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

8706 lines
306 KiB
C++
Raw Normal View History

[modules] Remove redundant import of lexical decls when building a lookup table for a DeclContext, and fix propagation of exception specifications along redeclaration chains. This reverts r232905, r232907, and r232907, which reverted r232793, r232853, and r232853. One additional change is present here to resolve issues with LLDB: distinguish between whether lexical decls missing from the lookup table are local or are provided by the external AST source, and still look in the external source if that's where they came from. llvm-svn: 232928
2015-03-23 11:25:59 +08:00
//===-- ASTReader.cpp - AST File Reader ----------------------------------===//
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
//
// 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 ASTReader class, which reads AST files.
//
//===----------------------------------------------------------------------===//
#include "clang/Serialization/ASTReader.h"
#include "ASTCommon.h"
#include "ASTReaderInternals.h"
#include "clang/AST/ASTConsumer.h"
#include "clang/AST/ASTContext.h"
#include "clang/AST/DeclTemplate.h"
#include "clang/AST/Expr.h"
#include "clang/AST/ExprCXX.h"
Introduce a PCHContainerOperations interface (NFC). A PCHContainerOperations abstract interface provides operations for creating and unwrapping containers for serialized ASTs (precompiled headers and clang modules). The default implementation is RawPCHContainerOperations, which uses a flat file for the output. The main application for this interface will be an ObjectFilePCHContainerOperations implementation that uses LLVM to wrap the module in an ELF/Mach-O/COFF container to store debug info alongside the AST. rdar://problem/20091852 llvm-svn: 240225
2015-06-21 02:53:08 +08:00
#include "clang/Frontend/PCHContainerOperations.h"
Re-commit r246497 (and dependent changes r246524 and r246521), reverted in r246546, with a workaround for an MSVC 2013 miscompile and an MSVC 2015 rejects-valid. Original commit message: [modules] Rework serialized DeclContext lookup table management. Instead of walking the loaded ModuleFiles looking for lookup tables for the context, store them all in one place, and merge them together if we find we have too many (currently, more than 4). If we do merge, include the merged form in our serialized lookup table, so that downstream readers never need to look at our imports' tables. This gives a huge performance improvement to builds with very large numbers of modules (in some cases, more than a 2x speedup was observed). llvm-svn: 246582
2015-09-02 04:35:42 +08:00
#include "clang/AST/ASTMutationListener.h"
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
#include "clang/AST/NestedNameSpecifier.h"
#include "clang/AST/Type.h"
#include "clang/AST/TypeLocVisitor.h"
Decouple ExprCXX.h and DeclCXX.h and clean up includes a bit. Required pulling LambdaExpr::Capture into its own header. No functionality change. llvm-svn: 208470
2014-05-11 00:31:55 +08:00
#include "clang/Basic/DiagnosticOptions.h"
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
#include "clang/Basic/FileManager.h"
#include "clang/Basic/SourceManager.h"
#include "clang/Basic/SourceManagerInternals.h"
#include "clang/Basic/TargetInfo.h"
#include "clang/Basic/TargetOptions.h"
#include "clang/Basic/Version.h"
#include "clang/Basic/VersionTuple.h"
Reapply r207477 and r207479 without cyclic dependency Fixed by moving ProcessWarningOptions from Frontend into Basic. All of the dependencies for ProcessWarningOptions were already in Basic, so this was a small change. llvm-svn: 207549
2014-04-30 00:25:26 +08:00
#include "clang/Frontend/Utils.h"
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
#include "clang/Lex/HeaderSearch.h"
#include "clang/Lex/HeaderSearchOptions.h"
#include "clang/Lex/MacroInfo.h"
#include "clang/Lex/PreprocessingRecord.h"
#include "clang/Lex/Preprocessor.h"
#include "clang/Lex/PreprocessorOptions.h"
#include "clang/Sema/Scope.h"
#include "clang/Sema/Sema.h"
#include "clang/Serialization/ASTDeserializationListener.h"
Implement the reader of the global module index and wire it into the AST reader. The global module index tracks all of the identifiers known to a set of module files. Lookup of those identifiers looks first in the global module index, which returns the set of module files in which that identifier can be found. The AST reader only needs to look into those module files and any module files not known to the global index (e.g., because they were (re)built after the global index), reducing the number of on-disk hash tables to visit. For an example source I'm looking at, we go from 237844 total identifier lookups into on-disk hash tables down to 126817. Unfortunately, this does not translate into a performance advantage. At best, it's a wash once the global module index has been built, but that's ignore the cost of building the global module index (which is itself fairly large). Profiles show that the global module index code is far less efficient than it should be; optimizing it might give enough of an advantage to justify its continued inclusion. llvm-svn: 173405
2013-01-25 09:03:03 +08:00
#include "clang/Serialization/GlobalModuleIndex.h"
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
#include "clang/Serialization/ModuleManager.h"
#include "clang/Serialization/SerializationDiagnostic.h"
[PCH] For HeaderFileInfoTrait, hash the key using size & time of the file. Previously the hash would be the filename portion of the path, which could be different for a filename with different case or a symbolic link with a different name completely. This did not actually create any issue so far because by validating all headers in the PCH we created uniqued FileEntries based on inodes, so an #include of a symbolic link (refering to a file from the PCH) would end up with a FileEntry with filename same as the one recorded in the PCH. llvm-svn: 176566
2013-03-07 02:12:47 +08:00
#include "llvm/ADT/Hashing.h"
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
#include "llvm/ADT/StringExtras.h"
#include "llvm/Bitcode/BitstreamReader.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/FileSystem.h"
#include "llvm/Support/MemoryBuffer.h"
#include "llvm/Support/Path.h"
#include "llvm/Support/SaveAndRestore.h"
Add an option to allow Clang verify source files for a module only once during the build When Clang loads the module, it verifies the user source files that the module was built from. If any file was changed, the module is rebuilt. There are two problems with this: 1. correctness: we don't verify system files (there are too many of them, and stat'ing all of them would take a lot of time); 2. performance: the same module file is verified again and again during a single build. This change allows the build system to optimize source file verification. The idea is based on the fact that while the project is being built, the source files don't change. This allows us to verify the module only once during a single build session. The build system passes a flag, -fbuild-session-timestamp=, to inform Clang of the time when the build started. The build system also requests to enable this feature by passing -fmodules-validate-once-per-build-session. If these flags are not passed, the behavior is not changed. When Clang verifies the module the first time, it writes out a timestamp file. Then, when Clang loads the module the second time, it finds a timestamp file, so it can compare the verification timestamp of the module with the time when the build started. If the verification timestamp is too old, the module is verified again, and the timestamp file is updated. llvm-svn: 201224
2014-02-12 18:33:14 +08:00
#include "llvm/Support/raw_ostream.h"
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
#include <algorithm>
add back a #include needed on some builders. llvm-svn: 172938
2013-01-20 08:57:52 +08:00
#include <cstdio>
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
#include <iterator>
Include system_error directly. llvm-svn: 210802
2014-06-13 01:19:42 +08:00
#include <system_error>
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
using namespace clang;
using namespace clang::serialization;
using namespace clang::serialization::reader;
finish converting the normal cases in ASTReader to use the new BitstreamCursor APIs. llvm-svn: 172937
2013-01-20 08:56:42 +08:00
using llvm::BitstreamCursor;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
Add dependencies from imported modules with -MD Add module dependencies to the dependency files created by -MD/-MMD/etc. by attaching an ASTReaderListener that will call into the dependency file generator when a module input file is seen in the serialized AST. llvm-svn: 203208
2014-03-07 14:40:32 +08:00
//===----------------------------------------------------------------------===//
// ChainedASTReaderListener implementation
//===----------------------------------------------------------------------===//
bool
ChainedASTReaderListener::ReadFullVersionInformation(StringRef FullVersion) {
return First->ReadFullVersionInformation(FullVersion) ||
Second->ReadFullVersionInformation(FullVersion);
}
Add module name and module map file to -module-file-info llvm-svn: 206217
2014-04-15 06:12:44 +08:00
void ChainedASTReaderListener::ReadModuleName(StringRef ModuleName) {
First->ReadModuleName(ModuleName);
Second->ReadModuleName(ModuleName);
}
void ChainedASTReaderListener::ReadModuleMapFile(StringRef ModuleMapPath) {
First->ReadModuleMapFile(ModuleMapPath);
Second->ReadModuleMapFile(ModuleMapPath);
}
[modules] When a .pcm file is explicitly built separately from the translation unit, allow the -O settings of the two compilations to differ. llvm-svn: 220943
2014-10-31 10:28:58 +08:00
bool
ChainedASTReaderListener::ReadLanguageOptions(const LangOptions &LangOpts,
bool Complain,
bool AllowCompatibleDifferences) {
return First->ReadLanguageOptions(LangOpts, Complain,
AllowCompatibleDifferences) ||
Second->ReadLanguageOptions(LangOpts, Complain,
AllowCompatibleDifferences);
Add dependencies from imported modules with -MD Add module dependencies to the dependency files created by -MD/-MMD/etc. by attaching an ASTReaderListener that will call into the dependency file generator when a module input file is seen in the serialized AST. llvm-svn: 203208
2014-03-07 14:40:32 +08:00
}
[modules] Teach the AST reader to handle the case of importing a module with a subset of the existing target CPU features or mismatched CPU names. While we can't check that the CPU name used to build the module will end up being able to codegen correctly for the translation unit, we actually check that the imported features are a subset of the existing features. While here, rewrite the code to use std::set_difference and have it diagnose all of the differences found. Test case added which walks the set relationships and ensures we diagnose all the right cases and accept the others. No functional change for implicit modules here, just better diagnostics. llvm-svn: 232248
2015-03-14 12:47:43 +08:00
bool ChainedASTReaderListener::ReadTargetOptions(
const TargetOptions &TargetOpts, bool Complain,
bool AllowCompatibleDifferences) {
return First->ReadTargetOptions(TargetOpts, Complain,
AllowCompatibleDifferences) ||
Second->ReadTargetOptions(TargetOpts, Complain,
AllowCompatibleDifferences);
Add dependencies from imported modules with -MD Add module dependencies to the dependency files created by -MD/-MMD/etc. by attaching an ASTReaderListener that will call into the dependency file generator when a module input file is seen in the serialized AST. llvm-svn: 203208
2014-03-07 14:40:32 +08:00
}
bool ChainedASTReaderListener::ReadDiagnosticOptions(
Reapply r207477 and r207479 without cyclic dependency Fixed by moving ProcessWarningOptions from Frontend into Basic. All of the dependencies for ProcessWarningOptions were already in Basic, so this was a small change. llvm-svn: 207549
2014-04-30 00:25:26 +08:00
IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts, bool Complain) {
Add dependencies from imported modules with -MD Add module dependencies to the dependency files created by -MD/-MMD/etc. by attaching an ASTReaderListener that will call into the dependency file generator when a module input file is seen in the serialized AST. llvm-svn: 203208
2014-03-07 14:40:32 +08:00
return First->ReadDiagnosticOptions(DiagOpts, Complain) ||
Second->ReadDiagnosticOptions(DiagOpts, Complain);
}
bool
ChainedASTReaderListener::ReadFileSystemOptions(const FileSystemOptions &FSOpts,
bool Complain) {
return First->ReadFileSystemOptions(FSOpts, Complain) ||
Second->ReadFileSystemOptions(FSOpts, Complain);
}
bool ChainedASTReaderListener::ReadHeaderSearchOptions(
[PCH/Modules] Check that the specific module cache path the PCH was built with, is the same as the one in the current compiler invocation. If they differ reject the PCH. This protects against the badness occurring from getting modules loaded from different module caches (see crashes). rdar://19889860 llvm-svn: 229909
2015-02-20 04:12:20 +08:00
const HeaderSearchOptions &HSOpts, StringRef SpecificModuleCachePath,
bool Complain) {
return First->ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
Complain) ||
Second->ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
Complain);
Add dependencies from imported modules with -MD Add module dependencies to the dependency files created by -MD/-MMD/etc. by attaching an ASTReaderListener that will call into the dependency file generator when a module input file is seen in the serialized AST. llvm-svn: 203208
2014-03-07 14:40:32 +08:00
}
bool ChainedASTReaderListener::ReadPreprocessorOptions(
const PreprocessorOptions &PPOpts, bool Complain,
std::string &SuggestedPredefines) {
return First->ReadPreprocessorOptions(PPOpts, Complain,
SuggestedPredefines) ||
Second->ReadPreprocessorOptions(PPOpts, Complain, SuggestedPredefines);
}
void ChainedASTReaderListener::ReadCounter(const serialization::ModuleFile &M,
unsigned Value) {
First->ReadCounter(M, Value);
Second->ReadCounter(M, Value);
}
bool ChainedASTReaderListener::needsInputFileVisitation() {
return First->needsInputFileVisitation() ||
Second->needsInputFileVisitation();
}
bool ChainedASTReaderListener::needsSystemInputFileVisitation() {
return First->needsSystemInputFileVisitation() ||
Second->needsSystemInputFileVisitation();
}
[modules] Change the way we deal with .d output for explicitly-specified module files: include the .pcm file itself in the .d output, rather than including its own input files. Other forms of module file continue to be transparent for .d output. Arguably, the input files for the .pcm file are still inputs to the compilation, but that's unnecessary for make-like build systems (where the mtime of the .pcm file is sufficient) and harmful for smarter build systems that know about module files and want to track only the local dependencies. llvm-svn: 244923
2015-08-14 01:57:10 +08:00
void ChainedASTReaderListener::visitModuleFile(StringRef Filename,
ModuleKind Kind) {
First->visitModuleFile(Filename, Kind);
Second->visitModuleFile(Filename, Kind);
[Modules] Emit the module file paths as dependencies of the PCH when we are building one. This is because the PCH is tied to the module files, if one of the module files changes or gets removed the build system should re-build the PCH file. rdar://16321245 llvm-svn: 203885
2014-03-14 11:07:38 +08:00
}
Add dependencies from imported modules with -MD Add module dependencies to the dependency files created by -MD/-MMD/etc. by attaching an ASTReaderListener that will call into the dependency file generator when a module input file is seen in the serialized AST. llvm-svn: 203208
2014-03-07 14:40:32 +08:00
bool ChainedASTReaderListener::visitInputFile(StringRef Filename,
[Modules] Make sure that the synthesized file "__inferred_module.map" doesn't show up as dependency of a module file. Follow-up for rdar://15459210 llvm-svn: 203882
2014-03-14 10:26:31 +08:00
bool isSystem,
[modules] Change the way we deal with .d output for explicitly-specified module files: include the .pcm file itself in the .d output, rather than including its own input files. Other forms of module file continue to be transparent for .d output. Arguably, the input files for the .pcm file are still inputs to the compilation, but that's unnecessary for make-like build systems (where the mtime of the .pcm file is sufficient) and harmful for smarter build systems that know about module files and want to track only the local dependencies. llvm-svn: 244923
2015-08-14 01:57:10 +08:00
bool isOverridden,
bool isExplicitModule) {
Frontend: Propagate ASTReaderListener API in ChainedASTReaderListener ASTReaderListener's documentation states that visitInputFile will be called based on the return values of needsInputFileVisitation and needsSystemInputFileVisitation, but ChainedASTReaderListener may call these methods on a child listener based on the values returned by the other child. Even worse, the calls to visitInputFile may be short-circuited due to the use of the boolean or, so the calls to visit may not occur at all for the second listener. This updates ChainedASTReaderListener::visitInputFile to propagate the ASTReaderListener behaviour to both children. llvm-svn: 209394
2014-05-22 14:04:59 +08:00
bool Continue = false;
if (First->needsInputFileVisitation() &&
(!isSystem || First->needsSystemInputFileVisitation()))
[modules] Change the way we deal with .d output for explicitly-specified module files: include the .pcm file itself in the .d output, rather than including its own input files. Other forms of module file continue to be transparent for .d output. Arguably, the input files for the .pcm file are still inputs to the compilation, but that's unnecessary for make-like build systems (where the mtime of the .pcm file is sufficient) and harmful for smarter build systems that know about module files and want to track only the local dependencies. llvm-svn: 244923
2015-08-14 01:57:10 +08:00
Continue |= First->visitInputFile(Filename, isSystem, isOverridden,
isExplicitModule);
Frontend: Propagate ASTReaderListener API in ChainedASTReaderListener ASTReaderListener's documentation states that visitInputFile will be called based on the return values of needsInputFileVisitation and needsSystemInputFileVisitation, but ChainedASTReaderListener may call these methods on a child listener based on the values returned by the other child. Even worse, the calls to visitInputFile may be short-circuited due to the use of the boolean or, so the calls to visit may not occur at all for the second listener. This updates ChainedASTReaderListener::visitInputFile to propagate the ASTReaderListener behaviour to both children. llvm-svn: 209394
2014-05-22 14:04:59 +08:00
if (Second->needsInputFileVisitation() &&
(!isSystem || Second->needsSystemInputFileVisitation()))
[modules] Change the way we deal with .d output for explicitly-specified module files: include the .pcm file itself in the .d output, rather than including its own input files. Other forms of module file continue to be transparent for .d output. Arguably, the input files for the .pcm file are still inputs to the compilation, but that's unnecessary for make-like build systems (where the mtime of the .pcm file is sufficient) and harmful for smarter build systems that know about module files and want to track only the local dependencies. llvm-svn: 244923
2015-08-14 01:57:10 +08:00
Continue |= Second->visitInputFile(Filename, isSystem, isOverridden,
isExplicitModule);
Frontend: Propagate ASTReaderListener API in ChainedASTReaderListener ASTReaderListener's documentation states that visitInputFile will be called based on the return values of needsInputFileVisitation and needsSystemInputFileVisitation, but ChainedASTReaderListener may call these methods on a child listener based on the values returned by the other child. Even worse, the calls to visitInputFile may be short-circuited due to the use of the boolean or, so the calls to visit may not occur at all for the second listener. This updates ChainedASTReaderListener::visitInputFile to propagate the ASTReaderListener behaviour to both children. llvm-svn: 209394
2014-05-22 14:04:59 +08:00
return Continue;
Add dependencies from imported modules with -MD Add module dependencies to the dependency files created by -MD/-MMD/etc. by attaching an ASTReaderListener that will call into the dependency file generator when a module input file is seen in the serialized AST. llvm-svn: 203208
2014-03-07 14:40:32 +08:00
}
Introduce module file extensions to piggy-back data onto module files. Introduce the notion of a module file extension, which introduces additional information into a module file at the time it is built that can then be queried when the module file is read. Module file extensions are identified by a block name (which must be unique to the extension) and can write any bitstream records into their own extension block within the module file. When a module file is loaded, any extension blocks are matched up with module file extension readers, that are per-module-file and are given access to the input bitstream. Note that module file extensions can only be introduced by programmatic clients that have access to the CompilerInvocation. There is only one such extension at the moment, which is used for testing the module file extension harness. As a future direction, one could imagine allowing the plugin mechanism to introduce new module file extensions. llvm-svn: 251955
2015-11-04 02:33:07 +08:00
void ChainedASTReaderListener::readModuleFileExtension(
const ModuleFileExtensionMetadata &Metadata) {
First->readModuleFileExtension(Metadata);
Second->readModuleFileExtension(Metadata);
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
//===----------------------------------------------------------------------===//
// PCH validator implementation
//===----------------------------------------------------------------------===//
Roll-back r250822. Summary: It breaks the build for the ASTMatchers Subscribers: klimek, cfe-commits Differential Revision: http://reviews.llvm.org/D13893 llvm-svn: 250827
2015-10-20 21:23:58 +08:00
ASTReaderListener::~ASTReaderListener() {}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
/// \brief Compare the given set of language options against an existing set of
/// language options.
///
/// \param Diags If non-NULL, diagnostics will be emitted via this engine.
[modules] When a .pcm file is explicitly built separately from the translation unit, allow the -O settings of the two compilations to differ. llvm-svn: 220943
2014-10-31 10:28:58 +08:00
/// \param AllowCompatibleDifferences If true, differences between compatible
/// language options will be permitted.
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
///
/// \returns true if the languagae options mis-match, false otherwise.
static bool checkLanguageOptions(const LangOptions &LangOpts,
const LangOptions &ExistingLangOpts,
[modules] When a .pcm file is explicitly built separately from the translation unit, allow the -O settings of the two compilations to differ. llvm-svn: 220943
2014-10-31 10:28:58 +08:00
DiagnosticsEngine *Diags,
bool AllowCompatibleDifferences = true) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
#define LANGOPT(Name, Bits, Default, Description) \
if (ExistingLangOpts.Name != LangOpts.Name) { \
if (Diags) \
Diags->Report(diag::err_pch_langopt_mismatch) \
<< Description << LangOpts.Name << ExistingLangOpts.Name; \
return true; \
}
#define VALUE_LANGOPT(Name, Bits, Default, Description) \
if (ExistingLangOpts.Name != LangOpts.Name) { \
if (Diags) \
Diags->Report(diag::err_pch_langopt_value_mismatch) \
<< Description; \
return true; \
}
#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
if (ExistingLangOpts.get##Name() != LangOpts.get##Name()) { \
if (Diags) \
Diags->Report(diag::err_pch_langopt_value_mismatch) \
<< Description; \
return true; \
}
[modules] When a .pcm file is explicitly built separately from the translation unit, allow the -O settings of the two compilations to differ. llvm-svn: 220943
2014-10-31 10:28:58 +08:00
#define COMPATIBLE_LANGOPT(Name, Bits, Default, Description) \
if (!AllowCompatibleDifferences) \
LANGOPT(Name, Bits, Default, Description)
#define COMPATIBLE_ENUM_LANGOPT(Name, Bits, Default, Description) \
if (!AllowCompatibleDifferences) \
ENUM_LANGOPT(Name, Bits, Default, Description)
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
#define BENIGN_LANGOPT(Name, Bits, Default, Description)
#define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
#include "clang/Basic/LangOptions.def"
[Modules] Consider -fmodule-feature in module hash and when loading Any extra features from -fmodule-feature are part of the module hash and need to get validated on load. Also print them with -module-file-info. llvm-svn: 240433
2015-06-24 02:20:18 +08:00
if (ExistingLangOpts.ModuleFeatures != LangOpts.ModuleFeatures) {
if (Diags)
Diags->Report(diag::err_pch_langopt_value_mismatch) << "module features";
return true;
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
if (ExistingLangOpts.ObjCRuntime != LangOpts.ObjCRuntime) {
if (Diags)
Diags->Report(diag::err_pch_langopt_value_mismatch)
<< "target Objective-C runtime";
return true;
}
Comment parsing: add CommentOptions to allow specifying custom comment block commands Add an ability to specify custom documentation block comment commands via a new class CommentOptions. The intention is that this class will hold future customizations for comment parsing, including defining documentation comments with specific numbers of parameters, etc. CommentOptions instance is a member of LangOptions. CommentOptions is controlled by a new command-line parameter -fcomment-block-commands=Foo,Bar,Baz. llvm-svn: 175892
2013-02-22 22:21:27 +08:00
if (ExistingLangOpts.CommentOpts.BlockCommandNames !=
LangOpts.CommentOpts.BlockCommandNames) {
if (Diags)
Diags->Report(diag::err_pch_langopt_value_mismatch)
<< "block command names";
return true;
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
return false;
}
/// \brief Compare the given set of target options against an existing set of
/// target options.
///
/// \param Diags If non-NULL, diagnostics will be emitted via this engine.
///
/// \returns true if the target options mis-match, false otherwise.
static bool checkTargetOptions(const TargetOptions &TargetOpts,
const TargetOptions &ExistingTargetOpts,
[modules] Teach the AST reader to handle the case of importing a module with a subset of the existing target CPU features or mismatched CPU names. While we can't check that the CPU name used to build the module will end up being able to codegen correctly for the translation unit, we actually check that the imported features are a subset of the existing features. While here, rewrite the code to use std::set_difference and have it diagnose all of the differences found. Test case added which walks the set relationships and ensures we diagnose all the right cases and accept the others. No functional change for implicit modules here, just better diagnostics. llvm-svn: 232248
2015-03-14 12:47:43 +08:00
DiagnosticsEngine *Diags,
bool AllowCompatibleDifferences = true) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
#define CHECK_TARGET_OPT(Field, Name) \
if (TargetOpts.Field != ExistingTargetOpts.Field) { \
if (Diags) \
Diags->Report(diag::err_pch_targetopt_mismatch) \
<< Name << TargetOpts.Field << ExistingTargetOpts.Field; \
return true; \
}
[modules] Teach the AST reader to handle the case of importing a module with a subset of the existing target CPU features or mismatched CPU names. While we can't check that the CPU name used to build the module will end up being able to codegen correctly for the translation unit, we actually check that the imported features are a subset of the existing features. While here, rewrite the code to use std::set_difference and have it diagnose all of the differences found. Test case added which walks the set relationships and ensures we diagnose all the right cases and accept the others. No functional change for implicit modules here, just better diagnostics. llvm-svn: 232248
2015-03-14 12:47:43 +08:00
// The triple and ABI must match exactly.
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
CHECK_TARGET_OPT(Triple, "target");
CHECK_TARGET_OPT(ABI, "target ABI");
[modules] Teach the AST reader to handle the case of importing a module with a subset of the existing target CPU features or mismatched CPU names. While we can't check that the CPU name used to build the module will end up being able to codegen correctly for the translation unit, we actually check that the imported features are a subset of the existing features. While here, rewrite the code to use std::set_difference and have it diagnose all of the differences found. Test case added which walks the set relationships and ensures we diagnose all the right cases and accept the others. No functional change for implicit modules here, just better diagnostics. llvm-svn: 232248
2015-03-14 12:47:43 +08:00
// We can tolerate different CPUs in many cases, notably when one CPU
// supports a strict superset of another. When allowing compatible
// differences skip this check.
if (!AllowCompatibleDifferences)
CHECK_TARGET_OPT(CPU, "target CPU");
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
#undef CHECK_TARGET_OPT
// Compare feature sets.
SmallVector<StringRef, 4> ExistingFeatures(
ExistingTargetOpts.FeaturesAsWritten.begin(),
ExistingTargetOpts.FeaturesAsWritten.end());
SmallVector<StringRef, 4> ReadFeatures(TargetOpts.FeaturesAsWritten.begin(),
TargetOpts.FeaturesAsWritten.end());
std::sort(ExistingFeatures.begin(), ExistingFeatures.end());
std::sort(ReadFeatures.begin(), ReadFeatures.end());
[modules] Teach the AST reader to handle the case of importing a module with a subset of the existing target CPU features or mismatched CPU names. While we can't check that the CPU name used to build the module will end up being able to codegen correctly for the translation unit, we actually check that the imported features are a subset of the existing features. While here, rewrite the code to use std::set_difference and have it diagnose all of the differences found. Test case added which walks the set relationships and ensures we diagnose all the right cases and accept the others. No functional change for implicit modules here, just better diagnostics. llvm-svn: 232248
2015-03-14 12:47:43 +08:00
// We compute the set difference in both directions explicitly so that we can
// diagnose the differences differently.
SmallVector<StringRef, 4> UnmatchedExistingFeatures, UnmatchedReadFeatures;
std::set_difference(
ExistingFeatures.begin(), ExistingFeatures.end(), ReadFeatures.begin(),
ReadFeatures.end(), std::back_inserter(UnmatchedExistingFeatures));
std::set_difference(ReadFeatures.begin(), ReadFeatures.end(),
ExistingFeatures.begin(), ExistingFeatures.end(),
std::back_inserter(UnmatchedReadFeatures));
// If we are allowing compatible differences and the read feature set is
// a strict subset of the existing feature set, there is nothing to diagnose.
if (AllowCompatibleDifferences && UnmatchedReadFeatures.empty())
return false;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
[modules] Teach the AST reader to handle the case of importing a module with a subset of the existing target CPU features or mismatched CPU names. While we can't check that the CPU name used to build the module will end up being able to codegen correctly for the translation unit, we actually check that the imported features are a subset of the existing features. While here, rewrite the code to use std::set_difference and have it diagnose all of the differences found. Test case added which walks the set relationships and ensures we diagnose all the right cases and accept the others. No functional change for implicit modules here, just better diagnostics. llvm-svn: 232248
2015-03-14 12:47:43 +08:00
if (Diags) {
for (StringRef Feature : UnmatchedReadFeatures)
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
Diags->Report(diag::err_pch_targetopt_feature_mismatch)
[modules] Teach the AST reader to handle the case of importing a module with a subset of the existing target CPU features or mismatched CPU names. While we can't check that the CPU name used to build the module will end up being able to codegen correctly for the translation unit, we actually check that the imported features are a subset of the existing features. While here, rewrite the code to use std::set_difference and have it diagnose all of the differences found. Test case added which walks the set relationships and ensures we diagnose all the right cases and accept the others. No functional change for implicit modules here, just better diagnostics. llvm-svn: 232248
2015-03-14 12:47:43 +08:00
<< /* is-existing-feature */ false << Feature;
for (StringRef Feature : UnmatchedExistingFeatures)
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
Diags->Report(diag::err_pch_targetopt_feature_mismatch)
[modules] Teach the AST reader to handle the case of importing a module with a subset of the existing target CPU features or mismatched CPU names. While we can't check that the CPU name used to build the module will end up being able to codegen correctly for the translation unit, we actually check that the imported features are a subset of the existing features. While here, rewrite the code to use std::set_difference and have it diagnose all of the differences found. Test case added which walks the set relationships and ensures we diagnose all the right cases and accept the others. No functional change for implicit modules here, just better diagnostics. llvm-svn: 232248
2015-03-14 12:47:43 +08:00
<< /* is-existing-feature */ true << Feature;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
[modules] Teach the AST reader to handle the case of importing a module with a subset of the existing target CPU features or mismatched CPU names. While we can't check that the CPU name used to build the module will end up being able to codegen correctly for the translation unit, we actually check that the imported features are a subset of the existing features. While here, rewrite the code to use std::set_difference and have it diagnose all of the differences found. Test case added which walks the set relationships and ensures we diagnose all the right cases and accept the others. No functional change for implicit modules here, just better diagnostics. llvm-svn: 232248
2015-03-14 12:47:43 +08:00
return !UnmatchedReadFeatures.empty() || !UnmatchedExistingFeatures.empty();
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
bool
PCHValidator::ReadLanguageOptions(const LangOptions &LangOpts,
[modules] When a .pcm file is explicitly built separately from the translation unit, allow the -O settings of the two compilations to differ. llvm-svn: 220943
2014-10-31 10:28:58 +08:00
bool Complain,
bool AllowCompatibleDifferences) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
const LangOptions &ExistingLangOpts = PP.getLangOpts();
return checkLanguageOptions(LangOpts, ExistingLangOpts,
[modules] When a .pcm file is explicitly built separately from the translation unit, allow the -O settings of the two compilations to differ. llvm-svn: 220943
2014-10-31 10:28:58 +08:00
Complain ? &Reader.Diags : nullptr,
AllowCompatibleDifferences);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
bool PCHValidator::ReadTargetOptions(const TargetOptions &TargetOpts,
[modules] Teach the AST reader to handle the case of importing a module with a subset of the existing target CPU features or mismatched CPU names. While we can't check that the CPU name used to build the module will end up being able to codegen correctly for the translation unit, we actually check that the imported features are a subset of the existing features. While here, rewrite the code to use std::set_difference and have it diagnose all of the differences found. Test case added which walks the set relationships and ensures we diagnose all the right cases and accept the others. No functional change for implicit modules here, just better diagnostics. llvm-svn: 232248
2015-03-14 12:47:43 +08:00
bool Complain,
bool AllowCompatibleDifferences) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
const TargetOptions &ExistingTargetOpts = PP.getTargetInfo().getTargetOpts();
return checkTargetOptions(TargetOpts, ExistingTargetOpts,
[modules] Teach the AST reader to handle the case of importing a module with a subset of the existing target CPU features or mismatched CPU names. While we can't check that the CPU name used to build the module will end up being able to codegen correctly for the translation unit, we actually check that the imported features are a subset of the existing features. While here, rewrite the code to use std::set_difference and have it diagnose all of the differences found. Test case added which walks the set relationships and ensures we diagnose all the right cases and accept the others. No functional change for implicit modules here, just better diagnostics. llvm-svn: 232248
2015-03-14 12:47:43 +08:00
Complain ? &Reader.Diags : nullptr,
AllowCompatibleDifferences);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
namespace {
typedef llvm::StringMap<std::pair<StringRef, bool /*IsUndef*/> >
MacroDefinitionsMap;
Use typedef for Densemap contraining SmallVector passed to a function to avoid repeating SmallVector size. llvm-svn: 185683
2013-07-05 12:43:31 +08:00
typedef llvm::DenseMap<DeclarationName, SmallVector<NamedDecl *, 8> >
DeclsMap;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
Reapply r207477 and r207479 without cyclic dependency Fixed by moving ProcessWarningOptions from Frontend into Basic. All of the dependencies for ProcessWarningOptions were already in Basic, so this was a small change. llvm-svn: 207549
2014-04-30 00:25:26 +08:00
static bool checkDiagnosticGroupMappings(DiagnosticsEngine &StoredDiags,
DiagnosticsEngine &Diags,
bool Complain) {
typedef DiagnosticsEngine::Level Level;
// Check current mappings for new -Werror mappings, and the stored mappings
// for cases that were explicitly mapped to *not* be errors that are now
// errors because of options like -Werror.
DiagnosticsEngine *MappingSources[] = { &Diags, &StoredDiags };
for (DiagnosticsEngine *MappingSource : MappingSources) {
for (auto DiagIDMappingPair : MappingSource->getDiagnosticMappings()) {
diag::kind DiagID = DiagIDMappingPair.first;
Level CurLevel = Diags.getDiagnosticLevel(DiagID, SourceLocation());
if (CurLevel < DiagnosticsEngine::Error)
continue; // not significant
Level StoredLevel =
StoredDiags.getDiagnosticLevel(DiagID, SourceLocation());
if (StoredLevel < DiagnosticsEngine::Error) {
if (Complain)
Diags.Report(diag::err_pch_diagopt_mismatch) << "-Werror=" +
Diags.getDiagnosticIDs()->getWarningOptionForDiag(DiagID).str();
return true;
}
}
}
return false;
}
DiagnosticIDs: use diagnostic severities to simplify extension handling llvm-svn: 211479
2014-06-23 05:58:33 +08:00
static bool isExtHandlingFromDiagsError(DiagnosticsEngine &Diags) {
diag::Severity Ext = Diags.getExtensionHandlingBehavior();
if (Ext == diag::Severity::Warning && Diags.getWarningsAsErrors())
return true;
return Ext >= diag::Severity::Error;
Reapply r207477 and r207479 without cyclic dependency Fixed by moving ProcessWarningOptions from Frontend into Basic. All of the dependencies for ProcessWarningOptions were already in Basic, so this was a small change. llvm-svn: 207549
2014-04-30 00:25:26 +08:00
}
static bool checkDiagnosticMappings(DiagnosticsEngine &StoredDiags,
DiagnosticsEngine &Diags,
bool IsSystem, bool Complain) {
// Top-level options
if (IsSystem) {
if (Diags.getSuppressSystemWarnings())
return false;
// If -Wsystem-headers was not enabled before, be conservative
if (StoredDiags.getSuppressSystemWarnings()) {
if (Complain)
Diags.Report(diag::err_pch_diagopt_mismatch) << "-Wsystem-headers";
return true;
}
}
if (Diags.getWarningsAsErrors() && !StoredDiags.getWarningsAsErrors()) {
if (Complain)
Diags.Report(diag::err_pch_diagopt_mismatch) << "-Werror";
return true;
}
if (Diags.getWarningsAsErrors() && Diags.getEnableAllWarnings() &&
!StoredDiags.getEnableAllWarnings()) {
if (Complain)
Diags.Report(diag::err_pch_diagopt_mismatch) << "-Weverything -Werror";
return true;
}
if (isExtHandlingFromDiagsError(Diags) &&
!isExtHandlingFromDiagsError(StoredDiags)) {
if (Complain)
Diags.Report(diag::err_pch_diagopt_mismatch) << "-pedantic-errors";
return true;
}
return checkDiagnosticGroupMappings(StoredDiags, Diags, Complain);
}
bool PCHValidator::ReadDiagnosticOptions(
IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts, bool Complain) {
DiagnosticsEngine &ExistingDiags = PP.getDiagnostics();
IntrusiveRefCntPtr<DiagnosticIDs> DiagIDs(ExistingDiags.getDiagnosticIDs());
IntrusiveRefCntPtr<DiagnosticsEngine> Diags(
Track IntrusiveRefCntPtr::get() changes from LLVM r212366 llvm-svn: 212369
2014-07-05 11:08:06 +08:00
new DiagnosticsEngine(DiagIDs, DiagOpts.get()));
Reapply r207477 and r207479 without cyclic dependency Fixed by moving ProcessWarningOptions from Frontend into Basic. All of the dependencies for ProcessWarningOptions were already in Basic, so this was a small change. llvm-svn: 207549
2014-04-30 00:25:26 +08:00
// This should never fail, because we would have processed these options
// before writing them to an ASTFile.
ProcessWarningOptions(*Diags, *DiagOpts, /*Report*/false);
ModuleManager &ModuleMgr = Reader.getModuleManager();
assert(ModuleMgr.size() >= 1 && "what ASTFile is this then");
// If the original import came from a file explicitly generated by the user,
// don't check the diagnostic mappings.
// FIXME: currently this is approximated by checking whether this is not a
[modules] Initial support for explicitly loading .pcm files. Implicit module builds are not well-suited to a lot of build systems. In particular, they fare badly in distributed build systems, and they lead to build artifacts that are not tracked as part of the usual dependency management process. This change allows explicitly-built module files (which are already supported through the -emit-module flag) to be explicitly loaded into a build, allowing build systems to opt to manage module builds and dependencies themselves. This is only the first step in supporting such configurations, and it should be considered experimental and subject to change or removal for now. llvm-svn: 220359
2014-10-22 10:05:46 +08:00
// module import of an implicitly-loaded module file.
Reapply r207477 and r207479 without cyclic dependency Fixed by moving ProcessWarningOptions from Frontend into Basic. All of the dependencies for ProcessWarningOptions were already in Basic, so this was a small change. llvm-svn: 207549
2014-04-30 00:25:26 +08:00
// Note: ModuleMgr.rbegin() may not be the current module, but it must be in
// the transitive closure of its imports, since unrelated modules cannot be
// imported until after this module finishes validation.
ModuleFile *TopImport = *ModuleMgr.rbegin();
while (!TopImport->ImportedBy.empty())
TopImport = TopImport->ImportedBy[0];
[modules] Initial support for explicitly loading .pcm files. Implicit module builds are not well-suited to a lot of build systems. In particular, they fare badly in distributed build systems, and they lead to build artifacts that are not tracked as part of the usual dependency management process. This change allows explicitly-built module files (which are already supported through the -emit-module flag) to be explicitly loaded into a build, allowing build systems to opt to manage module builds and dependencies themselves. This is only the first step in supporting such configurations, and it should be considered experimental and subject to change or removal for now. llvm-svn: 220359
2014-10-22 10:05:46 +08:00
if (TopImport->Kind != MK_ImplicitModule)
Reapply r207477 and r207479 without cyclic dependency Fixed by moving ProcessWarningOptions from Frontend into Basic. All of the dependencies for ProcessWarningOptions were already in Basic, so this was a small change. llvm-svn: 207549
2014-04-30 00:25:26 +08:00
return false;
StringRef ModuleName = TopImport->ModuleName;
assert(!ModuleName.empty() && "diagnostic options read before module name");
Module *M = PP.getHeaderSearchInfo().lookupModule(ModuleName);
assert(M && "missing module");
// FIXME: if the diagnostics are incompatible, save a DiagnosticOptions that
// contains the union of their flags.
return checkDiagnosticMappings(*Diags, ExistingDiags, M->IsSystem, Complain);
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
/// \brief Collect the macro definitions provided by the given preprocessor
/// options.
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
static void
collectMacroDefinitions(const PreprocessorOptions &PPOpts,
MacroDefinitionsMap &Macros,
SmallVectorImpl<StringRef> *MacroNames = nullptr) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
for (unsigned I = 0, N = PPOpts.Macros.size(); I != N; ++I) {
StringRef Macro = PPOpts.Macros[I].first;
bool IsUndef = PPOpts.Macros[I].second;
std::pair<StringRef, StringRef> MacroPair = Macro.split('=');
StringRef MacroName = MacroPair.first;
StringRef MacroBody = MacroPair.second;
// For an #undef'd macro, we only care about the name.
if (IsUndef) {
if (MacroNames && !Macros.count(MacroName))
MacroNames->push_back(MacroName);
Macros[MacroName] = std::make_pair("", true);
continue;
}
// For a #define'd macro, figure out the actual definition.
if (MacroName.size() == Macro.size())
MacroBody = "1";
else {
// Note: GCC drops anything following an end-of-line character.
StringRef::size_type End = MacroBody.find_first_of("\n\r");
MacroBody = MacroBody.substr(0, End);
}
if (MacroNames && !Macros.count(MacroName))
MacroNames->push_back(MacroName);
Macros[MacroName] = std::make_pair(MacroBody, false);
}
}
[PCH/Modules] Check that the specific module cache path the PCH was built with, is the same as the one in the current compiler invocation. If they differ reject the PCH. This protects against the badness occurring from getting modules loaded from different module caches (see crashes). rdar://19889860 llvm-svn: 229909
2015-02-20 04:12:20 +08:00
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
/// \brief Check the preprocessor options deserialized from the control block
/// against the preprocessor options in an existing preprocessor.
///
/// \param Diags If non-null, produce diagnostics for any mismatches incurred.
static bool checkPreprocessorOptions(const PreprocessorOptions &PPOpts,
const PreprocessorOptions &ExistingPPOpts,
DiagnosticsEngine *Diags,
FileManager &FileMgr,
[PCH/modules] Require the preprocessing record option to match the used PCH, if modules are enabled. The preprocessing record becomes important when modules are enabled, since it is used to calculate the module cache hash. llvm-svn: 180635
2013-04-27 05:33:40 +08:00
std::string &SuggestedPredefines,
const LangOptions &LangOpts) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
// Check macro definitions.
MacroDefinitionsMap ASTFileMacros;
collectMacroDefinitions(PPOpts, ASTFileMacros);
MacroDefinitionsMap ExistingMacros;
SmallVector<StringRef, 4> ExistingMacroNames;
collectMacroDefinitions(ExistingPPOpts, ExistingMacros, &ExistingMacroNames);
for (unsigned I = 0, N = ExistingMacroNames.size(); I != N; ++I) {
// Dig out the macro definition in the existing preprocessor options.
StringRef MacroName = ExistingMacroNames[I];
std::pair<StringRef, bool> Existing = ExistingMacros[MacroName];
// Check whether we know anything about this macro name or not.
llvm::StringMap<std::pair<StringRef, bool /*IsUndef*/> >::iterator Known
= ASTFileMacros.find(MacroName);
if (Known == ASTFileMacros.end()) {
// FIXME: Check whether this identifier was referenced anywhere in the
// AST file. If so, we should reject the AST file. Unfortunately, this
// information isn't in the control block. What shall we do about it?
if (Existing.second) {
SuggestedPredefines += "#undef ";
SuggestedPredefines += MacroName.str();
SuggestedPredefines += '\n';
} else {
SuggestedPredefines += "#define ";
SuggestedPredefines += MacroName.str();
SuggestedPredefines += ' ';
SuggestedPredefines += Existing.first.str();
SuggestedPredefines += '\n';
}
continue;
}
// If the macro was defined in one but undef'd in the other, we have a
// conflict.
if (Existing.second != Known->second.second) {
if (Diags) {
Diags->Report(diag::err_pch_macro_def_undef)
<< MacroName << Known->second.second;
}
return true;
}
// If the macro was #undef'd in both, or if the macro bodies are identical,
// it's fine.
if (Existing.second || Existing.first == Known->second.first)
continue;
// The macro bodies differ; complain.
if (Diags) {
Diags->Report(diag::err_pch_macro_def_conflict)
<< MacroName << Known->second.first << Existing.first;
}
return true;
}
// Check whether we're using predefines.
if (PPOpts.UsePredefines != ExistingPPOpts.UsePredefines) {
if (Diags) {
Diags->Report(diag::err_pch_undef) << ExistingPPOpts.UsePredefines;
}
return true;
}
[PCH/modules] Require the preprocessing record option to match the used PCH, if modules are enabled. The preprocessing record becomes important when modules are enabled, since it is used to calculate the module cache hash. llvm-svn: 180635
2013-04-27 05:33:40 +08:00
// Detailed record is important since it is used for the module cache hash.
if (LangOpts.Modules &&
PPOpts.DetailedRecord != ExistingPPOpts.DetailedRecord) {
if (Diags) {
Diags->Report(diag::err_pch_pp_detailed_record) << PPOpts.DetailedRecord;
}
return true;
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
// Compute the #include and #include_macros lines we need.
for (unsigned I = 0, N = ExistingPPOpts.Includes.size(); I != N; ++I) {
StringRef File = ExistingPPOpts.Includes[I];
if (File == ExistingPPOpts.ImplicitPCHInclude)
continue;
if (std::find(PPOpts.Includes.begin(), PPOpts.Includes.end(), File)
!= PPOpts.Includes.end())
continue;
SuggestedPredefines += "#include \"";
Correctly implement -include search logic. According to the gcc docs, -include uses the current working directory for the lookup instead of the main source file. This patch gets rid of NormalizeIncludePath (which relied on an implementation detail of FileManager / FileEntry for the include path logic to work), and instead hands the correct lookup information down to LookupFile. This will allow us to change the FileEntry's behavior regarding its Name caching. llvm-svn: 215433
2014-08-12 16:25:57 +08:00
SuggestedPredefines += File;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
SuggestedPredefines += "\"\n";
}
for (unsigned I = 0, N = ExistingPPOpts.MacroIncludes.size(); I != N; ++I) {
StringRef File = ExistingPPOpts.MacroIncludes[I];
if (std::find(PPOpts.MacroIncludes.begin(), PPOpts.MacroIncludes.end(),
File)
!= PPOpts.MacroIncludes.end())
continue;
SuggestedPredefines += "#__include_macros \"";
Correctly implement -include search logic. According to the gcc docs, -include uses the current working directory for the lookup instead of the main source file. This patch gets rid of NormalizeIncludePath (which relied on an implementation detail of FileManager / FileEntry for the include path logic to work), and instead hands the correct lookup information down to LookupFile. This will allow us to change the FileEntry's behavior regarding its Name caching. llvm-svn: 215433
2014-08-12 16:25:57 +08:00
SuggestedPredefines += File;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
SuggestedPredefines += "\"\n##\n";
}
return false;
}
bool PCHValidator::ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
bool Complain,
std::string &SuggestedPredefines) {
const PreprocessorOptions &ExistingPPOpts = PP.getPreprocessorOpts();
return checkPreprocessorOptions(PPOpts, ExistingPPOpts,
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
Complain? &Reader.Diags : nullptr,
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
PP.getFileManager(),
[PCH/modules] Require the preprocessing record option to match the used PCH, if modules are enabled. The preprocessing record becomes important when modules are enabled, since it is used to calculate the module cache hash. llvm-svn: 180635
2013-04-27 05:33:40 +08:00
SuggestedPredefines,
PP.getLangOpts());
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
[PCH/Modules] Check that the specific module cache path the PCH was built with, is the same as the one in the current compiler invocation. If they differ reject the PCH. This protects against the badness occurring from getting modules loaded from different module caches (see crashes). rdar://19889860 llvm-svn: 229909
2015-02-20 04:12:20 +08:00
/// Check the header search options deserialized from the control block
/// against the header search options in an existing preprocessor.
///
/// \param Diags If non-null, produce diagnostics for any mismatches incurred.
static bool checkHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
StringRef SpecificModuleCachePath,
StringRef ExistingModuleCachePath,
DiagnosticsEngine *Diags,
const LangOptions &LangOpts) {
if (LangOpts.Modules) {
if (SpecificModuleCachePath != ExistingModuleCachePath) {
if (Diags)
Diags->Report(diag::err_pch_modulecache_mismatch)
<< SpecificModuleCachePath << ExistingModuleCachePath;
return true;
}
}
return false;
}
bool PCHValidator::ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
StringRef SpecificModuleCachePath,
bool Complain) {
return checkHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
PP.getHeaderSearchInfo().getModuleCachePath(),
Complain ? &Reader.Diags : nullptr,
PP.getLangOpts());
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
void PCHValidator::ReadCounter(const ModuleFile &M, unsigned Value) {
PP.setCounterValue(Value);
}
//===----------------------------------------------------------------------===//
// AST reader implementation
//===----------------------------------------------------------------------===//
Let ASTReader optionally delete its ASTDeserializationListener. Use this to fix the leak of DeserializedDeclsDumper and DeserializedDeclsChecker in FrontendAction (found by LSan), PR19560. The "delete this" bool is necessary because both PCHGenerator and ASTUnit return the same object from both getDeserializationListener() and getASTMutationListener(), so ASTReader can't just have a unique_ptr. It's also not possible to just let FrontendAction (or CompilerInstance) own these listeners due to lifetime issues (see comments on PR19560). Finally, ASTDeserializationListener can't easily be refcounted, since several of the current listeners are allocated on the stack. Having this bool isn't ideal, but it's a pattern that's used in other places in the codebase too, and it seems better than leaking. llvm-svn: 208277
2014-05-08 12:26:47 +08:00
void ASTReader::setDeserializationListener(ASTDeserializationListener *Listener,
bool TakeOwnership) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
DeserializationListener = Listener;
Let ASTReader optionally delete its ASTDeserializationListener. Use this to fix the leak of DeserializedDeclsDumper and DeserializedDeclsChecker in FrontendAction (found by LSan), PR19560. The "delete this" bool is necessary because both PCHGenerator and ASTUnit return the same object from both getDeserializationListener() and getASTMutationListener(), so ASTReader can't just have a unique_ptr. It's also not possible to just let FrontendAction (or CompilerInstance) own these listeners due to lifetime issues (see comments on PR19560). Finally, ASTDeserializationListener can't easily be refcounted, since several of the current listeners are allocated on the stack. Having this bool isn't ideal, but it's a pattern that's used in other places in the codebase too, and it seems better than leaking. llvm-svn: 208277
2014-05-08 12:26:47 +08:00
OwnsDeserializationListener = TakeOwnership;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
unsigned ASTSelectorLookupTrait::ComputeHash(Selector Sel) {
return serialization::ComputeHash(Sel);
}
std::pair<unsigned, unsigned>
ASTSelectorLookupTrait::ReadKeyDataLength(const unsigned char*& d) {
Reapply "OnDiskHashTable: Use Endian.h to read little endian ostreams" Committed this by accident before it was done last time. Original message: Rather than rolling our own functions to read little endian data from a buffer, we can use the support in llvm's Endian.h. No functional change. llvm-svn: 205062
2014-03-29 06:03:24 +08:00
using namespace llvm::support;
unsigned KeyLen = endian::readNext<uint16_t, little, unaligned>(d);
unsigned DataLen = endian::readNext<uint16_t, little, unaligned>(d);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
return std::make_pair(KeyLen, DataLen);
}
ASTSelectorLookupTrait::internal_key_type
ASTSelectorLookupTrait::ReadKey(const unsigned char* d, unsigned) {
Reapply "OnDiskHashTable: Use Endian.h to read little endian ostreams" Committed this by accident before it was done last time. Original message: Rather than rolling our own functions to read little endian data from a buffer, we can use the support in llvm's Endian.h. No functional change. llvm-svn: 205062
2014-03-29 06:03:24 +08:00
using namespace llvm::support;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
SelectorTable &SelTable = Reader.getContext().Selectors;
Reapply "OnDiskHashTable: Use Endian.h to read little endian ostreams" Committed this by accident before it was done last time. Original message: Rather than rolling our own functions to read little endian data from a buffer, we can use the support in llvm's Endian.h. No functional change. llvm-svn: 205062
2014-03-29 06:03:24 +08:00
unsigned N = endian::readNext<uint16_t, little, unaligned>(d);
IdentifierInfo *FirstII = Reader.getLocalIdentifier(
F, endian::readNext<uint32_t, little, unaligned>(d));
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
if (N == 0)
return SelTable.getNullarySelector(FirstII);
else if (N == 1)
return SelTable.getUnarySelector(FirstII);
SmallVector<IdentifierInfo *, 16> Args;
Args.push_back(FirstII);
for (unsigned I = 1; I != N; ++I)
Reapply "OnDiskHashTable: Use Endian.h to read little endian ostreams" Committed this by accident before it was done last time. Original message: Rather than rolling our own functions to read little endian data from a buffer, we can use the support in llvm's Endian.h. No functional change. llvm-svn: 205062
2014-03-29 06:03:24 +08:00
Args.push_back(Reader.getLocalIdentifier(
F, endian::readNext<uint32_t, little, unaligned>(d)));
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
return SelTable.getSelector(N, Args.data());
}
ASTSelectorLookupTrait::data_type
ASTSelectorLookupTrait::ReadData(Selector, const unsigned char* d,
unsigned DataLen) {
Reapply "OnDiskHashTable: Use Endian.h to read little endian ostreams" Committed this by accident before it was done last time. Original message: Rather than rolling our own functions to read little endian data from a buffer, we can use the support in llvm's Endian.h. No functional change. llvm-svn: 205062
2014-03-29 06:03:24 +08:00
using namespace llvm::support;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
data_type Result;
Reapply "OnDiskHashTable: Use Endian.h to read little endian ostreams" Committed this by accident before it was done last time. Original message: Rather than rolling our own functions to read little endian data from a buffer, we can use the support in llvm's Endian.h. No functional change. llvm-svn: 205062
2014-03-29 06:03:24 +08:00
Result.ID = Reader.getGlobalSelectorID(
F, endian::readNext<uint32_t, little, unaligned>(d));
Objective-C: Serialize "more than one decl" state of ObjCMethodList. This fixes PR21587, what r221933 fixed for regular programs is now also fixed for decls coming from PCH files. Use another bit from the count/bits uint16_t for storing the "more than one decl" bit. This reduces the number of bits for the count from 14 to 13. The selector with the most overloads in Cocoa.h has ~55 overloads, so 13 bits should still be plenty. Since this changes the meaning of a serialized bit pattern, also increase clang::serialization::VERSION_MAJOR. Storing the "more than one decl" state of only the first overload isn't quite correct, but Sema::AreMultipleMethodsInGlobalPool() currently only looks at the state of the first overload so it's good enough for now. llvm-svn: 224892
2014-12-28 06:14:15 +08:00
unsigned FullInstanceBits = endian::readNext<uint16_t, little, unaligned>(d);
unsigned FullFactoryBits = endian::readNext<uint16_t, little, unaligned>(d);
Result.InstanceBits = FullInstanceBits & 0x3;
Result.InstanceHasMoreThanOneDecl = (FullInstanceBits >> 2) & 0x1;
Result.FactoryBits = FullFactoryBits & 0x3;
Result.FactoryHasMoreThanOneDecl = (FullFactoryBits >> 2) & 0x1;
unsigned NumInstanceMethods = FullInstanceBits >> 3;
unsigned NumFactoryMethods = FullFactoryBits >> 3;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
// Load instance methods
for (unsigned I = 0; I != NumInstanceMethods; ++I) {
Reapply "OnDiskHashTable: Use Endian.h to read little endian ostreams" Committed this by accident before it was done last time. Original message: Rather than rolling our own functions to read little endian data from a buffer, we can use the support in llvm's Endian.h. No functional change. llvm-svn: 205062
2014-03-29 06:03:24 +08:00
if (ObjCMethodDecl *Method = Reader.GetLocalDeclAs<ObjCMethodDecl>(
F, endian::readNext<uint32_t, little, unaligned>(d)))
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
Result.Instance.push_back(Method);
}
// Load factory methods
for (unsigned I = 0; I != NumFactoryMethods; ++I) {
Reapply "OnDiskHashTable: Use Endian.h to read little endian ostreams" Committed this by accident before it was done last time. Original message: Rather than rolling our own functions to read little endian data from a buffer, we can use the support in llvm's Endian.h. No functional change. llvm-svn: 205062
2014-03-29 06:03:24 +08:00
if (ObjCMethodDecl *Method = Reader.GetLocalDeclAs<ObjCMethodDecl>(
F, endian::readNext<uint32_t, little, unaligned>(d)))
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
Result.Factory.push_back(Method);
}
return Result;
}
Factor the trait for lookup into the on-based hash table of identifiers into two parts: the part that involves dealing with the key (which can be re-used) and the ASTReader-specific part that creates the IdentifierInfos. While I'm at it, StringRef'ify this code, which was using pair<const char*, unsigned>. No functionality change. llvm-svn: 173283
2013-01-24 02:53:14 +08:00
unsigned ASTIdentifierLookupTraitBase::ComputeHash(const internal_key_type& a) {
return llvm::HashString(a);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
std::pair<unsigned, unsigned>
Factor the trait for lookup into the on-based hash table of identifiers into two parts: the part that involves dealing with the key (which can be re-used) and the ASTReader-specific part that creates the IdentifierInfos. While I'm at it, StringRef'ify this code, which was using pair<const char*, unsigned>. No functionality change. llvm-svn: 173283
2013-01-24 02:53:14 +08:00
ASTIdentifierLookupTraitBase::ReadKeyDataLength(const unsigned char*& d) {
Reapply "OnDiskHashTable: Use Endian.h to read little endian ostreams" Committed this by accident before it was done last time. Original message: Rather than rolling our own functions to read little endian data from a buffer, we can use the support in llvm's Endian.h. No functional change. llvm-svn: 205062
2014-03-29 06:03:24 +08:00
using namespace llvm::support;
unsigned DataLen = endian::readNext<uint16_t, little, unaligned>(d);
unsigned KeyLen = endian::readNext<uint16_t, little, unaligned>(d);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
return std::make_pair(KeyLen, DataLen);
}
Factor the trait for lookup into the on-based hash table of identifiers into two parts: the part that involves dealing with the key (which can be re-used) and the ASTReader-specific part that creates the IdentifierInfos. While I'm at it, StringRef'ify this code, which was using pair<const char*, unsigned>. No functionality change. llvm-svn: 173283
2013-01-24 02:53:14 +08:00
ASTIdentifierLookupTraitBase::internal_key_type
ASTIdentifierLookupTraitBase::ReadKey(const unsigned char* d, unsigned n) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
assert(n >= 2 && d[n-1] == '\0');
Factor the trait for lookup into the on-based hash table of identifiers into two parts: the part that involves dealing with the key (which can be re-used) and the ASTReader-specific part that creates the IdentifierInfos. While I'm at it, StringRef'ify this code, which was using pair<const char*, unsigned>. No functionality change. llvm-svn: 173283
2013-01-24 02:53:14 +08:00
return StringRef((const char*) d, n-1);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
[Modules] Cope better with top-level declarations loaded after being declared in the current translation unit <rdar://problem/13189985>. These two related tweaks to keep the information associated with a given identifier correct when the identifier has been given some top-level information (say, a top-level declaration) and more information is then loaded from a module. The first ensures that an identifier that was "interesting" before being loaded from an AST is considered to be different from its on-disk counterpart. Otherwise, we lose such changes when writing the current translation unit as a module. Second, teach the code that injects AST-loaded names into the identifier chain for name lookup to keep the most recent declaration, so that we don't end up confusing our declaration chains by having a different declaration in there. llvm-svn: 174895
2013-02-12 02:16:18 +08:00
/// \brief Whether the given identifier is "interesting".
[modules] In C++, stop serializing and deserializing a list of declarations in the identifier table. This is redundant, since the TU-scope lookups are also serialized as part of the TU DeclContext, and wasteful in a number of ways. We still emit the decls for PCH / preamble builds, since for those we want identical results, not merely semantically equivalent ones. llvm-svn: 242855
2015-07-22 07:54:07 +08:00
static bool isInterestingIdentifier(ASTReader &Reader, IdentifierInfo &II,
bool IsModule) {
Stop treating extension keywords as 'interesting'; we don't allow the extension flag to change between serialization and deserialization, so it does not require the identifier to be serialized. llvm-svn: 242567
2015-07-18 04:19:56 +08:00
return II.hadMacroDefinition() ||
II.isPoisoned() ||
[modules] Don't save uninteresting identifiers, and don't consider identifiers to be interesting just because they are the name of a builtin. Reduces the size of an empty module by over 80% (~100KB). llvm-svn: 242650
2015-07-20 05:41:12 +08:00
(IsModule ? II.hasRevertedBuiltin() : II.getObjCOrBuiltinID()) ||
[Modules] Cope better with top-level declarations loaded after being declared in the current translation unit <rdar://problem/13189985>. These two related tweaks to keep the information associated with a given identifier correct when the identifier has been given some top-level information (say, a top-level declaration) and more information is then loaded from a module. The first ensures that an identifier that was "interesting" before being loaded from an AST is considered to be different from its on-disk counterpart. Otherwise, we lose such changes when writing the current translation unit as a module. Second, teach the code that injects AST-loaded names into the identifier chain for name lookup to keep the most recent declaration, so that we don't end up confusing our declaration chains by having a different declaration in there. llvm-svn: 174895
2013-02-12 02:16:18 +08:00
II.hasRevertedTokenIDToIdentifier() ||
[modules] In C++, stop serializing and deserializing a list of declarations in the identifier table. This is redundant, since the TU-scope lookups are also serialized as part of the TU DeclContext, and wasteful in a number of ways. We still emit the decls for PCH / preamble builds, since for those we want identical results, not merely semantically equivalent ones. llvm-svn: 242855
2015-07-22 07:54:07 +08:00
(!(IsModule && Reader.getContext().getLangOpts().CPlusPlus) &&
II.getFETokenInfo<void>());
[Modules] Cope better with top-level declarations loaded after being declared in the current translation unit <rdar://problem/13189985>. These two related tweaks to keep the information associated with a given identifier correct when the identifier has been given some top-level information (say, a top-level declaration) and more information is then loaded from a module. The first ensures that an identifier that was "interesting" before being loaded from an AST is considered to be different from its on-disk counterpart. Otherwise, we lose such changes when writing the current translation unit as a module. Second, teach the code that injects AST-loaded names into the identifier chain for name lookup to keep the most recent declaration, so that we don't end up confusing our declaration chains by having a different declaration in there. llvm-svn: 174895
2013-02-12 02:16:18 +08:00
}
Refactor to remove repetition, no functionality change. llvm-svn: 242564
2015-07-18 04:09:43 +08:00
static bool readBit(unsigned &Bits) {
bool Value = Bits & 0x1;
Bits >>= 1;
return Value;
}
[modules] Stop updating all identifiers when writing a module. This is unnecessary in C++ modules (where we don't need the identifiers for their Decls) and expensive. llvm-svn: 245821
2015-08-24 11:33:22 +08:00
IdentID ASTIdentifierLookupTrait::ReadIdentifierID(const unsigned char *d) {
using namespace llvm::support;
unsigned RawID = endian::readNext<uint32_t, little, unaligned>(d);
return Reader.getGlobalIdentifierID(F, RawID >> 1);
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
IdentifierInfo *ASTIdentifierLookupTrait::ReadData(const internal_key_type& k,
const unsigned char* d,
unsigned DataLen) {
Reapply "OnDiskHashTable: Use Endian.h to read little endian ostreams" Committed this by accident before it was done last time. Original message: Rather than rolling our own functions to read little endian data from a buffer, we can use the support in llvm's Endian.h. No functional change. llvm-svn: 205062
2014-03-29 06:03:24 +08:00
using namespace llvm::support;
unsigned RawID = endian::readNext<uint32_t, little, unaligned>(d);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
bool IsInteresting = RawID & 0x01;
// Wipe out the "is interesting" bit.
RawID = RawID >> 1;
Refactor to remove repetition, no functionality change. llvm-svn: 242564
2015-07-18 04:09:43 +08:00
// Build the IdentifierInfo and link the identifier ID with it.
IdentifierInfo *II = KnownII;
if (!II) {
II = &Reader.getIdentifierTable().getOwn(k);
KnownII = II;
}
if (!II->isFromAST()) {
II->setIsFromAST();
Fix missing builtin identifier infos with PCH+modules Use the *current* state of "is-moduleness" rather than the state at serialization time so that if we read a builtin identifier from a module that wasn't "interesting" to that module, we will still write it out to a PCH that imports that module. Otherwise, we would get mysterious "unknown builtin" errors when using PCH+modules. rdar://problem/23287656 llvm-svn: 251565
2015-10-29 06:25:37 +08:00
bool IsModule = Reader.PP.getCurrentModule() != nullptr;
if (isInterestingIdentifier(Reader, *II, IsModule))
Refactor to remove repetition, no functionality change. llvm-svn: 242564
2015-07-18 04:09:43 +08:00
II->setChangedSinceDeserialization();
}
Reader.markIdentifierUpToDate(II);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
IdentID ID = Reader.getGlobalIdentifierID(F, RawID);
if (!IsInteresting) {
Refactor to remove repetition, no functionality change. llvm-svn: 242564
2015-07-18 04:09:43 +08:00
// For uninteresting identifiers, there's nothing else to do. Just notify
// the reader that we've finished loading this identifier.
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
Reader.SetIdentifierInfo(ID, II);
return II;
}
Reapply "OnDiskHashTable: Use Endian.h to read little endian ostreams" Committed this by accident before it was done last time. Original message: Rather than rolling our own functions to read little endian data from a buffer, we can use the support in llvm's Endian.h. No functional change. llvm-svn: 205062
2014-03-29 06:03:24 +08:00
unsigned ObjCOrBuiltinID = endian::readNext<uint16_t, little, unaligned>(d);
unsigned Bits = endian::readNext<uint16_t, little, unaligned>(d);
Refactor to remove repetition, no functionality change. llvm-svn: 242564
2015-07-18 04:09:43 +08:00
bool CPlusPlusOperatorKeyword = readBit(Bits);
bool HasRevertedTokenIDToIdentifier = readBit(Bits);
[modules] Don't save uninteresting identifiers, and don't consider identifiers to be interesting just because they are the name of a builtin. Reduces the size of an empty module by over 80% (~100KB). llvm-svn: 242650
2015-07-20 05:41:12 +08:00
bool HasRevertedBuiltin = readBit(Bits);
Refactor to remove repetition, no functionality change. llvm-svn: 242564
2015-07-18 04:09:43 +08:00
bool Poisoned = readBit(Bits);
bool ExtensionToken = readBit(Bits);
bool HadMacroDefinition = readBit(Bits);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
assert(Bits == 0 && "Extra bits in the identifier?");
DataLen -= 8;
// Set or check the various bits in the IdentifierInfo structure.
// Token IDs are read-only.
[PCH] When deserializing an IdentifierInfo, call IdentifierInfo::RevertTokenIDToIdentifier() only when it's not already an identifier. Fixes an assertion hit. rdar://13288735 llvm-svn: 176148
2013-02-27 09:13:51 +08:00
if (HasRevertedTokenIDToIdentifier && II->getTokenID() != tok::identifier)
[modules] Don't save uninteresting identifiers, and don't consider identifiers to be interesting just because they are the name of a builtin. Reduces the size of an empty module by over 80% (~100KB). llvm-svn: 242650
2015-07-20 05:41:12 +08:00
II->revertTokenIDToIdentifier();
if (!F.isModule())
II->setObjCOrBuiltinID(ObjCOrBuiltinID);
else if (HasRevertedBuiltin && II->getBuiltinID()) {
II->revertBuiltin();
assert((II->hasRevertedBuiltin() ||
II->getObjCOrBuiltinID() == ObjCOrBuiltinID) &&
"Incorrect ObjC keyword or builtin ID");
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
assert(II->isExtensionToken() == ExtensionToken &&
"Incorrect extension token flag");
(void)ExtensionToken;
if (Poisoned)
II->setIsPoisoned(true);
assert(II->isCPlusPlusOperatorKeyword() == CPlusPlusOperatorKeyword &&
"Incorrect C++ operator keyword flag");
(void)CPlusPlusOperatorKeyword;
// If this identifier is a macro, deserialize the macro
// definition.
Refactor to remove repetition, no functionality change. llvm-svn: 242564
2015-07-18 04:09:43 +08:00
if (HadMacroDefinition) {
Reapply "OnDiskHashTable: Use Endian.h to read little endian ostreams" Committed this by accident before it was done last time. Original message: Rather than rolling our own functions to read little endian data from a buffer, we can use the support in llvm's Endian.h. No functional change. llvm-svn: 205062
2014-03-29 06:03:24 +08:00
uint32_t MacroDirectivesOffset =
endian::readNext<uint32_t, little, unaligned>(d);
[PCH/Modules] De/Serialize MacroInfos separately than MacroDirectives. -Serialize the macro directives history into its own section -Get rid of the macro updates section -When de/serializing an identifier from a module, associate only one macro per submodule that defined+exported it. llvm-svn: 177761
2013-03-23 05:12:57 +08:00
DataLen -= 4;
If a module A exports a macro M, and a module B imports that macro and #undef's it, importers of B should not see the macro. This is complicated by the fact that A's macro could also be visible through a different path. The rules (as hashed out on cfe-commits) are included as a documentation update in this change. With this, the number of regressions in libc++'s testsuite when modules are enabled drops from 47 to 7. Those remaining 7 are also macro-related, and are due to remaining bugs in this change (in particular, the handling of submodules is imperfect). llvm-svn: 202560
2014-03-01 08:08:04 +08:00
[modules] Move list of exported module macros from IdentifierInfo lookup table to separate storage, adjacent to the macro directive history. This is substantially simpler, provides better space usage accounting in bcanalyzer, and gives a more compact representation. No functionality change intended. llvm-svn: 235420
2015-04-22 05:46:32 +08:00
Reader.addPendingMacro(II, &F, MacroDirectivesOffset);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
Reader.SetIdentifierInfo(ID, II);
// Read all of the declarations visible at global scope with this
// name.
if (DataLen > 0) {
SmallVector<uint32_t, 4> DeclIDs;
for (; DataLen > 0; DataLen -= 4)
Reapply "OnDiskHashTable: Use Endian.h to read little endian ostreams" Committed this by accident before it was done last time. Original message: Rather than rolling our own functions to read little endian data from a buffer, we can use the support in llvm's Endian.h. No functional change. llvm-svn: 205062
2014-03-29 06:03:24 +08:00
DeclIDs.push_back(Reader.getGlobalDeclID(
F, endian::readNext<uint32_t, little, unaligned>(d)));
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
Reader.SetGloballyVisibleDecls(II, DeclIDs);
}
return II;
}
[modules] The key to a DeclContext name lookup table is not actually a DeclarationName (because all ctor names are considered the same, and so on). Reflect this in the type used as the lookup table key. As a side-effect, remove one copy of the duplicated code used to compute the hash of the key. llvm-svn: 246124
2015-08-27 07:55:49 +08:00
DeclarationNameKey::DeclarationNameKey(DeclarationName Name)
: Kind(Name.getNameKind()) {
switch (Kind) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
case DeclarationName::Identifier:
[modules] The key to a DeclContext name lookup table is not actually a DeclarationName (because all ctor names are considered the same, and so on). Reflect this in the type used as the lookup table key. As a side-effect, remove one copy of the duplicated code used to compute the hash of the key. llvm-svn: 246124
2015-08-27 07:55:49 +08:00
Data = (uint64_t)Name.getAsIdentifierInfo();
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
break;
case DeclarationName::ObjCZeroArgSelector:
case DeclarationName::ObjCOneArgSelector:
case DeclarationName::ObjCMultiArgSelector:
[modules] The key to a DeclContext name lookup table is not actually a DeclarationName (because all ctor names are considered the same, and so on). Reflect this in the type used as the lookup table key. As a side-effect, remove one copy of the duplicated code used to compute the hash of the key. llvm-svn: 246124
2015-08-27 07:55:49 +08:00
Data = (uint64_t)Name.getObjCSelector().getAsOpaquePtr();
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
break;
case DeclarationName::CXXOperatorName:
[modules] The key to a DeclContext name lookup table is not actually a DeclarationName (because all ctor names are considered the same, and so on). Reflect this in the type used as the lookup table key. As a side-effect, remove one copy of the duplicated code used to compute the hash of the key. llvm-svn: 246124
2015-08-27 07:55:49 +08:00
Data = Name.getCXXOverloadedOperator();
break;
case DeclarationName::CXXLiteralOperatorName:
Data = (uint64_t)Name.getCXXLiteralIdentifier();
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
break;
case DeclarationName::CXXConstructorName:
case DeclarationName::CXXDestructorName:
case DeclarationName::CXXConversionFunctionName:
case DeclarationName::CXXUsingDirective:
[modules] The key to a DeclContext name lookup table is not actually a DeclarationName (because all ctor names are considered the same, and so on). Reflect this in the type used as the lookup table key. As a side-effect, remove one copy of the duplicated code used to compute the hash of the key. llvm-svn: 246124
2015-08-27 07:55:49 +08:00
Data = 0;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
break;
}
}
[modules] The key to a DeclContext name lookup table is not actually a DeclarationName (because all ctor names are considered the same, and so on). Reflect this in the type used as the lookup table key. As a side-effect, remove one copy of the duplicated code used to compute the hash of the key. llvm-svn: 246124
2015-08-27 07:55:49 +08:00
unsigned DeclarationNameKey::getHash() const {
llvm::FoldingSetNodeID ID;
ID.AddInteger(Kind);
switch (Kind) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
case DeclarationName::Identifier:
[modules] The key to a DeclContext name lookup table is not actually a DeclarationName (because all ctor names are considered the same, and so on). Reflect this in the type used as the lookup table key. As a side-effect, remove one copy of the duplicated code used to compute the hash of the key. llvm-svn: 246124
2015-08-27 07:55:49 +08:00
case DeclarationName::CXXLiteralOperatorName:
ID.AddString(((IdentifierInfo*)Data)->getName());
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
break;
case DeclarationName::ObjCZeroArgSelector:
case DeclarationName::ObjCOneArgSelector:
case DeclarationName::ObjCMultiArgSelector:
[modules] The key to a DeclContext name lookup table is not actually a DeclarationName (because all ctor names are considered the same, and so on). Reflect this in the type used as the lookup table key. As a side-effect, remove one copy of the duplicated code used to compute the hash of the key. llvm-svn: 246124
2015-08-27 07:55:49 +08:00
ID.AddInteger(serialization::ComputeHash(Selector(Data)));
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
break;
case DeclarationName::CXXOperatorName:
[modules] The key to a DeclContext name lookup table is not actually a DeclarationName (because all ctor names are considered the same, and so on). Reflect this in the type used as the lookup table key. As a side-effect, remove one copy of the duplicated code used to compute the hash of the key. llvm-svn: 246124
2015-08-27 07:55:49 +08:00
ID.AddInteger((OverloadedOperatorKind)Data);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
break;
case DeclarationName::CXXConstructorName:
case DeclarationName::CXXDestructorName:
case DeclarationName::CXXConversionFunctionName:
case DeclarationName::CXXUsingDirective:
break;
}
[modules] The key to a DeclContext name lookup table is not actually a DeclarationName (because all ctor names are considered the same, and so on). Reflect this in the type used as the lookup table key. As a side-effect, remove one copy of the duplicated code used to compute the hash of the key. llvm-svn: 246124
2015-08-27 07:55:49 +08:00
return ID.ComputeHash();
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
Re-commit r246497 (and dependent changes r246524 and r246521), reverted in r246546, with a workaround for an MSVC 2013 miscompile and an MSVC 2015 rejects-valid. Original commit message: [modules] Rework serialized DeclContext lookup table management. Instead of walking the loaded ModuleFiles looking for lookup tables for the context, store them all in one place, and merge them together if we find we have too many (currently, more than 4). If we do merge, include the merged form in our serialized lookup table, so that downstream readers never need to look at our imports' tables. This gives a huge performance improvement to builds with very large numbers of modules (in some cases, more than a 2x speedup was observed). llvm-svn: 246582
2015-09-02 04:35:42 +08:00
ModuleFile *
ASTDeclContextNameLookupTrait::ReadFileRef(const unsigned char *&d) {
using namespace llvm::support;
uint32_t ModuleFileID = endian::readNext<uint32_t, little, unaligned>(d);
return Reader.getLocalModuleFile(F, ModuleFileID);
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
std::pair<unsigned, unsigned>
[modules] The key to a DeclContext name lookup table is not actually a DeclarationName (because all ctor names are considered the same, and so on). Reflect this in the type used as the lookup table key. As a side-effect, remove one copy of the duplicated code used to compute the hash of the key. llvm-svn: 246124
2015-08-27 07:55:49 +08:00
ASTDeclContextNameLookupTrait::ReadKeyDataLength(const unsigned char *&d) {
Reapply "OnDiskHashTable: Use Endian.h to read little endian ostreams" Committed this by accident before it was done last time. Original message: Rather than rolling our own functions to read little endian data from a buffer, we can use the support in llvm's Endian.h. No functional change. llvm-svn: 205062
2014-03-29 06:03:24 +08:00
using namespace llvm::support;
unsigned KeyLen = endian::readNext<uint16_t, little, unaligned>(d);
unsigned DataLen = endian::readNext<uint16_t, little, unaligned>(d);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
return std::make_pair(KeyLen, DataLen);
}
[modules] The key to a DeclContext name lookup table is not actually a DeclarationName (because all ctor names are considered the same, and so on). Reflect this in the type used as the lookup table key. As a side-effect, remove one copy of the duplicated code used to compute the hash of the key. llvm-svn: 246124
2015-08-27 07:55:49 +08:00
ASTDeclContextNameLookupTrait::internal_key_type
ASTDeclContextNameLookupTrait::ReadKey(const unsigned char *d, unsigned) {
Reapply "OnDiskHashTable: Use Endian.h to read little endian ostreams" Committed this by accident before it was done last time. Original message: Rather than rolling our own functions to read little endian data from a buffer, we can use the support in llvm's Endian.h. No functional change. llvm-svn: 205062
2014-03-29 06:03:24 +08:00
using namespace llvm::support;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
[modules] The key to a DeclContext name lookup table is not actually a DeclarationName (because all ctor names are considered the same, and so on). Reflect this in the type used as the lookup table key. As a side-effect, remove one copy of the duplicated code used to compute the hash of the key. llvm-svn: 246124
2015-08-27 07:55:49 +08:00
auto Kind = (DeclarationName::NameKind)*d++;
uint64_t Data;
switch (Kind) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
case DeclarationName::Identifier:
[modules] The key to a DeclContext name lookup table is not actually a DeclarationName (because all ctor names are considered the same, and so on). Reflect this in the type used as the lookup table key. As a side-effect, remove one copy of the duplicated code used to compute the hash of the key. llvm-svn: 246124
2015-08-27 07:55:49 +08:00
Data = (uint64_t)Reader.getLocalIdentifier(
Reapply "OnDiskHashTable: Use Endian.h to read little endian ostreams" Committed this by accident before it was done last time. Original message: Rather than rolling our own functions to read little endian data from a buffer, we can use the support in llvm's Endian.h. No functional change. llvm-svn: 205062
2014-03-29 06:03:24 +08:00
F, endian::readNext<uint32_t, little, unaligned>(d));
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
break;
case DeclarationName::ObjCZeroArgSelector:
case DeclarationName::ObjCOneArgSelector:
case DeclarationName::ObjCMultiArgSelector:
[modules] The key to a DeclContext name lookup table is not actually a DeclarationName (because all ctor names are considered the same, and so on). Reflect this in the type used as the lookup table key. As a side-effect, remove one copy of the duplicated code used to compute the hash of the key. llvm-svn: 246124
2015-08-27 07:55:49 +08:00
Data =
Reapply "OnDiskHashTable: Use Endian.h to read little endian ostreams" Committed this by accident before it was done last time. Original message: Rather than rolling our own functions to read little endian data from a buffer, we can use the support in llvm's Endian.h. No functional change. llvm-svn: 205062
2014-03-29 06:03:24 +08:00
(uint64_t)Reader.getLocalSelector(
F, endian::readNext<uint32_t, little, unaligned>(
d)).getAsOpaquePtr();
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
break;
case DeclarationName::CXXOperatorName:
[modules] The key to a DeclContext name lookup table is not actually a DeclarationName (because all ctor names are considered the same, and so on). Reflect this in the type used as the lookup table key. As a side-effect, remove one copy of the duplicated code used to compute the hash of the key. llvm-svn: 246124
2015-08-27 07:55:49 +08:00
Data = *d++; // OverloadedOperatorKind
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
break;
case DeclarationName::CXXLiteralOperatorName:
[modules] The key to a DeclContext name lookup table is not actually a DeclarationName (because all ctor names are considered the same, and so on). Reflect this in the type used as the lookup table key. As a side-effect, remove one copy of the duplicated code used to compute the hash of the key. llvm-svn: 246124
2015-08-27 07:55:49 +08:00
Data = (uint64_t)Reader.getLocalIdentifier(
Reapply "OnDiskHashTable: Use Endian.h to read little endian ostreams" Committed this by accident before it was done last time. Original message: Rather than rolling our own functions to read little endian data from a buffer, we can use the support in llvm's Endian.h. No functional change. llvm-svn: 205062
2014-03-29 06:03:24 +08:00
F, endian::readNext<uint32_t, little, unaligned>(d));
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
break;
case DeclarationName::CXXConstructorName:
case DeclarationName::CXXDestructorName:
case DeclarationName::CXXConversionFunctionName:
case DeclarationName::CXXUsingDirective:
[modules] The key to a DeclContext name lookup table is not actually a DeclarationName (because all ctor names are considered the same, and so on). Reflect this in the type used as the lookup table key. As a side-effect, remove one copy of the duplicated code used to compute the hash of the key. llvm-svn: 246124
2015-08-27 07:55:49 +08:00
Data = 0;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
break;
}
[modules] The key to a DeclContext name lookup table is not actually a DeclarationName (because all ctor names are considered the same, and so on). Reflect this in the type used as the lookup table key. As a side-effect, remove one copy of the duplicated code used to compute the hash of the key. llvm-svn: 246124
2015-08-27 07:55:49 +08:00
return DeclarationNameKey(Kind, Data);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
Re-commit r246497 (and dependent changes r246524 and r246521), reverted in r246546, with a workaround for an MSVC 2013 miscompile and an MSVC 2015 rejects-valid. Original commit message: [modules] Rework serialized DeclContext lookup table management. Instead of walking the loaded ModuleFiles looking for lookup tables for the context, store them all in one place, and merge them together if we find we have too many (currently, more than 4). If we do merge, include the merged form in our serialized lookup table, so that downstream readers never need to look at our imports' tables. This gives a huge performance improvement to builds with very large numbers of modules (in some cases, more than a 2x speedup was observed). llvm-svn: 246582
2015-09-02 04:35:42 +08:00
void ASTDeclContextNameLookupTrait::ReadDataInto(internal_key_type,
const unsigned char *d,
unsigned DataLen,
data_type_builder &Val) {
Reapply "OnDiskHashTable: Use Endian.h to read little endian ostreams" Committed this by accident before it was done last time. Original message: Rather than rolling our own functions to read little endian data from a buffer, we can use the support in llvm's Endian.h. No functional change. llvm-svn: 205062
2014-03-29 06:03:24 +08:00
using namespace llvm::support;
Re-commit r246497 (and dependent changes r246524 and r246521), reverted in r246546, with a workaround for an MSVC 2013 miscompile and an MSVC 2015 rejects-valid. Original commit message: [modules] Rework serialized DeclContext lookup table management. Instead of walking the loaded ModuleFiles looking for lookup tables for the context, store them all in one place, and merge them together if we find we have too many (currently, more than 4). If we do merge, include the merged form in our serialized lookup table, so that downstream readers never need to look at our imports' tables. This gives a huge performance improvement to builds with very large numbers of modules (in some cases, more than a 2x speedup was observed). llvm-svn: 246582
2015-09-02 04:35:42 +08:00
for (unsigned NumDecls = DataLen / 4; NumDecls; --NumDecls) {
uint32_t LocalID = endian::readNext<uint32_t, little, unaligned>(d);
Val.insert(Reader.getGlobalDeclID(F, LocalID));
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
[modules] Defer setting up the lookup table for a DeclContext until we can determine the primary context, rather than sometimes registering the lookup table on the wrong context. This exposed a couple of bugs: * the odr violation check didn't deal properly with mergeable declarations if the declaration retained by name lookup wasn't in the canonical definition of the class * the (broken) RewriteDecl mechanism would emit two name lookup tables for the same DeclContext into the same module file (one as part of the rewritten declaration and one as a visible update for the old declaration) These are both fixed too. llvm-svn: 244192
2015-08-06 12:23:48 +08:00
bool ASTReader::ReadLexicalDeclContextStorage(ModuleFile &M,
BitstreamCursor &Cursor,
uint64_t Offset,
DeclContext *DC) {
assert(Offset != 0);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
[modules] Defer setting up the lookup table for a DeclContext until we can determine the primary context, rather than sometimes registering the lookup table on the wrong context. This exposed a couple of bugs: * the odr violation check didn't deal properly with mergeable declarations if the declaration retained by name lookup wasn't in the canonical definition of the class * the (broken) RewriteDecl mechanism would emit two name lookup tables for the same DeclContext into the same module file (one as part of the rewritten declaration and one as a visible update for the old declaration) These are both fixed too. llvm-svn: 244192
2015-08-06 12:23:48 +08:00
SavedStreamPosition SavedPosition(Cursor);
Cursor.JumpToBit(Offset);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
[modules] Defer setting up the lookup table for a DeclContext until we can determine the primary context, rather than sometimes registering the lookup table on the wrong context. This exposed a couple of bugs: * the odr violation check didn't deal properly with mergeable declarations if the declaration retained by name lookup wasn't in the canonical definition of the class * the (broken) RewriteDecl mechanism would emit two name lookup tables for the same DeclContext into the same module file (one as part of the rewritten declaration and one as a visible update for the old declaration) These are both fixed too. llvm-svn: 244192
2015-08-06 12:23:48 +08:00
RecordData Record;
StringRef Blob;
unsigned Code = Cursor.ReadCode();
unsigned RecCode = Cursor.readRecord(Code, Record, &Blob);
if (RecCode != DECL_CONTEXT_LEXICAL) {
Error("Expected lexical block");
return true;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
[modules] Stop walking all modules when looking for lexical decls for a DeclContext. These only ever come from the owning module file for the Decl. llvm-svn: 244285
2015-08-07 06:07:25 +08:00
assert(!isa<TranslationUnitDecl>(DC) &&
"expected a TU_UPDATE_LEXICAL record for TU");
[modules] When instantiating the contents of an imported CXXRecordDecl, we can emit lexical contents for a declaration for another module. Track which module those contents came from, and ensure that we only grab the lexical contents from a single such instantiation. llvm-svn: 244682
2015-08-12 06:00:24 +08:00
// If we are handling a C++ class template instantiation, we can see multiple
// lexical updates for the same record. It's important that we select only one
// of them, so that field numbering works properly. Just pick the first one we
// see.
auto &Lex = LexicalDecls[DC];
if (!Lex.first) {
Lex = std::make_pair(
&M, llvm::makeArrayRef(
reinterpret_cast<const llvm::support::unaligned_uint32_t *>(
Blob.data()),
Blob.size() / 4));
}
[modules] Defer setting up the lookup table for a DeclContext until we can determine the primary context, rather than sometimes registering the lookup table on the wrong context. This exposed a couple of bugs: * the odr violation check didn't deal properly with mergeable declarations if the declaration retained by name lookup wasn't in the canonical definition of the class * the (broken) RewriteDecl mechanism would emit two name lookup tables for the same DeclContext into the same module file (one as part of the rewritten declaration and one as a visible update for the old declaration) These are both fixed too. llvm-svn: 244192
2015-08-06 12:23:48 +08:00
DC->setHasExternalLexicalStorage(true);
return false;
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
[modules] Defer setting up the lookup table for a DeclContext until we can determine the primary context, rather than sometimes registering the lookup table on the wrong context. This exposed a couple of bugs: * the odr violation check didn't deal properly with mergeable declarations if the declaration retained by name lookup wasn't in the canonical definition of the class * the (broken) RewriteDecl mechanism would emit two name lookup tables for the same DeclContext into the same module file (one as part of the rewritten declaration and one as a visible update for the old declaration) These are both fixed too. llvm-svn: 244192
2015-08-06 12:23:48 +08:00
bool ASTReader::ReadVisibleDeclContextStorage(ModuleFile &M,
BitstreamCursor &Cursor,
uint64_t Offset,
DeclID ID) {
assert(Offset != 0);
SavedStreamPosition SavedPosition(Cursor);
Cursor.JumpToBit(Offset);
RecordData Record;
StringRef Blob;
unsigned Code = Cursor.ReadCode();
unsigned RecCode = Cursor.readRecord(Code, Record, &Blob);
if (RecCode != DECL_CONTEXT_VISIBLE) {
Error("Expected visible lookup table block");
return true;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
[modules] Defer setting up the lookup table for a DeclContext until we can determine the primary context, rather than sometimes registering the lookup table on the wrong context. This exposed a couple of bugs: * the odr violation check didn't deal properly with mergeable declarations if the declaration retained by name lookup wasn't in the canonical definition of the class * the (broken) RewriteDecl mechanism would emit two name lookup tables for the same DeclContext into the same module file (one as part of the rewritten declaration and one as a visible update for the old declaration) These are both fixed too. llvm-svn: 244192
2015-08-06 12:23:48 +08:00
// We can't safely determine the primary context yet, so delay attaching the
// lookup table until we're done with recursive deserialization.
Re-commit r246497 (and dependent changes r246524 and r246521), reverted in r246546, with a workaround for an MSVC 2013 miscompile and an MSVC 2015 rejects-valid. Original commit message: [modules] Rework serialized DeclContext lookup table management. Instead of walking the loaded ModuleFiles looking for lookup tables for the context, store them all in one place, and merge them together if we find we have too many (currently, more than 4). If we do merge, include the merged form in our serialized lookup table, so that downstream readers never need to look at our imports' tables. This gives a huge performance improvement to builds with very large numbers of modules (in some cases, more than a 2x speedup was observed). llvm-svn: 246582
2015-09-02 04:35:42 +08:00
auto *Data = (const unsigned char*)Blob.data();
PendingVisibleUpdates[ID].push_back(PendingVisibleUpdate{&M, Data});
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
return false;
}
void ASTReader::Error(StringRef Msg) {
Error(diag::err_fe_pch_malformed, Msg);
[modules] Add an experimental -cc1 feature to embed the contents of an input file in the .pcm files. This allows a smaller set of files to be sent to a remote build worker when building with explicit modules (for instance, module map files need not be sent along with the corresponding precompiled modules). This doesn't actually make the embedded files visible to header search, so it's not useful as a packaging format for public header files. llvm-svn: 245028
2015-08-14 13:02:58 +08:00
if (Context.getLangOpts().Modules && !Diags.isDiagnosticInFlight() &&
!PP.getHeaderSearchInfo().getModuleCachePath().empty()) {
[Modules] When things go horribly wrong when reading a module, point at the module cache. Sometimes people hack on their system headers. In such cases, they'll need to delete their module cache, but may not know where it is. Add a note to show them where it is. llvm-svn: 181638
2013-05-11 06:15:13 +08:00
Diag(diag::note_module_cache_path)
<< PP.getHeaderSearchInfo().getModuleCachePath();
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
void ASTReader::Error(unsigned DiagID,
StringRef Arg1, StringRef Arg2) {
if (Diags.isDiagnosticInFlight())
Diags.SetDelayedDiagnostic(DiagID, Arg1, Arg2);
else
Diag(DiagID) << Arg1 << Arg2;
}
//===----------------------------------------------------------------------===//
// Source Manager Deserialization
//===----------------------------------------------------------------------===//
/// \brief Read the line table in the source manager block.
/// \returns true if there was an error.
bool ASTReader::ParseLineTable(ModuleFile &F,
[modules] Instead of storing absolute paths in a .pcm file, store the path to the root of the module and use paths relative to that directory wherever possible. This is a step towards allowing explicit modules to be relocated without being rebuilt, which is important for some kinds of distributed builds, for good paths in diagnostics, and for appropriate .d output. This is a recommit of r223443, reverted in r223465; when joining together imported file paths, we now use the system's separator rather than always using '/'. This avoids path mismatches between the original module build and the module user on Windows (at least, in some cases). A more comprehensive fix will follow. llvm-svn: 223539
2014-12-06 06:42:13 +08:00
const RecordData &Record) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
unsigned Idx = 0;
LineTableInfo &LineTable = SourceMgr.getLineTable();
// Parse the file names
std::map<int, int> FileIDs;
[modules] When emitting line tables, only emit filenames that are actually referenced by the entries that we emit. llvm-svn: 246534
2015-09-01 15:41:55 +08:00
for (unsigned I = 0; Record[Idx]; ++I) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
// Extract the file name
[modules] Instead of storing absolute paths in a .pcm file, store the path to the root of the module and use paths relative to that directory wherever possible. This is a step towards allowing explicit modules to be relocated without being rebuilt, which is important for some kinds of distributed builds, for good paths in diagnostics, and for appropriate .d output. This is a recommit of r223443, reverted in r223465; when joining together imported file paths, we now use the system's separator rather than always using '/'. This avoids path mismatches between the original module build and the module user on Windows (at least, in some cases). A more comprehensive fix will follow. llvm-svn: 223539
2014-12-06 06:42:13 +08:00
auto Filename = ReadPath(F, Record, Idx);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
FileIDs[I] = LineTable.getLineTableFilenameID(Filename);
}
[modules] When emitting line tables, only emit filenames that are actually referenced by the entries that we emit. llvm-svn: 246534
2015-09-01 15:41:55 +08:00
++Idx;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
// Parse the line entries
std::vector<LineEntry> Entries;
while (Idx < Record.size()) {
int FID = Record[Idx++];
assert(FID >= 0 && "Serialized line entries for non-local file.");
// Remap FileID from 1-based old view.
FID += F.SLocEntryBaseID - 1;
// Extract the line entries
unsigned NumEntries = Record[Idx++];
[modules] When emitting line tables, only emit filenames that are actually referenced by the entries that we emit. llvm-svn: 246534
2015-09-01 15:41:55 +08:00
assert(NumEntries && "no line entries for file ID");
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
Entries.clear();
Entries.reserve(NumEntries);
for (unsigned I = 0; I != NumEntries; ++I) {
unsigned FileOffset = Record[Idx++];
unsigned LineNo = Record[Idx++];
int FilenameID = FileIDs[Record[Idx++]];
SrcMgr::CharacteristicKind FileKind
= (SrcMgr::CharacteristicKind)Record[Idx++];
unsigned IncludeOffset = Record[Idx++];
Entries.push_back(LineEntry::get(FileOffset, LineNo, FilenameID,
FileKind, IncludeOffset));
}
LineTable.AddEntry(FileID::get(FID), Entries);
}
return false;
}
/// \brief Read a source manager block
bool ASTReader::ReadSourceManagerBlock(ModuleFile &F) {
using namespace SrcMgr;
finish converting the normal cases in ASTReader to use the new BitstreamCursor APIs. llvm-svn: 172937
2013-01-20 08:56:42 +08:00
BitstreamCursor &SLocEntryCursor = F.SLocEntryCursor;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +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 = F.Stream;
// The stream itself is going to skip over the source manager block.
if (F.Stream.SkipBlock()) {
Error("malformed block record in AST file");
return true;
}
// Enter the source manager block.
if (SLocEntryCursor.EnterSubBlock(SOURCE_MANAGER_BLOCK_ID)) {
Error("malformed source manager block record in AST file");
return true;
}
RecordData Record;
while (true) {
switch a bunch of ASTReader to use the new BitstreamCursor::advance* methods, which hide a bunch of private details of the cursor from clients and simplify their code. More to come. llvm-svn: 172922
2013-01-20 05:39:22 +08:00
llvm::BitstreamEntry E = SLocEntryCursor.advanceSkippingSubblocks();
switch (E.Kind) {
case llvm::BitstreamEntry::SubBlock: // Handled for us already.
case llvm::BitstreamEntry::Error:
Error("malformed block record in AST file");
return true;
case llvm::BitstreamEntry::EndBlock:
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
return false;
switch a bunch of ASTReader to use the new BitstreamCursor::advance* methods, which hide a bunch of private details of the cursor from clients and simplify their code. More to come. llvm-svn: 172922
2013-01-20 05:39:22 +08:00
case llvm::BitstreamEntry::Record:
// The interesting case.
break;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
switch a bunch of ASTReader to use the new BitstreamCursor::advance* methods, which hide a bunch of private details of the cursor from clients and simplify their code. More to come. llvm-svn: 172922
2013-01-20 05:39:22 +08:00
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
// Read a record.
Record.clear();
ReadSourceManagerBlock is skipping over records that can contain Blobs. Not passing in a StringRef to bind to them forces them to be unpacked into the Record as individual bytes. This is wasteful, but not likely to be measurable in this instance. llvm-svn: 173066
2013-01-22 02:28:26 +08:00
StringRef Blob;
switch (SLocEntryCursor.readRecord(E.ID, Record, &Blob)) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
default: // Default behavior: ignore.
break;
case SM_SLOC_FILE_ENTRY:
case SM_SLOC_BUFFER_ENTRY:
case SM_SLOC_EXPANSION_ENTRY:
// Once we hit one of the source location entries, we're done.
return false;
}
}
}
/// \brief If a header file is not found at the path that we expect it to be
/// and the PCH file was moved from its original location, try to resolve the
/// file by assuming that header+PCH were moved together and the header is in
/// the same place relative to the PCH.
static std::string
resolveFileRelativeToOriginalDir(const std::string &Filename,
const std::string &OriginalDir,
const std::string &CurrDir) {
assert(OriginalDir != CurrDir &&
"No point trying to resolve the file if the PCH dir didn't change");
using namespace llvm::sys;
SmallString<128> filePath(Filename);
fs::make_absolute(filePath);
assert(path::is_absolute(OriginalDir));
SmallString<128> currPCHPath(CurrDir);
path::const_iterator fileDirI = path::begin(path::parent_path(filePath)),
fileDirE = path::end(path::parent_path(filePath));
path::const_iterator origDirI = path::begin(OriginalDir),
origDirE = path::end(OriginalDir);
// Skip the common path components from filePath and OriginalDir.
while (fileDirI != fileDirE && origDirI != origDirE &&
*fileDirI == *origDirI) {
++fileDirI;
++origDirI;
}
for (; origDirI != origDirE; ++origDirI)
path::append(currPCHPath, "..");
path::append(currPCHPath, fileDirI, fileDirE);
path::append(currPCHPath, path::filename(Filename));
return currPCHPath.str();
}
bool ASTReader::ReadSLocEntry(int ID) {
if (ID == 0)
return false;
if (unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) {
Error("source location entry ID out-of-range for AST file");
return true;
}
ModuleFile *F = GlobalSLocEntryMap.find(-ID)->second;
F->SLocEntryCursor.JumpToBit(F->SLocEntryOffsets[ID - F->SLocEntryBaseID]);
finish converting the normal cases in ASTReader to use the new BitstreamCursor APIs. llvm-svn: 172937
2013-01-20 08:56:42 +08:00
BitstreamCursor &SLocEntryCursor = F->SLocEntryCursor;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
unsigned BaseOffset = F->SLocEntryBaseOffset;
++NumSLocEntriesRead;
switch a bunch of ASTReader to use the new BitstreamCursor::advance* methods, which hide a bunch of private details of the cursor from clients and simplify their code. More to come. llvm-svn: 172922
2013-01-20 05:39:22 +08:00
llvm::BitstreamEntry Entry = SLocEntryCursor.advance();
if (Entry.Kind != llvm::BitstreamEntry::Record) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
Error("incorrectly-formatted source location entry in AST file");
return true;
}
switch a bunch of ASTReader to use the new BitstreamCursor::advance* methods, which hide a bunch of private details of the cursor from clients and simplify their code. More to come. llvm-svn: 172922
2013-01-20 05:39:22 +08:00
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
RecordData Record;
update to use the new BitcodeCursor readRecord that takes a StringRef blob parameter, and adopt "advance" in more places. llvm-svn: 172951
2013-01-20 10:38:54 +08:00
StringRef Blob;
switch (SLocEntryCursor.readRecord(Entry.ID, Record, &Blob)) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
default:
Error("incorrectly-formatted source location entry in AST file");
return true;
case SM_SLOC_FILE_ENTRY: {
// We will detect whether a file changed and return 'Failure' for it, but
// we will also try to fail gracefully by setting up the SLocEntry.
unsigned InputID = Record[4];
InputFile IF = getInputFile(*F, InputID);
[PCH] Enhance InputFile to also include whether the file is out-of-date. Previously we would return null for an out-of-date file. This inhibited ASTReader::ReadSLocEntry from creating a FileID to recover gracefully in such a case. llvm-svn: 176332
2013-03-01 11:26:04 +08:00
const FileEntry *File = IF.getFile();
bool OverriddenBuffer = IF.isOverridden();
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
[PCH] Enhance InputFile to also include whether the file is out-of-date. Previously we would return null for an out-of-date file. This inhibited ASTReader::ReadSLocEntry from creating a FileID to recover gracefully in such a case. llvm-svn: 176332
2013-03-01 11:26:04 +08:00
// Note that we only check if a File was returned. If it was out-of-date
// we have complained but we will continue creating a FileID to recover
// gracefully.
if (!File)
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
return true;
SourceLocation IncludeLoc = ReadSourceLocation(*F, Record[1]);
if (IncludeLoc.isInvalid() && F->Kind != MK_MainFile) {
// This is the module's main file.
IncludeLoc = getImportLocation(F);
}
SrcMgr::CharacteristicKind
FileCharacter = (SrcMgr::CharacteristicKind)Record[2];
FileID FID = SourceMgr.createFileID(File, IncludeLoc, FileCharacter,
ID, BaseOffset + Record[0]);
SrcMgr::FileInfo &FileInfo =
const_cast<SrcMgr::FileInfo&>(SourceMgr.getSLocEntry(FID).getFile());
FileInfo.NumCreatedFIDs = Record[5];
if (Record[3])
FileInfo.setHasLineDirectives();
const DeclID *FirstDecl = F->FileSortedDecls + Record[6];
unsigned NumFileDecls = Record[7];
if (NumFileDecls) {
assert(F->FileSortedDecls && "FILE_SORTED_DECLS not encountered yet ?");
FileDeclIDs[FID] = FileDeclsInfo(F, llvm::makeArrayRef(FirstDecl,
NumFileDecls));
}
const SrcMgr::ContentCache *ContentCache
= SourceMgr.getOrCreateContentCache(File,
/*isSystemFile=*/FileCharacter != SrcMgr::C_User);
if (OverriddenBuffer && !ContentCache->BufferOverridden &&
[modules] Refactor handling of -fmodules-embed-*. Track this properly rather than reusing the "overridden buffer" mechanism. This will allow us to make embedded files and overridden files behave differently in future. llvm-svn: 254121
2015-11-26 10:04:16 +08:00
ContentCache->ContentsEntry == ContentCache->OrigEntry &&
!ContentCache->getRawBuffer()) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
unsigned Code = SLocEntryCursor.ReadCode();
Record.clear();
update to use the new BitcodeCursor readRecord that takes a StringRef blob parameter, and adopt "advance" in more places. llvm-svn: 172951
2013-01-20 10:38:54 +08:00
unsigned RecCode = SLocEntryCursor.readRecord(Code, Record, &Blob);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
if (RecCode != SM_SLOC_BUFFER_BLOB) {
Error("AST record has invalid code");
return true;
}
Update for LLVM api change. llvm-svn: 216585
2014-08-28 04:03:29 +08:00
std::unique_ptr<llvm::MemoryBuffer> Buffer
update to use the new BitcodeCursor readRecord that takes a StringRef blob parameter, and adopt "advance" in more places. llvm-svn: 172951
2013-01-20 10:38:54 +08:00
= llvm::MemoryBuffer::getMemBuffer(Blob.drop_back(1), File->getName());
Overload SourceManager::overrideFileContents so that unconditionally passing ownership is explicitly done using unique_ptr. Only those callers who are dynamically passing ownership should need the 3 argument form. Those accepting the default ("do pass ownership") should do so explicitly with a unique_ptr now. llvm-svn: 216614
2014-08-28 04:54:45 +08:00
SourceMgr.overrideFileContents(File, std::move(Buffer));
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
break;
}
case SM_SLOC_BUFFER_ENTRY: {
update to use the new BitcodeCursor readRecord that takes a StringRef blob parameter, and adopt "advance" in more places. llvm-svn: 172951
2013-01-20 10:38:54 +08:00
const char *Name = Blob.data();
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
unsigned Offset = Record[0];
SrcMgr::CharacteristicKind
FileCharacter = (SrcMgr::CharacteristicKind)Record[2];
SourceLocation IncludeLoc = ReadSourceLocation(*F, Record[1]);
[modules] Initial support for explicitly loading .pcm files. Implicit module builds are not well-suited to a lot of build systems. In particular, they fare badly in distributed build systems, and they lead to build artifacts that are not tracked as part of the usual dependency management process. This change allows explicitly-built module files (which are already supported through the -emit-module flag) to be explicitly loaded into a build, allowing build systems to opt to manage module builds and dependencies themselves. This is only the first step in supporting such configurations, and it should be considered experimental and subject to change or removal for now. llvm-svn: 220359
2014-10-22 10:05:46 +08:00
if (IncludeLoc.isInvalid() &&
(F->Kind == MK_ImplicitModule || F->Kind == MK_ExplicitModule)) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
IncludeLoc = getImportLocation(F);
}
unsigned Code = SLocEntryCursor.ReadCode();
Record.clear();
unsigned RecCode
update to use the new BitcodeCursor readRecord that takes a StringRef blob parameter, and adopt "advance" in more places. llvm-svn: 172951
2013-01-20 10:38:54 +08:00
= SLocEntryCursor.readRecord(Code, Record, &Blob);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
if (RecCode != SM_SLOC_BUFFER_BLOB) {
Error("AST record has invalid code");
return true;
}
Update for LLVM api change. llvm-svn: 216585
2014-08-28 04:03:29 +08:00
std::unique_ptr<llvm::MemoryBuffer> Buffer =
llvm::MemoryBuffer::getMemBuffer(Blob.drop_back(1), Name);
unique_ptrify SourceManager::createFileID llvm-svn: 216715
2014-08-29 15:59:55 +08:00
SourceMgr.createFileID(std::move(Buffer), FileCharacter, ID,
Update for LLVM api change. llvm-svn: 216585
2014-08-28 04:03:29 +08:00
BaseOffset + Offset, IncludeLoc);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
break;
}
case SM_SLOC_EXPANSION_ENTRY: {
SourceLocation SpellingLoc = ReadSourceLocation(*F, Record[1]);
SourceMgr.createExpansionLoc(SpellingLoc,
ReadSourceLocation(*F, Record[2]),
ReadSourceLocation(*F, Record[3]),
Record[4],
ID,
BaseOffset + Record[0]);
break;
}
}
return false;
}
std::pair<SourceLocation, StringRef> ASTReader::getModuleImportLoc(int ID) {
if (ID == 0)
return std::make_pair(SourceLocation(), "");
if (unsigned(-ID) - 2 >= getTotalNumSLocs() || ID > 0) {
Error("source location entry ID out-of-range for AST file");
return std::make_pair(SourceLocation(), "");
}
// Find which module file this entry lands in.
ModuleFile *M = GlobalSLocEntryMap.find(-ID)->second;
[modules] Initial support for explicitly loading .pcm files. Implicit module builds are not well-suited to a lot of build systems. In particular, they fare badly in distributed build systems, and they lead to build artifacts that are not tracked as part of the usual dependency management process. This change allows explicitly-built module files (which are already supported through the -emit-module flag) to be explicitly loaded into a build, allowing build systems to opt to manage module builds and dependencies themselves. This is only the first step in supporting such configurations, and it should be considered experimental and subject to change or removal for now. llvm-svn: 220359
2014-10-22 10:05:46 +08:00
if (M->Kind != MK_ImplicitModule && M->Kind != MK_ExplicitModule)
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
return std::make_pair(SourceLocation(), "");
// FIXME: Can we map this down to a particular submodule? That would be
// ideal.
Allow multiple modules with the same name to coexist in the module cache To differentiate between two modules with the same name, we will consider the path the module map file that they are defined by* part of the ‘key’ for looking up the precompiled module (pcm file). Specifically, this patch renames the precompiled module (pcm) files from cache-path/<module hash>/Foo.pcm to cache-path/<module hash>/Foo-<hash of module map path>.pcm In addition, I’ve taught the ASTReader to re-resolve the names of imported modules during module loading so that if the header search context changes between when a module was originally built and when it is loaded we can rebuild it if necessary. For example, if module A imports module B first time: clang -I /path/to/A -I /path/to/B ... second time: clang -I /path/to/A -I /different/path/to/B ... will now rebuild A as expected. * in the case of inferred modules, we use the module map file that allowed the inference, not the __inferred_module.map file, since the inferred file path is the same for every inferred module. llvm-svn: 206201
2014-04-15 02:00:01 +08:00
return std::make_pair(M->ImportLoc, StringRef(M->ModuleName));
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
/// \brief Find the location where the module F is imported.
SourceLocation ASTReader::getImportLocation(ModuleFile *F) {
if (F->ImportLoc.isValid())
return F->ImportLoc;
// Otherwise we have a PCH. It's considered to be "imported" at the first
// location of its includer.
if (F->ImportedBy.empty() || !F->ImportedBy[0]) {
Allow multiple modules with the same name to coexist in the module cache To differentiate between two modules with the same name, we will consider the path the module map file that they are defined by* part of the ‘key’ for looking up the precompiled module (pcm file). Specifically, this patch renames the precompiled module (pcm) files from cache-path/<module hash>/Foo.pcm to cache-path/<module hash>/Foo-<hash of module map path>.pcm In addition, I’ve taught the ASTReader to re-resolve the names of imported modules during module loading so that if the header search context changes between when a module was originally built and when it is loaded we can rebuild it if necessary. For example, if module A imports module B first time: clang -I /path/to/A -I /path/to/B ... second time: clang -I /path/to/A -I /different/path/to/B ... will now rebuild A as expected. * in the case of inferred modules, we use the module map file that allowed the inference, not the __inferred_module.map file, since the inferred file path is the same for every inferred module. llvm-svn: 206201
2014-04-15 02:00:01 +08:00
// Main file is the importer.
Replace double negation of !FileID.isInvalid() with FileID.isValid(). +couple more of double-negated !SourceLocation.isInvalid() unfixed in r249228. llvm-svn: 249235
2015-10-03 18:46:20 +08:00
assert(SourceMgr.getMainFileID().isValid() && "missing main file");
Allow multiple modules with the same name to coexist in the module cache To differentiate between two modules with the same name, we will consider the path the module map file that they are defined by* part of the ‘key’ for looking up the precompiled module (pcm file). Specifically, this patch renames the precompiled module (pcm) files from cache-path/<module hash>/Foo.pcm to cache-path/<module hash>/Foo-<hash of module map path>.pcm In addition, I’ve taught the ASTReader to re-resolve the names of imported modules during module loading so that if the header search context changes between when a module was originally built and when it is loaded we can rebuild it if necessary. For example, if module A imports module B first time: clang -I /path/to/A -I /path/to/B ... second time: clang -I /path/to/A -I /different/path/to/B ... will now rebuild A as expected. * in the case of inferred modules, we use the module map file that allowed the inference, not the __inferred_module.map file, since the inferred file path is the same for every inferred module. llvm-svn: 206201
2014-04-15 02:00:01 +08:00
return SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID());
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
return F->ImportedBy[0]->FirstLoc;
}
/// 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.
finish converting the normal cases in ASTReader to use the new BitstreamCursor APIs. llvm-svn: 172937
2013-01-20 08:56:42 +08:00
bool ASTReader::ReadBlockAbbrevs(BitstreamCursor &Cursor, unsigned BlockID) {
[modules] Write the options records to a separate subblock rather than writing them directly to the control block. These are fairly large, and in a build with lots of modules / chained PCH, we don't need to read most of them. No functionality change intended. llvm-svn: 247055
2015-09-09 03:40:14 +08:00
if (Cursor.EnterSubBlock(BlockID))
return true;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
while (true) {
uint64_t Offset = Cursor.GetCurrentBitNo();
unsigned Code = Cursor.ReadCode();
// We expect all abbrevs to be at the start of the block.
if (Code != llvm::bitc::DEFINE_ABBREV) {
Cursor.JumpToBit(Offset);
return false;
}
Cursor.ReadAbbrevRecord();
}
}
PR9992: Serialize and deserialize the token sequence for a function template in -fdelayed-template-parsing mode. Patch by Will Wilson! llvm-svn: 187916
2013-08-08 05:41:30 +08:00
Token ASTReader::ReadToken(ModuleFile &F, const RecordDataImpl &Record,
Move parsing of identifiers in MS-style inline assembly into the actual parser and support arbitrary id-expressions. We're actually basically set up to do arbitrary expressions here if we wanted to. Assembly operands permit things like A::x to be written regardless of language mode, which forces us to embellish the evaluation context logic somewhat. The logic here under template instantiation is incorrect; we need to preserve the fact that an expression was unevaluated. Of course, template instantiation in general is fishy here because we have no way of delaying semantic analysis in the MC parser. It's all just fishy. I've also fixed the serialization of MS asm statements. This commit depends on an LLVM commit. llvm-svn: 180976
2013-05-03 08:10:13 +08:00
unsigned &Idx) {
Token Tok;
Tok.startToken();
Tok.setLocation(ReadSourceLocation(F, Record, Idx));
Tok.setLength(Record[Idx++]);
if (IdentifierInfo *II = getLocalIdentifier(F, Record[Idx++]))
Tok.setIdentifierInfo(II);
Tok.setKind((tok::TokenKind)Record[Idx++]);
Tok.setFlag((Token::TokenFlags)Record[Idx++]);
return Tok;
}
[PCH/Modules] De/Serialize MacroInfos separately than MacroDirectives. -Serialize the macro directives history into its own section -Get rid of the macro updates section -When de/serializing an identifier from a module, associate only one macro per submodule that defined+exported it. llvm-svn: 177761
2013-03-23 05:12:57 +08:00
MacroInfo *ASTReader::ReadMacroRecord(ModuleFile &F, uint64_t Offset) {
finish converting the normal cases in ASTReader to use the new BitstreamCursor APIs. llvm-svn: 172937
2013-01-20 08:56:42 +08:00
BitstreamCursor &Stream = F.MacroCursor;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +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);
RecordData Record;
SmallVector<IdentifierInfo*, 16> MacroArgs;
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
MacroInfo *Macro = nullptr;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
while (true) {
convert some more stuff over to use new cursor APIs. llvm-svn: 172932
2013-01-20 08:00:22 +08:00
// Advance to the next record, but if we get to the end of the block, don't
// pop it (removing all the abbreviations from the cursor) since we want to
// be able to reseek within the block and read entries.
finish converting the normal cases in ASTReader to use the new BitstreamCursor APIs. llvm-svn: 172937
2013-01-20 08:56:42 +08:00
unsigned Flags = BitstreamCursor::AF_DontPopBlockAtEnd;
convert some more stuff over to use new cursor APIs. llvm-svn: 172932
2013-01-20 08:00:22 +08:00
llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks(Flags);
switch (Entry.Kind) {
case llvm::BitstreamEntry::SubBlock: // Handled for us already.
case llvm::BitstreamEntry::Error:
Error("malformed block record in AST file");
[PCH/Modules] De/Serialize MacroInfos separately than MacroDirectives. -Serialize the macro directives history into its own section -Get rid of the macro updates section -When de/serializing an identifier from a module, associate only one macro per submodule that defined+exported it. llvm-svn: 177761
2013-03-23 05:12:57 +08:00
return Macro;
convert some more stuff over to use new cursor APIs. llvm-svn: 172932
2013-01-20 08:00:22 +08:00
case llvm::BitstreamEntry::EndBlock:
[PCH/Modules] De/Serialize MacroInfos separately than MacroDirectives. -Serialize the macro directives history into its own section -Get rid of the macro updates section -When de/serializing an identifier from a module, associate only one macro per submodule that defined+exported it. llvm-svn: 177761
2013-03-23 05:12:57 +08:00
return Macro;
convert some more stuff over to use new cursor APIs. llvm-svn: 172932
2013-01-20 08:00:22 +08:00
case llvm::BitstreamEntry::Record:
// The interesting case.
break;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
// Read a record.
Record.clear();
PreprocessorRecordTypes RecType =
update to use the new BitcodeCursor readRecord that takes a StringRef blob parameter, and adopt "advance" in more places. llvm-svn: 172951
2013-01-20 10:38:54 +08:00
(PreprocessorRecordTypes)Stream.readRecord(Entry.ID, Record);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
switch (RecType) {
[modules] Move list of exported module macros from IdentifierInfo lookup table to separate storage, adjacent to the macro directive history. This is substantially simpler, provides better space usage accounting in bcanalyzer, and gives a more compact representation. No functionality change intended. llvm-svn: 235420
2015-04-22 05:46:32 +08:00
case PP_MODULE_MACRO:
[PCH/Modules] De/Serialize MacroInfos separately than MacroDirectives. -Serialize the macro directives history into its own section -Get rid of the macro updates section -When de/serializing an identifier from a module, associate only one macro per submodule that defined+exported it. llvm-svn: 177761
2013-03-23 05:12:57 +08:00
case PP_MACRO_DIRECTIVE_HISTORY:
return Macro;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
case PP_MACRO_OBJECT_LIKE:
case PP_MACRO_FUNCTION_LIKE: {
// 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)
[PCH/Modules] De/Serialize MacroInfos separately than MacroDirectives. -Serialize the macro directives history into its own section -Get rid of the macro updates section -When de/serializing an identifier from a module, associate only one macro per submodule that defined+exported it. llvm-svn: 177761
2013-03-23 05:12:57 +08:00
return Macro;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
[PCH/Modules] De/Serialize MacroInfos separately than MacroDirectives. -Serialize the macro directives history into its own section -Get rid of the macro updates section -When de/serializing an identifier from a module, associate only one macro per submodule that defined+exported it. llvm-svn: 177761
2013-03-23 05:12:57 +08:00
unsigned NextIndex = 1; // Skip identifier ID.
SubmoduleID SubModID = getGlobalSubmoduleID(F, Record[NextIndex++]);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
SourceLocation Loc = ReadSourceLocation(F, Record, NextIndex);
[PCH/Modules] De/Serialize MacroInfos separately than MacroDirectives. -Serialize the macro directives history into its own section -Get rid of the macro updates section -When de/serializing an identifier from a module, associate only one macro per submodule that defined+exported it. llvm-svn: 177761
2013-03-23 05:12:57 +08:00
MacroInfo *MI = PP.AllocateDeserializedMacroInfo(Loc, SubModID);
[PCH] (De)serialize the end location of MacroInfo. llvm-svn: 171772
2013-01-08 03:16:23 +08:00
MI->setDefinitionEndLoc(ReadSourceLocation(F, Record, NextIndex));
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
MI->setIsUsed(Record[NextIndex++]);
[Preprocessor/CodeComplete] Don't add include guard macros to code-completion results. llvm-svn: 205917
2014-04-10 02:21:23 +08:00
MI->setUsedForHeaderGuard(Record[NextIndex++]);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
if (RecType == PP_MACRO_FUNCTION_LIKE) {
// Decode function-like macro info.
bool isC99VarArgs = Record[NextIndex++];
bool isGNUVarArgs = Record[NextIndex++];
bool hasCommaPasting = Record[NextIndex++];
MacroArgs.clear();
unsigned NumArgs = Record[NextIndex++];
for (unsigned i = 0; i != NumArgs; ++i)
MacroArgs.push_back(getLocalIdentifier(F, Record[NextIndex++]));
// Install function-like macro info.
MI->setIsFunctionLike();
if (isC99VarArgs) MI->setIsC99Varargs();
if (isGNUVarArgs) MI->setIsGNUVarargs();
if (hasCommaPasting) MI->setHasCommaPasting();
Change MacroInfo::setArgumentList to take an ArrayRef instead of pointer and size. While there use std::copy intead of a manual loop. llvm-svn: 250987
2015-10-22 12:59:52 +08:00
MI->setArgumentList(MacroArgs, PP.getPreprocessorAllocator());
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
// Remember that we saw this macro last so that we add the tokens that
// form its body to it.
Macro = MI;
if (NextIndex + 1 == Record.size() && PP.getPreprocessingRecord() &&
Record[NextIndex]) {
// We have a macro definition. Register the association
PreprocessedEntityID
GlobalID = getGlobalPreprocessedEntityID(F, Record[NextIndex]);
PreprocessingRecord &PPRec = *PP.getPreprocessingRecord();
Rename MacroDefinition -> MacroDefinitionRecord, Preprocessor::MacroDefinition -> MacroDefinition. clang::MacroDefinition now models the currently-defined value of a macro. The previous MacroDefinition type, which represented a record of a macro definition directive for a detailed preprocessing record, is now called MacroDefinitionRecord. llvm-svn: 236400
2015-05-04 10:25:31 +08:00
PreprocessingRecord::PPEntityID PPID =
PPRec.getPPEntityID(GlobalID - 1, /*isLoaded=*/true);
MacroDefinitionRecord *PPDef = cast_or_null<MacroDefinitionRecord>(
PPRec.getPreprocessedEntity(PPID));
[preprocessing record] Have the MacroDefinitions map point to the MacroDefinition object instead its index in the preprocessed entities vector. This is because the order of the entities in the vector can change in some (uncommon) cases. llvm-svn: 175907
2013-02-23 02:35:59 +08:00
if (PPDef)
PPRec.RegisterMacroDefinition(Macro, PPDef);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
++NumMacrosRead;
break;
}
case PP_TOKEN: {
// If we see a TOKEN before a PP_MACRO_*, then the file is
// erroneous, just pretend we didn't see this.
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
if (!Macro) break;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
Move parsing of identifiers in MS-style inline assembly into the actual parser and support arbitrary id-expressions. We're actually basically set up to do arbitrary expressions here if we wanted to. Assembly operands permit things like A::x to be written regardless of language mode, which forces us to embellish the evaluation context logic somewhat. The logic here under template instantiation is incorrect; we need to preserve the fact that an expression was unevaluated. Of course, template instantiation in general is fishy here because we have no way of delaying semantic analysis in the MC parser. It's all just fishy. I've also fixed the serialization of MS asm statements. This commit depends on an LLVM commit. llvm-svn: 180976
2013-05-03 08:10:13 +08:00
unsigned Idx = 0;
Token Tok = ReadToken(F, Record, Idx);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
Macro->AddTokenToBody(Tok);
break;
}
}
}
}
PreprocessedEntityID
ASTReader::getGlobalPreprocessedEntityID(ModuleFile &M, unsigned LocalID) const {
ContinuousRangeMap<uint32_t, int, 2>::const_iterator
I = M.PreprocessedEntityRemap.find(LocalID - NUM_PREDEF_PP_ENTITY_IDS);
assert(I != M.PreprocessedEntityRemap.end()
&& "Invalid index into preprocessed entity index remap");
return LocalID + I->second;
}
[PCH] For HeaderFileInfoTrait, hash the key using size & time of the file. Previously the hash would be the filename portion of the path, which could be different for a filename with different case or a symbolic link with a different name completely. This did not actually create any issue so far because by validating all headers in the PCH we created uniqued FileEntries based on inodes, so an #include of a symbolic link (refering to a file from the PCH) would end up with a FileEntry with filename same as the one recorded in the PCH. llvm-svn: 176566
2013-03-07 02:12:47 +08:00
unsigned HeaderFileInfoTrait::ComputeHash(internal_key_ref ikey) {
return llvm::hash_combine(ikey.Size, ikey.ModTime);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
[modules] Instead of storing absolute paths in a .pcm file, store the path to the root of the module and use paths relative to that directory wherever possible. This is a step towards allowing explicit modules to be relocated without being rebuilt, which is important for some kinds of distributed builds, for good paths in diagnostics, and for appropriate .d output. This is a recommit of r223443, reverted in r223465; when joining together imported file paths, we now use the system's separator rather than always using '/'. This avoids path mismatches between the original module build and the module user on Windows (at least, in some cases). A more comprehensive fix will follow. llvm-svn: 223539
2014-12-06 06:42:13 +08:00
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
HeaderFileInfoTrait::internal_key_type
[PCH] For HeaderFileInfoTrait, hash the key using size & time of the file. Previously the hash would be the filename portion of the path, which could be different for a filename with different case or a symbolic link with a different name completely. This did not actually create any issue so far because by validating all headers in the PCH we created uniqued FileEntries based on inodes, so an #include of a symbolic link (refering to a file from the PCH) would end up with a FileEntry with filename same as the one recorded in the PCH. llvm-svn: 176566
2013-03-07 02:12:47 +08:00
HeaderFileInfoTrait::GetInternalKey(const FileEntry *FE) {
[modules] When explicitly building a module file, don't include timestamps in the produced pcm file for stable file creation across distributed build systems. llvm-svn: 245199
2015-08-17 15:13:32 +08:00
internal_key_type ikey = {FE->getSize(),
M.HasTimestamps ? FE->getModificationTime() : 0,
FE->getName(), /*Imported*/ false};
[PCH] For HeaderFileInfoTrait, hash the key using size & time of the file. Previously the hash would be the filename portion of the path, which could be different for a filename with different case or a symbolic link with a different name completely. This did not actually create any issue so far because by validating all headers in the PCH we created uniqued FileEntries based on inodes, so an #include of a symbolic link (refering to a file from the PCH) would end up with a FileEntry with filename same as the one recorded in the PCH. llvm-svn: 176566
2013-03-07 02:12:47 +08:00
return ikey;
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
[PCH] For HeaderFileInfoTrait, hash the key using size & time of the file. Previously the hash would be the filename portion of the path, which could be different for a filename with different case or a symbolic link with a different name completely. This did not actually create any issue so far because by validating all headers in the PCH we created uniqued FileEntries based on inodes, so an #include of a symbolic link (refering to a file from the PCH) would end up with a FileEntry with filename same as the one recorded in the PCH. llvm-svn: 176566
2013-03-07 02:12:47 +08:00
bool HeaderFileInfoTrait::EqualKey(internal_key_ref a, internal_key_ref b) {
[modules] When explicitly building a module file, don't include timestamps in the produced pcm file for stable file creation across distributed build systems. llvm-svn: 245199
2015-08-17 15:13:32 +08:00
if (a.Size != b.Size || (a.ModTime && b.ModTime && a.ModTime != b.ModTime))
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
return false;
[modules] Instead of storing absolute paths in a .pcm file, store the path to the root of the module and use paths relative to that directory wherever possible. This is a step towards allowing explicit modules to be relocated without being rebuilt, which is important for some kinds of distributed builds, for good paths in diagnostics, and for appropriate .d output. This is a recommit of r223443, reverted in r223465; when joining together imported file paths, we now use the system's separator rather than always using '/'. This avoids path mismatches between the original module build and the module user on Windows (at least, in some cases). A more comprehensive fix will follow. llvm-svn: 223539
2014-12-06 06:42:13 +08:00
if (llvm::sys::path::is_absolute(a.Filename) &&
strcmp(a.Filename, b.Filename) == 0)
[PCH] For HeaderFileInfoTrait, hash the key using size & time of the file. Previously the hash would be the filename portion of the path, which could be different for a filename with different case or a symbolic link with a different name completely. This did not actually create any issue so far because by validating all headers in the PCH we created uniqued FileEntries based on inodes, so an #include of a symbolic link (refering to a file from the PCH) would end up with a FileEntry with filename same as the one recorded in the PCH. llvm-svn: 176566
2013-03-07 02:12:47 +08:00
return true;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
// Determine whether the actual files are equivalent.
[PCH] In HeaderFileInfoTrait::EqualKey(), use FileManager::getFile() to compare two filenames, instead of llvm::sys::fs::equivalent(). llvm::sys::fs::equivalent() does 2 stat calls every time it's called. Use FileManager::getFile() to take advantage of the stat caching that FileManager is providing. llvm-svn: 176450
2013-03-05 04:33:40 +08:00
FileManager &FileMgr = Reader.getFileManager();
[modules] Instead of storing absolute paths in a .pcm file, store the path to the root of the module and use paths relative to that directory wherever possible. This is a step towards allowing explicit modules to be relocated without being rebuilt, which is important for some kinds of distributed builds, for good paths in diagnostics, and for appropriate .d output. This is a recommit of r223443, reverted in r223465; when joining together imported file paths, we now use the system's separator rather than always using '/'. This avoids path mismatches between the original module build and the module user on Windows (at least, in some cases). A more comprehensive fix will follow. llvm-svn: 223539
2014-12-06 06:42:13 +08:00
auto GetFile = [&](const internal_key_type &Key) -> const FileEntry* {
if (!Key.Imported)
return FileMgr.getFile(Key.Filename);
std::string Resolved = Key.Filename;
Reader.ResolveImportedPath(M, Resolved);
return FileMgr.getFile(Resolved);
};
const FileEntry *FEA = GetFile(a);
const FileEntry *FEB = GetFile(b);
return FEA && FEA == FEB;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
std::pair<unsigned, unsigned>
HeaderFileInfoTrait::ReadKeyDataLength(const unsigned char*& d) {
Reapply "OnDiskHashTable: Use Endian.h to read little endian ostreams" Committed this by accident before it was done last time. Original message: Rather than rolling our own functions to read little endian data from a buffer, we can use the support in llvm's Endian.h. No functional change. llvm-svn: 205062
2014-03-29 06:03:24 +08:00
using namespace llvm::support;
unsigned KeyLen = (unsigned) endian::readNext<uint16_t, little, unaligned>(d);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
unsigned DataLen = (unsigned) *d++;
[PCH] For HeaderFileInfoTrait, hash the key using size & time of the file. Previously the hash would be the filename portion of the path, which could be different for a filename with different case or a symbolic link with a different name completely. This did not actually create any issue so far because by validating all headers in the PCH we created uniqued FileEntries based on inodes, so an #include of a symbolic link (refering to a file from the PCH) would end up with a FileEntry with filename same as the one recorded in the PCH. llvm-svn: 176566
2013-03-07 02:12:47 +08:00
return std::make_pair(KeyLen, DataLen);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
[PCH] For HeaderFileInfoTrait, hash the key using size & time of the file. Previously the hash would be the filename portion of the path, which could be different for a filename with different case or a symbolic link with a different name completely. This did not actually create any issue so far because by validating all headers in the PCH we created uniqued FileEntries based on inodes, so an #include of a symbolic link (refering to a file from the PCH) would end up with a FileEntry with filename same as the one recorded in the PCH. llvm-svn: 176566
2013-03-07 02:12:47 +08:00
HeaderFileInfoTrait::internal_key_type
HeaderFileInfoTrait::ReadKey(const unsigned char *d, unsigned) {
Reapply "OnDiskHashTable: Use Endian.h to read little endian ostreams" Committed this by accident before it was done last time. Original message: Rather than rolling our own functions to read little endian data from a buffer, we can use the support in llvm's Endian.h. No functional change. llvm-svn: 205062
2014-03-29 06:03:24 +08:00
using namespace llvm::support;
[PCH] For HeaderFileInfoTrait, hash the key using size & time of the file. Previously the hash would be the filename portion of the path, which could be different for a filename with different case or a symbolic link with a different name completely. This did not actually create any issue so far because by validating all headers in the PCH we created uniqued FileEntries based on inodes, so an #include of a symbolic link (refering to a file from the PCH) would end up with a FileEntry with filename same as the one recorded in the PCH. llvm-svn: 176566
2013-03-07 02:12:47 +08:00
internal_key_type ikey;
Reapply "OnDiskHashTable: Use Endian.h to read little endian ostreams" Committed this by accident before it was done last time. Original message: Rather than rolling our own functions to read little endian data from a buffer, we can use the support in llvm's Endian.h. No functional change. llvm-svn: 205062
2014-03-29 06:03:24 +08:00
ikey.Size = off_t(endian::readNext<uint64_t, little, unaligned>(d));
ikey.ModTime = time_t(endian::readNext<uint64_t, little, unaligned>(d));
[PCH] For HeaderFileInfoTrait, hash the key using size & time of the file. Previously the hash would be the filename portion of the path, which could be different for a filename with different case or a symbolic link with a different name completely. This did not actually create any issue so far because by validating all headers in the PCH we created uniqued FileEntries based on inodes, so an #include of a symbolic link (refering to a file from the PCH) would end up with a FileEntry with filename same as the one recorded in the PCH. llvm-svn: 176566
2013-03-07 02:12:47 +08:00
ikey.Filename = (const char *)d;
[modules] Instead of storing absolute paths in a .pcm file, store the path to the root of the module and use paths relative to that directory wherever possible. This is a step towards allowing explicit modules to be relocated without being rebuilt, which is important for some kinds of distributed builds, for good paths in diagnostics, and for appropriate .d output. This is a recommit of r223443, reverted in r223465; when joining together imported file paths, we now use the system's separator rather than always using '/'. This avoids path mismatches between the original module build and the module user on Windows (at least, in some cases). A more comprehensive fix will follow. llvm-svn: 223539
2014-12-06 06:42:13 +08:00
ikey.Imported = true;
[PCH] For HeaderFileInfoTrait, hash the key using size & time of the file. Previously the hash would be the filename portion of the path, which could be different for a filename with different case or a symbolic link with a different name completely. This did not actually create any issue so far because by validating all headers in the PCH we created uniqued FileEntries based on inodes, so an #include of a symbolic link (refering to a file from the PCH) would end up with a FileEntry with filename same as the one recorded in the PCH. llvm-svn: 176566
2013-03-07 02:12:47 +08:00
return ikey;
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
HeaderFileInfoTrait::data_type
[Modules] Don't eagerly load and associate all the module header files. In a module-enabled Cocoa PCH file, we spend a lot of time stat'ing the headers in order to associate the FileEntries with their modules and support implicit module import. Use a more lazy scheme by enhancing HeaderInfoTable to store extra info about the module that a header belongs to, and associate it with its module only when there is a request for loading the header info for a particular file. Part of rdar://13391765 llvm-svn: 176976
2013-03-14 05:13:51 +08:00
HeaderFileInfoTrait::ReadData(internal_key_ref key, const unsigned char *d,
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
unsigned DataLen) {
const unsigned char *End = d + DataLen;
Reapply "OnDiskHashTable: Use Endian.h to read little endian ostreams" Committed this by accident before it was done last time. Original message: Rather than rolling our own functions to read little endian data from a buffer, we can use the support in llvm's Endian.h. No functional change. llvm-svn: 205062
2014-03-29 06:03:24 +08:00
using namespace llvm::support;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
HeaderFileInfo HFI;
unsigned Flags = *d++;
[modules] Fix HeaderFileInfo serialization to store all the known owning modules for a header, not just the current favourite. llvm-svn: 245390
2015-08-19 07:42:23 +08:00
// FIXME: Refactor with mergeHeaderFileInfo in HeaderSearch.cpp.
HFI.isImport |= (Flags >> 4) & 0x01;
HFI.isPragmaOnce |= (Flags >> 3) & 0x01;
HFI.DirInfo = (Flags >> 1) & 0x03;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
HFI.IndexHeaderMapHeader = Flags & 0x01;
[modules] Fix HeaderFileInfo serialization to store all the known owning modules for a header, not just the current favourite. llvm-svn: 245390
2015-08-19 07:42:23 +08:00
// FIXME: Find a better way to handle this. Maybe just store a
// "has been included" flag?
HFI.NumIncludes = std::max(endian::readNext<uint16_t, little, unaligned>(d),
HFI.NumIncludes);
Reapply "OnDiskHashTable: Use Endian.h to read little endian ostreams" Committed this by accident before it was done last time. Original message: Rather than rolling our own functions to read little endian data from a buffer, we can use the support in llvm's Endian.h. No functional change. llvm-svn: 205062
2014-03-29 06:03:24 +08:00
HFI.ControllingMacroID = Reader.getGlobalIdentifierID(
M, endian::readNext<uint32_t, little, unaligned>(d));
if (unsigned FrameworkOffset =
endian::readNext<uint32_t, little, unaligned>(d)) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
// The framework offset is 1 greater than the actual offset,
// since 0 is used as an indicator for "no framework name".
StringRef FrameworkName(FrameworkStrings + FrameworkOffset - 1);
HFI.Framework = HS->getUniqueFrameworkName(FrameworkName);
}
[modules] Fix HeaderFileInfo serialization to store all the known owning modules for a header, not just the current favourite. llvm-svn: 245390
2015-08-19 07:42:23 +08:00
assert((End - d) % 4 == 0 &&
"Wrong data length in HeaderFileInfo deserialization");
while (d != End) {
Reapply "OnDiskHashTable: Use Endian.h to read little endian ostreams" Committed this by accident before it was done last time. Original message: Rather than rolling our own functions to read little endian data from a buffer, we can use the support in llvm's Endian.h. No functional change. llvm-svn: 205062
2014-03-29 06:03:24 +08:00
uint32_t LocalSMID = endian::readNext<uint32_t, little, unaligned>(d);
[modules] Fix HeaderFileInfo serialization to store all the known owning modules for a header, not just the current favourite. llvm-svn: 245390
2015-08-19 07:42:23 +08:00
auto HeaderRole = static_cast<ModuleMap::ModuleHeaderRole>(LocalSMID & 3);
LocalSMID >>= 2;
// This header is part of a module. Associate it with the module to enable
// implicit module import.
SubmoduleID GlobalSMID = Reader.getGlobalSubmoduleID(M, LocalSMID);
Module *Mod = Reader.getSubmodule(GlobalSMID);
FileManager &FileMgr = Reader.getFileManager();
ModuleMap &ModMap =
Reader.getPreprocessor().getHeaderSearchInfo().getModuleMap();
std::string Filename = key.Filename;
if (key.Imported)
Reader.ResolveImportedPath(M, Filename);
// FIXME: This is not always the right filename-as-written, but we're not
// going to use this information to rebuild the module, so it doesn't make
// a lot of difference.
Module::Header H = { key.Filename, FileMgr.getFile(Filename) };
[modules] Remove unnecessary deserialization of fully-external HeaderFileInfos for all files we've seen in this compilation. llvm-svn: 245881
2015-08-25 05:59:32 +08:00
ModMap.addHeader(Mod, H, HeaderRole, /*Imported*/true);
HFI.isModuleHeader |= !(HeaderRole & ModuleMap::TextualHeader);
[Modules] Don't eagerly load and associate all the module header files. In a module-enabled Cocoa PCH file, we spend a lot of time stat'ing the headers in order to associate the FileEntries with their modules and support implicit module import. Use a more lazy scheme by enhancing HeaderInfoTable to store extra info about the module that a header belongs to, and associate it with its module only when there is a request for loading the header info for a particular file. Part of rdar://13391765 llvm-svn: 176976
2013-03-14 05:13:51 +08:00
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
// This HeaderFileInfo was externally loaded.
HFI.External = true;
[modules] Remove unnecessary deserialization of fully-external HeaderFileInfos for all files we've seen in this compilation. llvm-svn: 245881
2015-08-25 05:59:32 +08:00
HFI.IsValid = true;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
return HFI;
}
[modules] Move list of exported module macros from IdentifierInfo lookup table to separate storage, adjacent to the macro directive history. This is substantially simpler, provides better space usage accounting in bcanalyzer, and gives a more compact representation. No functionality change intended. llvm-svn: 235420
2015-04-22 05:46:32 +08:00
void ASTReader::addPendingMacro(IdentifierInfo *II,
ModuleFile *M,
uint64_t MacroDirectivesOffset) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
assert(NumCurrentElementsDeserializing > 0 &&"Missing deserialization guard");
[PCH/Modules] De/Serialize MacroInfos separately than MacroDirectives. -Serialize the macro directives history into its own section -Get rid of the macro updates section -When de/serializing an identifier from a module, associate only one macro per submodule that defined+exported it. llvm-svn: 177761
2013-03-23 05:12:57 +08:00
PendingMacroIDs[II].push_back(PendingMacroInfo(M, MacroDirectivesOffset));
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
void ASTReader::ReadDefinedMacros() {
// Note that we are loading defined macros.
Deserializing Macros(this);
Use llvm::reverse to make a bunch of loops use foreach. NFC. In llvm commit r243581, a reverse range adapter was added which allows us to change code such as for (auto I = Fields.rbegin(), E = Fields.rend(); I != E; ++I) { in to for (const FieldDecl *I : llvm::reverse(Fields)) This commit changes a few of the places in clang which are eligible to use this new adapter. llvm-svn: 243663
2015-07-31 01:22:52 +08:00
for (auto &I : llvm::reverse(ModuleMgr)) {
BitstreamCursor &MacroCursor = I->MacroCursor;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
// If there was no preprocessor block, skip this file.
if (!MacroCursor.getBitStreamReader())
continue;
finish converting the normal cases in ASTReader to use the new BitstreamCursor APIs. llvm-svn: 172937
2013-01-20 08:56:42 +08:00
BitstreamCursor Cursor = MacroCursor;
Use llvm::reverse to make a bunch of loops use foreach. NFC. In llvm commit r243581, a reverse range adapter was added which allows us to change code such as for (auto I = Fields.rbegin(), E = Fields.rend(); I != E; ++I) { in to for (const FieldDecl *I : llvm::reverse(Fields)) This commit changes a few of the places in clang which are eligible to use this new adapter. llvm-svn: 243663
2015-07-31 01:22:52 +08:00
Cursor.JumpToBit(I->MacroStartOffset);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
RecordData Record;
while (true) {
switch a bunch of ASTReader to use the new BitstreamCursor::advance* methods, which hide a bunch of private details of the cursor from clients and simplify their code. More to come. llvm-svn: 172922
2013-01-20 05:39:22 +08:00
llvm::BitstreamEntry E = Cursor.advanceSkippingSubblocks();
switch (E.Kind) {
case llvm::BitstreamEntry::SubBlock: // Handled for us already.
case llvm::BitstreamEntry::Error:
Error("malformed block record in AST file");
return;
case llvm::BitstreamEntry::EndBlock:
goto NextCursor;
case llvm::BitstreamEntry::Record:
Record.clear();
update to use the new BitcodeCursor readRecord that takes a StringRef blob parameter, and adopt "advance" in more places. llvm-svn: 172951
2013-01-20 10:38:54 +08:00
switch (Cursor.readRecord(E.ID, Record)) {
switch a bunch of ASTReader to use the new BitstreamCursor::advance* methods, which hide a bunch of private details of the cursor from clients and simplify their code. More to come. llvm-svn: 172922
2013-01-20 05:39:22 +08:00
default: // Default behavior: ignore.
break;
case PP_MACRO_OBJECT_LIKE:
case PP_MACRO_FUNCTION_LIKE:
Use llvm::reverse to make a bunch of loops use foreach. NFC. In llvm commit r243581, a reverse range adapter was added which allows us to change code such as for (auto I = Fields.rbegin(), E = Fields.rend(); I != E; ++I) { in to for (const FieldDecl *I : llvm::reverse(Fields)) This commit changes a few of the places in clang which are eligible to use this new adapter. llvm-svn: 243663
2015-07-31 01:22:52 +08:00
getLocalIdentifier(*I, Record[0]);
switch a bunch of ASTReader to use the new BitstreamCursor::advance* methods, which hide a bunch of private details of the cursor from clients and simplify their code. More to come. llvm-svn: 172922
2013-01-20 05:39:22 +08:00
break;
case PP_TOKEN:
// Ignore tokens.
break;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
break;
}
}
switch a bunch of ASTReader to use the new BitstreamCursor::advance* methods, which hide a bunch of private details of the cursor from clients and simplify their code. More to come. llvm-svn: 172922
2013-01-20 05:39:22 +08:00
NextCursor: ;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
}
namespace {
/// \brief Visitor class used to look up identifirs in an AST file.
class IdentifierLookupVisitor {
StringRef Name;
[modules] Avoid repeatedly hashing the same name when looking it up in multiple module files. llvm-svn: 242180
2015-07-15 02:42:41 +08:00
unsigned NameHash;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
unsigned PriorGeneration;
Track the number of lookups and hits into the on-disk hash tables for identifiers within the AST file reader. llvm-svn: 173403
2013-01-25 08:38:33 +08:00
unsigned &NumIdentifierLookups;
unsigned &NumIdentifierLookupHits;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
IdentifierInfo *Found;
Track the number of lookups and hits into the on-disk hash tables for identifiers within the AST file reader. llvm-svn: 173403
2013-01-25 08:38:33 +08:00
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
public:
Track the number of lookups and hits into the on-disk hash tables for identifiers within the AST file reader. llvm-svn: 173403
2013-01-25 08:38:33 +08:00
IdentifierLookupVisitor(StringRef Name, unsigned PriorGeneration,
unsigned &NumIdentifierLookups,
unsigned &NumIdentifierLookupHits)
[modules] Avoid repeatedly hashing the same name when looking it up in multiple module files. llvm-svn: 242180
2015-07-15 02:42:41 +08:00
: Name(Name), NameHash(ASTIdentifierLookupTrait::ComputeHash(Name)),
PriorGeneration(PriorGeneration),
Track the number of lookups and hits into the on-disk hash tables for identifiers within the AST file reader. llvm-svn: 173403
2013-01-25 08:38:33 +08:00
NumIdentifierLookups(NumIdentifierLookups),
NumIdentifierLookupHits(NumIdentifierLookupHits),
Found()
{
}
[Modules] Wrap the main ModuleManager visitor in a function_ref. Avoids the awkward passing of an opaque void *UserData argument. No functional change intended. llvm-svn: 243213
2015-07-25 20:14:04 +08:00
bool operator()(ModuleFile &M) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
// If we've already searched this module file, skip it now.
Remove some noise "this->"s left behind by r243213. llvm-svn: 243614
2015-07-30 11:37:16 +08:00
if (M.Generation <= PriorGeneration)
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
return true;
Implement the reader of the global module index and wire it into the AST reader. The global module index tracks all of the identifiers known to a set of module files. Lookup of those identifiers looks first in the global module index, which returns the set of module files in which that identifier can be found. The AST reader only needs to look into those module files and any module files not known to the global index (e.g., because they were (re)built after the global index), reducing the number of on-disk hash tables to visit. For an example source I'm looking at, we go from 237844 total identifier lookups into on-disk hash tables down to 126817. Unfortunately, this does not translate into a performance advantage. At best, it's a wash once the global module index has been built, but that's ignore the cost of building the global module index (which is itself fairly large). Profiles show that the global module index code is far less efficient than it should be; optimizing it might give enough of an advantage to justify its continued inclusion. llvm-svn: 173405
2013-01-25 09:03:03 +08:00
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
ASTIdentifierLookupTable *IdTable
= (ASTIdentifierLookupTable *)M.IdentifierLookupTable;
if (!IdTable)
return false;
[Modules] Wrap the main ModuleManager visitor in a function_ref. Avoids the awkward passing of an opaque void *UserData argument. No functional change intended. llvm-svn: 243213
2015-07-25 20:14:04 +08:00
ASTIdentifierLookupTrait Trait(IdTable->getInfoObj().getReader(), M,
Remove some noise "this->"s left behind by r243213. llvm-svn: 243614
2015-07-30 11:37:16 +08:00
Found);
++NumIdentifierLookups;
[modules] Avoid repeatedly hashing the same name when looking it up in multiple module files. llvm-svn: 242180
2015-07-15 02:42:41 +08:00
ASTIdentifierLookupTable::iterator Pos =
Remove some noise "this->"s left behind by r243213. llvm-svn: 243614
2015-07-30 11:37:16 +08:00
IdTable->find_hashed(Name, NameHash, &Trait);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
if (Pos == IdTable->end())
return false;
// Dereferencing the iterator has the effect of building the
// IdentifierInfo node and populating it with the various
// declarations it needs.
Remove some noise "this->"s left behind by r243213. llvm-svn: 243614
2015-07-30 11:37:16 +08:00
++NumIdentifierLookupHits;
Found = *Pos;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
return true;
}
// \brief Retrieve the identifier info found within the module
// files.
IdentifierInfo *getIdentifierInfo() const { return Found; }
};
Revert r240270 ("Fixed/added namespace ending comments using clang-tidy"). llvm-svn: 240353
2015-06-23 07:07:51 +08:00
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
void ASTReader::updateOutOfDateIdentifier(IdentifierInfo &II) {
// Note that we are loading an identifier.
Deserializing AnIdentifier(this);
unsigned PriorGeneration = 0;
if (getContext().getLangOpts().Modules)
PriorGeneration = IdentifierGeneration[&II];
Implement the reader of the global module index and wire it into the AST reader. The global module index tracks all of the identifiers known to a set of module files. Lookup of those identifiers looks first in the global module index, which returns the set of module files in which that identifier can be found. The AST reader only needs to look into those module files and any module files not known to the global index (e.g., because they were (re)built after the global index), reducing the number of on-disk hash tables to visit. For an example source I'm looking at, we go from 237844 total identifier lookups into on-disk hash tables down to 126817. Unfortunately, this does not translate into a performance advantage. At best, it's a wash once the global module index has been built, but that's ignore the cost of building the global module index (which is itself fairly large). Profiles show that the global module index code is far less efficient than it should be; optimizing it might give enough of an advantage to justify its continued inclusion. llvm-svn: 173405
2013-01-25 09:03:03 +08:00
// If there is a global index, look there first to determine which modules
// provably do not have any results for this identifier.
Improve coordination between the module manager and the global module index, optimizing the operation that skips lookup in modules where we know the identifier will not be found. This makes the global module index optimization actually useful, providing an 8.5% speedup over modules without the global module index for -fsyntax-only. llvm-svn: 173529
2013-01-26 07:32:03 +08:00
GlobalModuleIndex::HitSet Hits;
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
GlobalModuleIndex::HitSet *HitsPtr = nullptr;
Implement the reader of the global module index and wire it into the AST reader. The global module index tracks all of the identifiers known to a set of module files. Lookup of those identifiers looks first in the global module index, which returns the set of module files in which that identifier can be found. The AST reader only needs to look into those module files and any module files not known to the global index (e.g., because they were (re)built after the global index), reducing the number of on-disk hash tables to visit. For an example source I'm looking at, we go from 237844 total identifier lookups into on-disk hash tables down to 126817. Unfortunately, this does not translate into a performance advantage. At best, it's a wash once the global module index has been built, but that's ignore the cost of building the global module index (which is itself fairly large). Profiles show that the global module index code is far less efficient than it should be; optimizing it might give enough of an advantage to justify its continued inclusion. llvm-svn: 173405
2013-01-25 09:03:03 +08:00
if (!loadGlobalIndex()) {
Improve coordination between the module manager and the global module index, optimizing the operation that skips lookup in modules where we know the identifier will not be found. This makes the global module index optimization actually useful, providing an 8.5% speedup over modules without the global module index for -fsyntax-only. llvm-svn: 173529
2013-01-26 07:32:03 +08:00
if (GlobalIndex->lookupIdentifier(II.getName(), Hits)) {
HitsPtr = &Hits;
Implement the reader of the global module index and wire it into the AST reader. The global module index tracks all of the identifiers known to a set of module files. Lookup of those identifiers looks first in the global module index, which returns the set of module files in which that identifier can be found. The AST reader only needs to look into those module files and any module files not known to the global index (e.g., because they were (re)built after the global index), reducing the number of on-disk hash tables to visit. For an example source I'm looking at, we go from 237844 total identifier lookups into on-disk hash tables down to 126817. Unfortunately, this does not translate into a performance advantage. At best, it's a wash once the global module index has been built, but that's ignore the cost of building the global module index (which is itself fairly large). Profiles show that the global module index code is far less efficient than it should be; optimizing it might give enough of an advantage to justify its continued inclusion. llvm-svn: 173405
2013-01-25 09:03:03 +08:00
}
}
Improve coordination between the module manager and the global module index, optimizing the operation that skips lookup in modules where we know the identifier will not be found. This makes the global module index optimization actually useful, providing an 8.5% speedup over modules without the global module index for -fsyntax-only. llvm-svn: 173529
2013-01-26 07:32:03 +08:00
IdentifierLookupVisitor Visitor(II.getName(), PriorGeneration,
Track the number of lookups and hits into the on-disk hash tables for identifiers within the AST file reader. llvm-svn: 173403
2013-01-25 08:38:33 +08:00
NumIdentifierLookups,
NumIdentifierLookupHits);
[Modules] Wrap the main ModuleManager visitor in a function_ref. Avoids the awkward passing of an opaque void *UserData argument. No functional change intended. llvm-svn: 243213
2015-07-25 20:14:04 +08:00
ModuleMgr.visit(Visitor, HitsPtr);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
markIdentifierUpToDate(&II);
}
void ASTReader::markIdentifierUpToDate(IdentifierInfo *II) {
if (!II)
return;
II->setOutOfDate(false);
// Update the generation for this identifier.
if (getContext().getLangOpts().Modules)
If a declaration is loaded, and then a module import adds a redeclaration, then ensure that querying the first declaration for its most recent declaration checks for redeclarations from the imported module. This works as follows: * The 'most recent' pointer on a canonical declaration grows a pointer to the external AST source and a generation number (space- and time-optimized for the case where there is no external source). * Each time the 'most recent' pointer is queried, if it has an external source, we check whether it's up to date, and update it if not. * The ancillary data stored on the canonical declaration is allocated lazily to avoid filling it in for declarations that end up being non-canonical. We'll still perform a redundant (ASTContext) allocation if someone asks for the most recent declaration from a decl before setPreviousDecl is called, but such cases are probably all bugs, and are now easy to find. Some finessing is still in order here -- in particular, we use a very general mechanism for handling the DefinitionData pointer on CXXRecordData, and a more targeted approach would be more compact. Also, the MayHaveOutOfDateDef mechanism should now be expunged, since it was addressing only a corner of the full problem space here. That's not covered by this patch. Early performance benchmarks show that this makes no measurable difference to Clang performance without modules enabled (and fixes a major correctness issue with modules enabled). I'll revert if a full performance comparison shows any problems. llvm-svn: 209046
2014-05-17 07:01:30 +08:00
IdentifierGeneration[II] = getGeneration();
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
[PCH/Modules] De/Serialize MacroInfos separately than MacroDirectives. -Serialize the macro directives history into its own section -Get rid of the macro updates section -When de/serializing an identifier from a module, associate only one macro per submodule that defined+exported it. llvm-svn: 177761
2013-03-23 05:12:57 +08:00
void ASTReader::resolvePendingMacro(IdentifierInfo *II,
const PendingMacroInfo &PMInfo) {
[modules] Move list of exported module macros from IdentifierInfo lookup table to separate storage, adjacent to the macro directive history. This is substantially simpler, provides better space usage accounting in bcanalyzer, and gives a more compact representation. No functionality change intended. llvm-svn: 235420
2015-04-22 05:46:32 +08:00
ModuleFile &M = *PMInfo.M;
[PCH/Modules] De/Serialize MacroInfos separately than MacroDirectives. -Serialize the macro directives history into its own section -Get rid of the macro updates section -When de/serializing an identifier from a module, associate only one macro per submodule that defined+exported it. llvm-svn: 177761
2013-03-23 05:12:57 +08:00
[modules] Move list of exported module macros from IdentifierInfo lookup table to separate storage, adjacent to the macro directive history. This is substantially simpler, provides better space usage accounting in bcanalyzer, and gives a more compact representation. No functionality change intended. llvm-svn: 235420
2015-04-22 05:46:32 +08:00
BitstreamCursor &Cursor = M.MacroCursor;
SavedStreamPosition SavedPosition(Cursor);
Cursor.JumpToBit(PMInfo.MacroDirectivesOffset);
[PCH/Modules] De/Serialize MacroInfos separately than MacroDirectives. -Serialize the macro directives history into its own section -Get rid of the macro updates section -When de/serializing an identifier from a module, associate only one macro per submodule that defined+exported it. llvm-svn: 177761
2013-03-23 05:12:57 +08:00
[modules] Store a ModuleMacro* on an imported macro directive rather than duplicating the info within it. llvm-svn: 235644
2015-04-24 04:40:50 +08:00
struct ModuleMacroRecord {
SubmoduleID SubModID;
MacroInfo *MI;
SmallVector<SubmoduleID, 8> Overrides;
};
llvm::SmallVector<ModuleMacroRecord, 8> ModuleMacros;
[PCH/Modules] De/Serialize MacroInfos separately than MacroDirectives. -Serialize the macro directives history into its own section -Get rid of the macro updates section -When de/serializing an identifier from a module, associate only one macro per submodule that defined+exported it. llvm-svn: 177761
2013-03-23 05:12:57 +08:00
[modules] Move list of exported module macros from IdentifierInfo lookup table to separate storage, adjacent to the macro directive history. This is substantially simpler, provides better space usage accounting in bcanalyzer, and gives a more compact representation. No functionality change intended. llvm-svn: 235420
2015-04-22 05:46:32 +08:00
// We expect to see a sequence of PP_MODULE_MACRO records listing exported
// macros, followed by a PP_MACRO_DIRECTIVE_HISTORY record with the complete
// macro histroy.
RecordData Record;
while (true) {
llvm::BitstreamEntry Entry =
Cursor.advance(BitstreamCursor::AF_DontPopBlockAtEnd);
if (Entry.Kind != llvm::BitstreamEntry::Record) {
Error("malformed block record in AST file");
return;
}
[PCH/Modules] De/Serialize MacroInfos separately than MacroDirectives. -Serialize the macro directives history into its own section -Get rid of the macro updates section -When de/serializing an identifier from a module, associate only one macro per submodule that defined+exported it. llvm-svn: 177761
2013-03-23 05:12:57 +08:00
[modules] Move list of exported module macros from IdentifierInfo lookup table to separate storage, adjacent to the macro directive history. This is substantially simpler, provides better space usage accounting in bcanalyzer, and gives a more compact representation. No functionality change intended. llvm-svn: 235420
2015-04-22 05:46:32 +08:00
Record.clear();
Silencing a -Wunused-variable warning; NFC. llvm-svn: 235512
2015-04-22 23:25:05 +08:00
switch ((PreprocessorRecordTypes)Cursor.readRecord(Entry.ID, Record)) {
[modules] Move list of exported module macros from IdentifierInfo lookup table to separate storage, adjacent to the macro directive history. This is substantially simpler, provides better space usage accounting in bcanalyzer, and gives a more compact representation. No functionality change intended. llvm-svn: 235420
2015-04-22 05:46:32 +08:00
case PP_MACRO_DIRECTIVE_HISTORY:
break;
[PCH/Modules] De/Serialize MacroInfos separately than MacroDirectives. -Serialize the macro directives history into its own section -Get rid of the macro updates section -When de/serializing an identifier from a module, associate only one macro per submodule that defined+exported it. llvm-svn: 177761
2013-03-23 05:12:57 +08:00
[modules] Move list of exported module macros from IdentifierInfo lookup table to separate storage, adjacent to the macro directive history. This is substantially simpler, provides better space usage accounting in bcanalyzer, and gives a more compact representation. No functionality change intended. llvm-svn: 235420
2015-04-22 05:46:32 +08:00
case PP_MODULE_MACRO: {
[modules] Store a ModuleMacro* on an imported macro directive rather than duplicating the info within it. llvm-svn: 235644
2015-04-24 04:40:50 +08:00
ModuleMacros.push_back(ModuleMacroRecord());
auto &Info = ModuleMacros.back();
[modules] Build a DAG of module macros for each identifier. This graph will be used to determine the current set of active macros. This is foundation work for getting macro visibility correct across submodules of the current module. No functionality change for now. llvm-svn: 235461
2015-04-22 08:26:11 +08:00
Info.SubModID = getGlobalSubmoduleID(M, Record[0]);
Info.MI = getMacro(getGlobalMacroID(M, Record[1]));
[modules] Store a ModuleMacro* on an imported macro directive rather than duplicating the info within it. llvm-svn: 235644
2015-04-24 04:40:50 +08:00
for (int I = 2, N = Record.size(); I != N; ++I)
Info.Overrides.push_back(getGlobalSubmoduleID(M, Record[I]));
[modules] Move list of exported module macros from IdentifierInfo lookup table to separate storage, adjacent to the macro directive history. This is substantially simpler, provides better space usage accounting in bcanalyzer, and gives a more compact representation. No functionality change intended. llvm-svn: 235420
2015-04-22 05:46:32 +08:00
continue;
}
[PCH/Modules] De/Serialize MacroInfos separately than MacroDirectives. -Serialize the macro directives history into its own section -Get rid of the macro updates section -When de/serializing an identifier from a module, associate only one macro per submodule that defined+exported it. llvm-svn: 177761
2013-03-23 05:12:57 +08:00
[modules] Move list of exported module macros from IdentifierInfo lookup table to separate storage, adjacent to the macro directive history. This is substantially simpler, provides better space usage accounting in bcanalyzer, and gives a more compact representation. No functionality change intended. llvm-svn: 235420
2015-04-22 05:46:32 +08:00
default:
Error("malformed block record in AST file");
return;
}
// We found the macro directive history; that's the last record
// for this macro.
break;
[PCH/Modules] De/Serialize MacroInfos separately than MacroDirectives. -Serialize the macro directives history into its own section -Get rid of the macro updates section -When de/serializing an identifier from a module, associate only one macro per submodule that defined+exported it. llvm-svn: 177761
2013-03-23 05:12:57 +08:00
}
[modules] Move list of exported module macros from IdentifierInfo lookup table to separate storage, adjacent to the macro directive history. This is substantially simpler, provides better space usage accounting in bcanalyzer, and gives a more compact representation. No functionality change intended. llvm-svn: 235420
2015-04-22 05:46:32 +08:00
// Module macros are listed in reverse dependency order.
[modules] Build a DAG of module macros for each identifier. This graph will be used to determine the current set of active macros. This is foundation work for getting macro visibility correct across submodules of the current module. No functionality change for now. llvm-svn: 235461
2015-04-22 08:26:11 +08:00
{
std::reverse(ModuleMacros.begin(), ModuleMacros.end());
llvm::SmallVector<ModuleMacro*, 8> Overrides;
[modules] Store a ModuleMacro* on an imported macro directive rather than duplicating the info within it. llvm-svn: 235644
2015-04-24 04:40:50 +08:00
for (auto &MMR : ModuleMacros) {
[modules] Build a DAG of module macros for each identifier. This graph will be used to determine the current set of active macros. This is foundation work for getting macro visibility correct across submodules of the current module. No functionality change for now. llvm-svn: 235461
2015-04-22 08:26:11 +08:00
Overrides.clear();
[modules] Store a ModuleMacro* on an imported macro directive rather than duplicating the info within it. llvm-svn: 235644
2015-04-24 04:40:50 +08:00
for (unsigned ModID : MMR.Overrides) {
[modules] Determine the set of macros exported by a submodule at the end of that submodule. Previously we'd defer this determination until writing the AST, which doesn't allow us to use this information when building other submodules of the same module. This change also allows us to use a uniform mechanism for writing module macro records, independent of whether they are local or imported. llvm-svn: 235614
2015-04-24 02:18:26 +08:00
Module *Mod = getSubmodule(ModID);
auto *Macro = PP.getModuleMacro(Mod, II);
[modules] Build a DAG of module macros for each identifier. This graph will be used to determine the current set of active macros. This is foundation work for getting macro visibility correct across submodules of the current module. No functionality change for now. llvm-svn: 235461
2015-04-22 08:26:11 +08:00
assert(Macro && "missing definition for overridden macro");
[modules] Cope with partial module macro information, fix memory leak found by buildbot. llvm-svn: 235464
2015-04-22 10:09:43 +08:00
Overrides.push_back(Macro);
[modules] Build a DAG of module macros for each identifier. This graph will be used to determine the current set of active macros. This is foundation work for getting macro visibility correct across submodules of the current module. No functionality change for now. llvm-svn: 235461
2015-04-22 08:26:11 +08:00
}
bool Inserted = false;
[modules] Store a ModuleMacro* on an imported macro directive rather than duplicating the info within it. llvm-svn: 235644
2015-04-24 04:40:50 +08:00
Module *Owner = getSubmodule(MMR.SubModID);
[modules] Stop trying to fake up a linear MacroDirective history. Modules builds fundamentally have a non-linear macro history. In the interest of better source fidelity, represent the macro definition information faithfully: we have a linear macro directive history within each module, and at any point we have a unique "latest" local macro directive and a collection of visible imported directives. This also removes the attendent complexity of attempting to create a correct MacroDirective history (which we got wrong in the general case). No functionality change intended. llvm-svn: 236176
2015-04-30 07:20:19 +08:00
PP.addModuleMacro(Owner, II, MMR.MI, Overrides, Inserted);
[modules] Move list of exported module macros from IdentifierInfo lookup table to separate storage, adjacent to the macro directive history. This is substantially simpler, provides better space usage accounting in bcanalyzer, and gives a more compact representation. No functionality change intended. llvm-svn: 235420
2015-04-22 05:46:32 +08:00
}
[PCH/Modules] De/Serialize MacroInfos separately than MacroDirectives. -Serialize the macro directives history into its own section -Get rid of the macro updates section -When de/serializing an identifier from a module, associate only one macro per submodule that defined+exported it. llvm-svn: 177761
2013-03-23 05:12:57 +08:00
}
[modules] Move list of exported module macros from IdentifierInfo lookup table to separate storage, adjacent to the macro directive history. This is substantially simpler, provides better space usage accounting in bcanalyzer, and gives a more compact representation. No functionality change intended. llvm-svn: 235420
2015-04-22 05:46:32 +08:00
// Don't read the directive history for a module; we don't have anywhere
// to put it.
if (M.Kind == MK_ImplicitModule || M.Kind == MK_ExplicitModule)
return;
[PCH/Modules] De/Serialize MacroInfos separately than MacroDirectives. -Serialize the macro directives history into its own section -Get rid of the macro updates section -When de/serializing an identifier from a module, associate only one macro per submodule that defined+exported it. llvm-svn: 177761
2013-03-23 05:12:57 +08:00
// Deserialize the macro directives history in reverse source-order.
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
MacroDirective *Latest = nullptr, *Earliest = nullptr;
[PCH/Modules] De/Serialize MacroInfos separately than MacroDirectives. -Serialize the macro directives history into its own section -Get rid of the macro updates section -When de/serializing an identifier from a module, associate only one macro per submodule that defined+exported it. llvm-svn: 177761
2013-03-23 05:12:57 +08:00
unsigned Idx = 0, N = Record.size();
while (Idx < N) {
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
MacroDirective *MD = nullptr;
[PCH/Modules] De/Serialize MacroInfos separately than MacroDirectives. -Serialize the macro directives history into its own section -Get rid of the macro updates section -When de/serializing an identifier from a module, associate only one macro per submodule that defined+exported it. llvm-svn: 177761
2013-03-23 05:12:57 +08:00
SourceLocation Loc = ReadSourceLocation(M, Record, Idx);
[Preprocessor/Modules] Separate the macro directives kinds into their own MacroDirective's subclasses. For each macro directive (define, undefine, visibility) have a separate object that gets chained to the macro directive history. This has several benefits: -No need to mutate a MacroDirective when there is a undefine/visibility directive. Stuff like PPMutationListener become unnecessary. -No need to keep extra source locations for the undef/visibility locations for the define directive object (which is the majority of the directives) -Much easier to hide/unhide a section in the macro directive history. -Easier to track the effects of the directives across different submodules. llvm-svn: 178037
2013-03-27 01:17:01 +08:00
MacroDirective::Kind K = (MacroDirective::Kind)Record[Idx++];
switch (K) {
case MacroDirective::MD_Define: {
[modules] Store a ModuleMacro* on an imported macro directive rather than duplicating the info within it. llvm-svn: 235644
2015-04-24 04:40:50 +08:00
MacroInfo *MI = getMacro(getGlobalMacroID(M, Record[Idx++]));
Remove dead code: a MacroDirective can't be imported or ambiguous any more. llvm-svn: 236197
2015-04-30 10:16:23 +08:00
MD = PP.AllocateDefMacroDirective(MI, Loc);
[Preprocessor/Modules] Separate the macro directives kinds into their own MacroDirective's subclasses. For each macro directive (define, undefine, visibility) have a separate object that gets chained to the macro directive history. This has several benefits: -No need to mutate a MacroDirective when there is a undefine/visibility directive. Stuff like PPMutationListener become unnecessary. -No need to keep extra source locations for the undef/visibility locations for the define directive object (which is the majority of the directives) -Much easier to hide/unhide a section in the macro directive history. -Easier to track the effects of the directives across different submodules. llvm-svn: 178037
2013-03-27 01:17:01 +08:00
break;
}
[modules] Substantially improve handling of #undef: * Track override set across module load and save * Track originating module to allow proper re-export of #undef * Make override set properly transitive when it picks up a #undef This fixes nearly all of the remaining macro issues with self-host. llvm-svn: 213922
2014-07-25 12:40:03 +08:00
case MacroDirective::MD_Undefine: {
Remove dead code: a MacroDirective can't be imported or ambiguous any more. llvm-svn: 236197
2015-04-30 10:16:23 +08:00
MD = PP.AllocateUndefMacroDirective(Loc);
[Preprocessor/Modules] Separate the macro directives kinds into their own MacroDirective's subclasses. For each macro directive (define, undefine, visibility) have a separate object that gets chained to the macro directive history. This has several benefits: -No need to mutate a MacroDirective when there is a undefine/visibility directive. Stuff like PPMutationListener become unnecessary. -No need to keep extra source locations for the undef/visibility locations for the define directive object (which is the majority of the directives) -Much easier to hide/unhide a section in the macro directive history. -Easier to track the effects of the directives across different submodules. llvm-svn: 178037
2013-03-27 01:17:01 +08:00
break;
[modules] Substantially improve handling of #undef: * Track override set across module load and save * Track originating module to allow proper re-export of #undef * Make override set properly transitive when it picks up a #undef This fixes nearly all of the remaining macro issues with self-host. llvm-svn: 213922
2014-07-25 12:40:03 +08:00
}
case MacroDirective::MD_Visibility:
[Preprocessor/Modules] Separate the macro directives kinds into their own MacroDirective's subclasses. For each macro directive (define, undefine, visibility) have a separate object that gets chained to the macro directive history. This has several benefits: -No need to mutate a MacroDirective when there is a undefine/visibility directive. Stuff like PPMutationListener become unnecessary. -No need to keep extra source locations for the undef/visibility locations for the define directive object (which is the majority of the directives) -Much easier to hide/unhide a section in the macro directive history. -Easier to track the effects of the directives across different submodules. llvm-svn: 178037
2013-03-27 01:17:01 +08:00
bool isPublic = Record[Idx++];
MD = PP.AllocateVisibilityMacroDirective(Loc, isPublic);
break;
}
[PCH/Modules] De/Serialize MacroInfos separately than MacroDirectives. -Serialize the macro directives history into its own section -Get rid of the macro updates section -When de/serializing an identifier from a module, associate only one macro per submodule that defined+exported it. llvm-svn: 177761
2013-03-23 05:12:57 +08:00
if (!Latest)
Latest = MD;
if (Earliest)
Earliest->setPrevious(MD);
Earliest = MD;
}
[modules] Don't bother registering loaded macros if there are none. We don't yet have a reduced testcase for this. llvm-svn: 236454
2015-05-05 03:58:00 +08:00
if (Latest)
PP.setLoadedMacroDirective(II, Latest);
[PCH/Modules] De/Serialize MacroInfos separately than MacroDirectives. -Serialize the macro directives history into its own section -Get rid of the macro updates section -When de/serializing an identifier from a module, associate only one macro per submodule that defined+exported it. llvm-svn: 177761
2013-03-23 05:12:57 +08:00
}
Refactor ASTReader::readInputFileInfo to return a struct containing the related information. No functionality change. llvm-svn: 203881
2014-03-14 10:26:27 +08:00
ASTReader::InputFileInfo
ASTReader::readInputFileInfo(ModuleFile &F, unsigned ID) {
Add a bunch of missing changes from r203208 Somehow lost these in a git operation. llvm-svn: 203210
2014-03-07 15:27:49 +08:00
// Go find this input file.
BitstreamCursor &Cursor = F.InputFilesCursor;
SavedStreamPosition SavedPosition(Cursor);
Cursor.JumpToBit(F.InputFileOffsets[ID-1]);
unsigned Code = Cursor.ReadCode();
RecordData Record;
StringRef Blob;
unsigned Result = Cursor.readRecord(Code, Record, &Blob);
assert(static_cast<InputFileRecordTypes>(Result) == INPUT_FILE &&
"invalid record type for input file");
(void)Result;
assert(Record[0] == ID && "Bogus stored ID or offset");
[modules] Refactor handling of -fmodules-embed-*. Track this properly rather than reusing the "overridden buffer" mechanism. This will allow us to make embedded files and overridden files behave differently in future. llvm-svn: 254121
2015-11-26 10:04:16 +08:00
InputFileInfo R;
R.StoredSize = static_cast<off_t>(Record[1]);
R.StoredTime = static_cast<time_t>(Record[2]);
R.Overridden = static_cast<bool>(Record[3]);
R.Transient = static_cast<bool>(Record[4]);
R.Filename = Blob;
ResolveImportedPath(F, R.Filename);
Fix VS2012 build after r203881 llvm-svn: 203951
2014-03-15 01:45:06 +08:00
return R;
Add a bunch of missing changes from r203208 Somehow lost these in a git operation. llvm-svn: 203210
2014-03-07 15:27:49 +08:00
}
[PCH] Enhance InputFile to also include whether the file is out-of-date. Previously we would return null for an out-of-date file. This inhibited ASTReader::ReadSLocEntry from creating a FileID to recover gracefully in such a case. llvm-svn: 176332
2013-03-01 11:26:04 +08:00
InputFile ASTReader::getInputFile(ModuleFile &F, unsigned ID, bool Complain) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
// If this ID is bogus, just return an empty input file.
if (ID == 0 || ID > F.InputFilesLoaded.size())
return InputFile();
// If we've already loaded this input file, return it.
[PCH] Enhance InputFile to also include whether the file is out-of-date. Previously we would return null for an out-of-date file. This inhibited ASTReader::ReadSLocEntry from creating a FileID to recover gracefully in such a case. llvm-svn: 176332
2013-03-01 11:26:04 +08:00
if (F.InputFilesLoaded[ID-1].getFile())
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
return F.InputFilesLoaded[ID-1];
[Serialization] In ASTReader::getInputFile record it when we didn't find the file to avoid looking it up again. Hopefully addresses rdar://14514222. llvm-svn: 198781
2014-01-09 03:13:34 +08:00
if (F.InputFilesLoaded[ID-1].isNotFound())
return InputFile();
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
// Go find this input file.
finish converting the normal cases in ASTReader to use the new BitstreamCursor APIs. llvm-svn: 172937
2013-01-20 08:56:42 +08:00
BitstreamCursor &Cursor = F.InputFilesCursor;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
SavedStreamPosition SavedPosition(Cursor);
Cursor.JumpToBit(F.InputFileOffsets[ID-1]);
Refactor ASTReader::readInputFileInfo to return a struct containing the related information. No functionality change. llvm-svn: 203881
2014-03-14 10:26:27 +08:00
InputFileInfo FI = readInputFileInfo(F, ID);
off_t StoredSize = FI.StoredSize;
time_t StoredTime = FI.StoredTime;
bool Overridden = FI.Overridden;
[modules] Refactor handling of -fmodules-embed-*. Track this properly rather than reusing the "overridden buffer" mechanism. This will allow us to make embedded files and overridden files behave differently in future. llvm-svn: 254121
2015-11-26 10:04:16 +08:00
bool Transient = FI.Transient;
Refactor ASTReader::readInputFileInfo to return a struct containing the related information. No functionality change. llvm-svn: 203881
2014-03-14 10:26:27 +08:00
StringRef Filename = FI.Filename;
Add a bunch of missing changes from r203208 Somehow lost these in a git operation. llvm-svn: 203210
2014-03-07 15:27:49 +08:00
[modules] Refactor handling of -fmodules-embed-*. Track this properly rather than reusing the "overridden buffer" mechanism. This will allow us to make embedded files and overridden files behave differently in future. llvm-svn: 254121
2015-11-26 10:04:16 +08:00
const FileEntry *File = FileMgr.getFile(Filename, /*OpenFile=*/false);
Add a bunch of missing changes from r203208 Somehow lost these in a git operation. llvm-svn: 203210
2014-03-07 15:27:49 +08:00
// If we didn't find the file, resolve it relative to the
// original directory from which this AST file was created.
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
if (File == nullptr && !F.OriginalDir.empty() && !CurrentDir.empty() &&
Add a bunch of missing changes from r203208 Somehow lost these in a git operation. llvm-svn: 203210
2014-03-07 15:27:49 +08:00
F.OriginalDir != CurrentDir) {
std::string Resolved = resolveFileRelativeToOriginalDir(Filename,
F.OriginalDir,
CurrentDir);
if (!Resolved.empty())
File = FileMgr.getFile(Resolved);
}
[PCH] Enhance InputFile to also include whether the file is out-of-date. Previously we would return null for an out-of-date file. This inhibited ASTReader::ReadSLocEntry from creating a FileID to recover gracefully in such a case. llvm-svn: 176332
2013-03-01 11:26:04 +08:00
Add a bunch of missing changes from r203208 Somehow lost these in a git operation. llvm-svn: 203210
2014-03-07 15:27:49 +08:00
// For an overridden file, create a virtual file with the stored
// size/timestamp.
[modules] Refactor handling of -fmodules-embed-*. Track this properly rather than reusing the "overridden buffer" mechanism. This will allow us to make embedded files and overridden files behave differently in future. llvm-svn: 254121
2015-11-26 10:04:16 +08:00
if ((Overridden || Transient) && File == nullptr)
Add a bunch of missing changes from r203208 Somehow lost these in a git operation. llvm-svn: 203210
2014-03-07 15:27:49 +08:00
File = FileMgr.getVirtualFile(Filename, StoredSize, StoredTime);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
if (File == nullptr) {
Add a bunch of missing changes from r203208 Somehow lost these in a git operation. llvm-svn: 203210
2014-03-07 15:27:49 +08:00
if (Complain) {
std::string ErrorStr = "could not find file '";
ErrorStr += Filename;
[modules] Improve error message on failed module load due to a missing file to say which module file referenced the missing file. llvm-svn: 250140
2015-10-13 09:26:26 +08:00
ErrorStr += "' referenced by AST file '";
ErrorStr += F.FileName;
ErrorStr += "'";
Add a bunch of missing changes from r203208 Somehow lost these in a git operation. llvm-svn: 203210
2014-03-07 15:27:49 +08:00
Error(ErrorStr.c_str());
}
// Record that we didn't find the file.
F.InputFilesLoaded[ID-1] = InputFile::getNotFound();
return InputFile();
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
Add a bunch of missing changes from r203208 Somehow lost these in a git operation. llvm-svn: 203210
2014-03-07 15:27:49 +08:00
// Check if there was a request to override the contents of the file
// that was part of the precompiled header. Overridding such a file
// can lead to problems when lexing using the source locations from the
// PCH.
SourceManager &SM = getSourceManager();
[modules] Don't reject multiple modules providing contents for the same embedded file. llvm-svn: 254365
2015-12-01 11:32:49 +08:00
// FIXME: Reject if the overrides are different.
if ((!Overridden && !Transient) && SM.isFileOverridden(File)) {
Add a bunch of missing changes from r203208 Somehow lost these in a git operation. llvm-svn: 203210
2014-03-07 15:27:49 +08:00
if (Complain)
Error(diag::err_fe_pch_file_overridden, Filename);
// After emitting the diagnostic, recover by disabling the override so
// that the original file will be used.
[modules] Refactor handling of -fmodules-embed-*. Track this properly rather than reusing the "overridden buffer" mechanism. This will allow us to make embedded files and overridden files behave differently in future. llvm-svn: 254121
2015-11-26 10:04:16 +08:00
//
// FIXME: This recovery is just as broken as the original state; there may
// be another precompiled module that's using the overridden contents, or
// we might be half way through parsing it. Instead, we should treat the
// overridden contents as belonging to a separate FileEntry.
Add a bunch of missing changes from r203208 Somehow lost these in a git operation. llvm-svn: 203210
2014-03-07 15:27:49 +08:00
SM.disableFileContentsOverride(File);
// The FileEntry is a virtual file entry with the size of the contents
// that would override the original contents. Set it to the original's
// size/time.
FileMgr.modifyFileEntry(const_cast<FileEntry*>(File),
StoredSize, StoredTime);
}
bool IsOutOfDate = false;
// For an overridden file, there is nothing to validate.
[modules] Allow -I, -D, -W flags to change between building a module and explicitly using the resulting .pcm file. Unlike for an implicit module build, we don't need nor want to require these flags to match between the module and its users. llvm-svn: 220780
2014-10-29 00:24:08 +08:00
if (!Overridden && //
(StoredSize != File->getSize() ||
#if defined(LLVM_ON_WIN32)
false
#else
Add a bunch of missing changes from r203208 Somehow lost these in a git operation. llvm-svn: 203210
2014-03-07 15:27:49 +08:00
// In our regression testing, the Windows file system seems to
// have inconsistent modification times that sometimes
// erroneously trigger this error-handling path.
[modules] Allow -I, -D, -W flags to change between building a module and explicitly using the resulting .pcm file. Unlike for an implicit module build, we don't need nor want to require these flags to match between the module and its users. llvm-svn: 220780
2014-10-29 00:24:08 +08:00
//
[modules] When explicitly building a module file, don't include timestamps in the produced pcm file for stable file creation across distributed build systems. llvm-svn: 245199
2015-08-17 15:13:32 +08:00
// FIXME: This probably also breaks HeaderFileInfo lookups on Windows.
(StoredTime && StoredTime != File->getModificationTime() &&
!DisableValidation)
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
#endif
Add a bunch of missing changes from r203208 Somehow lost these in a git operation. llvm-svn: 203210
2014-03-07 15:27:49 +08:00
)) {
if (Complain) {
// Build a list of the PCH imports that got us here (in reverse).
SmallVector<ModuleFile *, 4> ImportStack(1, &F);
while (ImportStack.back()->ImportedBy.size() > 0)
ImportStack.push_back(ImportStack.back()->ImportedBy[0]);
// The top-level PCH is stale.
StringRef TopLevelPCHName(ImportStack.back()->FileName);
Error(diag::err_fe_pch_file_modified, Filename, TopLevelPCHName);
// Print the import stack.
if (ImportStack.size() > 1 && !Diags.isDiagnosticInFlight()) {
Diag(diag::note_pch_required_by)
<< Filename << ImportStack[0]->FileName;
for (unsigned I = 1; I < ImportStack.size(); ++I)
Improve the error message when a PCH dependency is modified Show the top-level pch file as the culprit, rather than the immediate dependency when a pch file imports a pcm from a module. To clarify the relationship, the pch import stack is printed as notes. The old behaviour was misleading when a pch imported a pcm (from a module), since removing the pcm would not fix the problem, whereas rebuilding the pch would. llvm-svn: 199446
2014-01-17 08:19:09 +08:00
Diag(diag::note_pch_required_by)
Add a bunch of missing changes from r203208 Somehow lost these in a git operation. llvm-svn: 203210
2014-03-07 15:27:49 +08:00
<< ImportStack[I-1]->FileName << ImportStack[I]->FileName;
<rdar://problem/13363214> Eliminate race condition between module rebuild and the global module index. The global module index was querying the file manager for each of the module files it knows about at load time, to prune out any out-of-date information. The file manager would then cache the results of the stat() falls used to find that module file. Later, the same translation unit could end up trying to import one of the module files that had previously been ignored by the module cache, but after some other Clang instance rebuilt the module file to bring it up-to-date. The stale stat() results in the file manager would trigger a second rebuild of the already-up-to-date module, causing failures down the line. The global module index now lazily resolves its module file references to actual AST reader module files only after the module file has been loaded, eliminating the stat-caching race. Moreover, the AST reader can communicate to its caller that a module file is missing (rather than simply being out-of-date), allowing us to simplify the module-loading logic and allowing the compiler to recover if a dependent module file ends up getting deleted. llvm-svn: 177367
2013-03-19 08:28:20 +08:00
}
Add a bunch of missing changes from r203208 Somehow lost these in a git operation. llvm-svn: 203210
2014-03-07 15:27:49 +08:00
if (!Diags.isDiagnosticInFlight())
Diag(diag::note_pch_rebuild_required) << TopLevelPCHName;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
Add a bunch of missing changes from r203208 Somehow lost these in a git operation. llvm-svn: 203210
2014-03-07 15:27:49 +08:00
IsOutOfDate = true;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
[modules] Refactor handling of -fmodules-embed-*. Track this properly rather than reusing the "overridden buffer" mechanism. This will allow us to make embedded files and overridden files behave differently in future. llvm-svn: 254121
2015-11-26 10:04:16 +08:00
// FIXME: If the file is overridden and we've already opened it,
// issue an error (or split it into a separate FileEntry).
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
[modules] Refactor handling of -fmodules-embed-*. Track this properly rather than reusing the "overridden buffer" mechanism. This will allow us to make embedded files and overridden files behave differently in future. llvm-svn: 254121
2015-11-26 10:04:16 +08:00
InputFile IF = InputFile(File, Overridden || Transient, IsOutOfDate);
Add a bunch of missing changes from r203208 Somehow lost these in a git operation. llvm-svn: 203210
2014-03-07 15:27:49 +08:00
// Note that we've loaded this input file.
F.InputFilesLoaded[ID-1] = IF;
return IF;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
[modules] Instead of storing absolute paths in a .pcm file, store the path to the root of the module and use paths relative to that directory wherever possible. This is a step towards allowing explicit modules to be relocated without being rebuilt, which is important for some kinds of distributed builds, for good paths in diagnostics, and for appropriate .d output. This is a recommit of r223443, reverted in r223465; when joining together imported file paths, we now use the system's separator rather than always using '/'. This avoids path mismatches between the original module build and the module user on Windows (at least, in some cases). A more comprehensive fix will follow. llvm-svn: 223539
2014-12-06 06:42:13 +08:00
/// \brief If we are loading a relocatable PCH or module file, and the filename
/// is not an absolute path, add the system or module root to the beginning of
/// the file name.
void ASTReader::ResolveImportedPath(ModuleFile &M, std::string &Filename) {
// Resolve relative to the base directory, if we have one.
if (!M.BaseDirectory.empty())
return ResolveImportedPath(Filename, M.BaseDirectory);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
[modules] Instead of storing absolute paths in a .pcm file, store the path to the root of the module and use paths relative to that directory wherever possible. This is a step towards allowing explicit modules to be relocated without being rebuilt, which is important for some kinds of distributed builds, for good paths in diagnostics, and for appropriate .d output. This is a recommit of r223443, reverted in r223465; when joining together imported file paths, we now use the system's separator rather than always using '/'. This avoids path mismatches between the original module build and the module user on Windows (at least, in some cases). A more comprehensive fix will follow. llvm-svn: 223539
2014-12-06 06:42:13 +08:00
void ASTReader::ResolveImportedPath(std::string &Filename, StringRef Prefix) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
if (Filename.empty() || llvm::sys::path::is_absolute(Filename))
return;
[modules] Instead of storing absolute paths in a .pcm file, store the path to the root of the module and use paths relative to that directory wherever possible. This is a step towards allowing explicit modules to be relocated without being rebuilt, which is important for some kinds of distributed builds, for good paths in diagnostics, and for appropriate .d output. This is a recommit of r223443, reverted in r223465; when joining together imported file paths, we now use the system's separator rather than always using '/'. This avoids path mismatches between the original module build and the module user on Windows (at least, in some cases). A more comprehensive fix will follow. llvm-svn: 223539
2014-12-06 06:42:13 +08:00
SmallString<128> Buffer;
llvm::sys::path::append(Buffer, Prefix, Filename);
Filename.assign(Buffer.begin(), Buffer.end());
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
[modules] PR22534: Load files specified by -fmodule-file= eagerly. In particular, this avoids the need to re-parse module map files when using such a module. llvm-svn: 244416
2015-08-09 16:48:41 +08:00
static bool isDiagnosedResult(ASTReader::ASTReadResult ARR, unsigned Caps) {
switch (ARR) {
case ASTReader::Failure: return true;
case ASTReader::Missing: return !(Caps & ASTReader::ARR_Missing);
case ASTReader::OutOfDate: return !(Caps & ASTReader::ARR_OutOfDate);
case ASTReader::VersionMismatch: return !(Caps & ASTReader::ARR_VersionMismatch);
case ASTReader::ConfigurationMismatch:
return !(Caps & ASTReader::ARR_ConfigurationMismatch);
case ASTReader::HadErrors: return true;
case ASTReader::Success: return false;
}
llvm_unreachable("unknown ASTReadResult");
}
[modules] Write the options records to a separate subblock rather than writing them directly to the control block. These are fairly large, and in a build with lots of modules / chained PCH, we don't need to read most of them. No functionality change intended. llvm-svn: 247055
2015-09-09 03:40:14 +08:00
ASTReader::ASTReadResult ASTReader::ReadOptionsBlock(
BitstreamCursor &Stream, unsigned ClientLoadCapabilities,
bool AllowCompatibleConfigurationMismatch, ASTReaderListener &Listener,
std::string &SuggestedPredefines) {
if (Stream.EnterSubBlock(OPTIONS_BLOCK_ID))
return Failure;
// Read all of the records in the options block.
RecordData Record;
ASTReadResult Result = Success;
while (1) {
llvm::BitstreamEntry Entry = Stream.advance();
switch (Entry.Kind) {
case llvm::BitstreamEntry::Error:
case llvm::BitstreamEntry::SubBlock:
return Failure;
case llvm::BitstreamEntry::EndBlock:
return Result;
case llvm::BitstreamEntry::Record:
// The interesting case.
break;
}
// Read and process a record.
Record.clear();
switch ((OptionsRecordTypes)Stream.readRecord(Entry.ID, Record)) {
case LANGUAGE_OPTIONS: {
bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
if (ParseLanguageOptions(Record, Complain, Listener,
AllowCompatibleConfigurationMismatch))
Result = ConfigurationMismatch;
break;
}
case TARGET_OPTIONS: {
bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
if (ParseTargetOptions(Record, Complain, Listener,
AllowCompatibleConfigurationMismatch))
Result = ConfigurationMismatch;
break;
}
case DIAGNOSTIC_OPTIONS: {
bool Complain = (ClientLoadCapabilities & ARR_OutOfDate) == 0;
if (!AllowCompatibleConfigurationMismatch &&
ParseDiagnosticOptions(Record, Complain, Listener))
return OutOfDate;
break;
}
case FILE_SYSTEM_OPTIONS: {
bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
if (!AllowCompatibleConfigurationMismatch &&
ParseFileSystemOptions(Record, Complain, Listener))
Result = ConfigurationMismatch;
break;
}
case HEADER_SEARCH_OPTIONS: {
bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
if (!AllowCompatibleConfigurationMismatch &&
ParseHeaderSearchOptions(Record, Complain, Listener))
Result = ConfigurationMismatch;
break;
}
case PREPROCESSOR_OPTIONS:
bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
if (!AllowCompatibleConfigurationMismatch &&
ParsePreprocessorOptions(Record, Complain, Listener,
SuggestedPredefines))
Result = ConfigurationMismatch;
break;
}
}
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
ASTReader::ASTReadResult
ASTReader::ReadControlBlock(ModuleFile &F,
Remove useless 'llvm::' qualifier from names like StringRef and others that are brought into 'clang' namespace by clang/Basic/LLVM.h llvm-svn: 172323
2013-01-13 03:30:44 +08:00
SmallVectorImpl<ImportedModule> &Loaded,
Allow multiple modules with the same name to coexist in the module cache To differentiate between two modules with the same name, we will consider the path the module map file that they are defined by* part of the ‘key’ for looking up the precompiled module (pcm file). Specifically, this patch renames the precompiled module (pcm) files from cache-path/<module hash>/Foo.pcm to cache-path/<module hash>/Foo-<hash of module map path>.pcm In addition, I’ve taught the ASTReader to re-resolve the names of imported modules during module loading so that if the header search context changes between when a module was originally built and when it is loaded we can rebuild it if necessary. For example, if module A imports module B first time: clang -I /path/to/A -I /path/to/B ... second time: clang -I /path/to/A -I /different/path/to/B ... will now rebuild A as expected. * in the case of inferred modules, we use the module map file that allowed the inference, not the __inferred_module.map file, since the inferred file path is the same for every inferred module. llvm-svn: 206201
2014-04-15 02:00:01 +08:00
const ModuleFile *ImportedBy,
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
unsigned ClientLoadCapabilities) {
finish converting the normal cases in ASTReader to use the new BitstreamCursor APIs. llvm-svn: 172937
2013-01-20 08:56:42 +08:00
BitstreamCursor &Stream = F.Stream;
[modules] If we're given a module file, via -fmodule-file=, for a module, but we can't load that file due to a configuration mismatch, and implicit module building is disabled, and the user turns off the error-by-default warning for that situation, then fall back to textual inclusion for the module rather than giving an error if any of its headers are included. llvm-svn: 252114
2015-11-05 08:54:55 +08:00
ASTReadResult Result = Success;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
if (Stream.EnterSubBlock(CONTROL_BLOCK_ID)) {
Error("malformed block record in AST file");
return Failure;
}
// Read all of the records and blocks in the control block.
RecordData Record;
[modules] Simplify reading of INPUT_FILE_OFFSETS record and make it robust against changes to record order. llvm-svn: 220524
2014-10-24 06:18:29 +08:00
unsigned NumInputs = 0;
unsigned NumUserInputs = 0;
switch a bunch of ASTReader to use the new BitstreamCursor::advance* methods, which hide a bunch of private details of the cursor from clients and simplify their code. More to come. llvm-svn: 172922
2013-01-20 05:39:22 +08:00
while (1) {
llvm::BitstreamEntry Entry = Stream.advance();
switch (Entry.Kind) {
case llvm::BitstreamEntry::Error:
Error("malformed block record in AST file");
return Failure;
Add an option to allow Clang verify source files for a module only once during the build When Clang loads the module, it verifies the user source files that the module was built from. If any file was changed, the module is rebuilt. There are two problems with this: 1. correctness: we don't verify system files (there are too many of them, and stat'ing all of them would take a lot of time); 2. performance: the same module file is verified again and again during a single build. This change allows the build system to optimize source file verification. The idea is based on the fact that while the project is being built, the source files don't change. This allows us to verify the module only once during a single build session. The build system passes a flag, -fbuild-session-timestamp=, to inform Clang of the time when the build started. The build system also requests to enable this feature by passing -fmodules-validate-once-per-build-session. If these flags are not passed, the behavior is not changed. When Clang verifies the module the first time, it writes out a timestamp file. Then, when Clang loads the module the second time, it finds a timestamp file, so it can compare the verification timestamp of the module with the time when the build started. If the verification timestamp is too old, the module is verified again, and the timestamp file is updated. llvm-svn: 201224
2014-02-12 18:33:14 +08:00
case llvm::BitstreamEntry::EndBlock: {
// Validate input files.
const HeaderSearchOptions &HSOpts =
PP.getHeaderSearchInfo().getHeaderSearchOpts();
Add dependencies from imported modules with -MD Add module dependencies to the dependency files created by -MD/-MMD/etc. by attaching an ASTReaderListener that will call into the dependency file generator when a module input file is seen in the serialized AST. llvm-svn: 203208
2014-03-07 14:40:32 +08:00
[modules] Simplify reading of INPUT_FILE_OFFSETS record and make it robust against changes to record order. llvm-svn: 220524
2014-10-24 06:18:29 +08:00
// All user input files reside at the index range [0, NumUserInputs), and
[modules] PR22534: Load files specified by -fmodule-file= eagerly. In particular, this avoids the need to re-parse module map files when using such a module. llvm-svn: 244416
2015-08-09 16:48:41 +08:00
// system input files reside at [NumUserInputs, NumInputs). For explicitly
// loaded module files, ignore missing inputs.
if (!DisableValidation && F.Kind != MK_ExplicitModule) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
bool Complain = (ClientLoadCapabilities & ARR_OutOfDate) == 0;
Add dependencies from imported modules with -MD Add module dependencies to the dependency files created by -MD/-MMD/etc. by attaching an ASTReaderListener that will call into the dependency file generator when a module input file is seen in the serialized AST. llvm-svn: 203208
2014-03-07 14:40:32 +08:00
Add an option to allow Clang verify source files for a module only once during the build When Clang loads the module, it verifies the user source files that the module was built from. If any file was changed, the module is rebuilt. There are two problems with this: 1. correctness: we don't verify system files (there are too many of them, and stat'ing all of them would take a lot of time); 2. performance: the same module file is verified again and again during a single build. This change allows the build system to optimize source file verification. The idea is based on the fact that while the project is being built, the source files don't change. This allows us to verify the module only once during a single build session. The build system passes a flag, -fbuild-session-timestamp=, to inform Clang of the time when the build started. The build system also requests to enable this feature by passing -fmodules-validate-once-per-build-session. If these flags are not passed, the behavior is not changed. When Clang verifies the module the first time, it writes out a timestamp file. Then, when Clang loads the module the second time, it finds a timestamp file, so it can compare the verification timestamp of the module with the time when the build started. If the verification timestamp is too old, the module is verified again, and the timestamp file is updated. llvm-svn: 201224
2014-02-12 18:33:14 +08:00
// If we are reading a module, we will create a verification timestamp,
// so we verify all input files. Otherwise, verify only user input
// files.
Add dependencies from imported modules with -MD Add module dependencies to the dependency files created by -MD/-MMD/etc. by attaching an ASTReaderListener that will call into the dependency file generator when a module input file is seen in the serialized AST. llvm-svn: 203208
2014-03-07 14:40:32 +08:00
unsigned N = NumUserInputs;
if (ValidateSystemInputs ||
[modules] Initial support for explicitly loading .pcm files. Implicit module builds are not well-suited to a lot of build systems. In particular, they fare badly in distributed build systems, and they lead to build artifacts that are not tracked as part of the usual dependency management process. This change allows explicitly-built module files (which are already supported through the -emit-module flag) to be explicitly loaded into a build, allowing build systems to opt to manage module builds and dependencies themselves. This is only the first step in supporting such configurations, and it should be considered experimental and subject to change or removal for now. llvm-svn: 220359
2014-10-22 10:05:46 +08:00
(HSOpts.ModulesValidateOncePerBuildSession &&
Validate user headers even if -fmodules-validate-once-per-build-session is enabled. Unlike system headers, we want to be more careful about modifications to user headers, because it's still easy to edit a header while you're building. llvm-svn: 221634
2014-11-11 06:13:10 +08:00
F.InputFilesValidationTimestamp <= HSOpts.BuildSessionTimestamp &&
[modules] Initial support for explicitly loading .pcm files. Implicit module builds are not well-suited to a lot of build systems. In particular, they fare badly in distributed build systems, and they lead to build artifacts that are not tracked as part of the usual dependency management process. This change allows explicitly-built module files (which are already supported through the -emit-module flag) to be explicitly loaded into a build, allowing build systems to opt to manage module builds and dependencies themselves. This is only the first step in supporting such configurations, and it should be considered experimental and subject to change or removal for now. llvm-svn: 220359
2014-10-22 10:05:46 +08:00
F.Kind == MK_ImplicitModule))
Add dependencies from imported modules with -MD Add module dependencies to the dependency files created by -MD/-MMD/etc. by attaching an ASTReaderListener that will call into the dependency file generator when a module input file is seen in the serialized AST. llvm-svn: 203208
2014-03-07 14:40:32 +08:00
N = NumInputs;
Stat system dependencies when using -verify-pch We don't stat the system headers to check for stalenes during regular PCH loading for performance reasons. When explicitly saying -verify-pch, we want to check all the dependencies - user or system. llvm-svn: 200979
2014-02-08 01:31:11 +08:00
for (unsigned I = 0; I < N; ++I) {
[PCH] Enhance InputFile to also include whether the file is out-of-date. Previously we would return null for an out-of-date file. This inhibited ASTReader::ReadSLocEntry from creating a FileID to recover gracefully in such a case. llvm-svn: 176332
2013-03-01 11:26:04 +08:00
InputFile IF = getInputFile(F, I+1, Complain);
if (!IF.getFile() || IF.isOutOfDate())
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
return OutOfDate;
[PCH] Enhance InputFile to also include whether the file is out-of-date. Previously we would return null for an out-of-date file. This inhibited ASTReader::ReadSLocEntry from creating a FileID to recover gracefully in such a case. llvm-svn: 176332
2013-03-01 11:26:04 +08:00
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
Add dependencies from imported modules with -MD Add module dependencies to the dependency files created by -MD/-MMD/etc. by attaching an ASTReaderListener that will call into the dependency file generator when a module input file is seen in the serialized AST. llvm-svn: 203208
2014-03-07 14:40:32 +08:00
[Modules] Emit the module file paths as dependencies of the PCH when we are building one. This is because the PCH is tied to the module files, if one of the module files changes or gets removed the build system should re-build the PCH file. rdar://16321245 llvm-svn: 203885
2014-03-14 11:07:38 +08:00
if (Listener)
[modules] Change the way we deal with .d output for explicitly-specified module files: include the .pcm file itself in the .d output, rather than including its own input files. Other forms of module file continue to be transparent for .d output. Arguably, the input files for the .pcm file are still inputs to the compilation, but that's unnecessary for make-like build systems (where the mtime of the .pcm file is sufficient) and harmful for smarter build systems that know about module files and want to track only the local dependencies. llvm-svn: 244923
2015-08-14 01:57:10 +08:00
Listener->visitModuleFile(F.FileName, F.Kind);
[Modules] Emit the module file paths as dependencies of the PCH when we are building one. This is because the PCH is tied to the module files, if one of the module files changes or gets removed the build system should re-build the PCH file. rdar://16321245 llvm-svn: 203885
2014-03-14 11:07:38 +08:00
Add dependencies from imported modules with -MD Add module dependencies to the dependency files created by -MD/-MMD/etc. by attaching an ASTReaderListener that will call into the dependency file generator when a module input file is seen in the serialized AST. llvm-svn: 203208
2014-03-07 14:40:32 +08:00
if (Listener && Listener->needsInputFileVisitation()) {
unsigned N = Listener->needsSystemInputFileVisitation() ? NumInputs
: NumUserInputs;
[Modules] Make sure that the synthesized file "__inferred_module.map" doesn't show up as dependency of a module file. Follow-up for rdar://15459210 llvm-svn: 203882
2014-03-14 10:26:31 +08:00
for (unsigned I = 0; I < N; ++I) {
bool IsSystem = I >= NumUserInputs;
InputFileInfo FI = readInputFileInfo(F, I+1);
[modules] Change the way we deal with .d output for explicitly-specified module files: include the .pcm file itself in the .d output, rather than including its own input files. Other forms of module file continue to be transparent for .d output. Arguably, the input files for the .pcm file are still inputs to the compilation, but that's unnecessary for make-like build systems (where the mtime of the .pcm file is sufficient) and harmful for smarter build systems that know about module files and want to track only the local dependencies. llvm-svn: 244923
2015-08-14 01:57:10 +08:00
Listener->visitInputFile(FI.Filename, IsSystem, FI.Overridden,
F.Kind == MK_ExplicitModule);
[Modules] Make sure that the synthesized file "__inferred_module.map" doesn't show up as dependency of a module file. Follow-up for rdar://15459210 llvm-svn: 203882
2014-03-14 10:26:31 +08:00
}
Add dependencies from imported modules with -MD Add module dependencies to the dependency files created by -MD/-MMD/etc. by attaching an ASTReaderListener that will call into the dependency file generator when a module input file is seen in the serialized AST. llvm-svn: 203208
2014-03-07 14:40:32 +08:00
}
[modules] If we're given a module file, via -fmodule-file=, for a module, but we can't load that file due to a configuration mismatch, and implicit module building is disabled, and the user turns off the error-by-default warning for that situation, then fall back to textual inclusion for the module rather than giving an error if any of its headers are included. llvm-svn: 252114
2015-11-05 08:54:55 +08:00
return Result;
Add an option to allow Clang verify source files for a module only once during the build When Clang loads the module, it verifies the user source files that the module was built from. If any file was changed, the module is rebuilt. There are two problems with this: 1. correctness: we don't verify system files (there are too many of them, and stat'ing all of them would take a lot of time); 2. performance: the same module file is verified again and again during a single build. This change allows the build system to optimize source file verification. The idea is based on the fact that while the project is being built, the source files don't change. This allows us to verify the module only once during a single build session. The build system passes a flag, -fbuild-session-timestamp=, to inform Clang of the time when the build started. The build system also requests to enable this feature by passing -fmodules-validate-once-per-build-session. If these flags are not passed, the behavior is not changed. When Clang verifies the module the first time, it writes out a timestamp file. Then, when Clang loads the module the second time, it finds a timestamp file, so it can compare the verification timestamp of the module with the time when the build started. If the verification timestamp is too old, the module is verified again, and the timestamp file is updated. llvm-svn: 201224
2014-02-12 18:33:14 +08:00
}
switch a bunch of ASTReader to use the new BitstreamCursor::advance* methods, which hide a bunch of private details of the cursor from clients and simplify their code. More to come. llvm-svn: 172922
2013-01-20 05:39:22 +08:00
case llvm::BitstreamEntry::SubBlock:
switch (Entry.ID) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
case INPUT_FILES_BLOCK_ID:
F.InputFilesCursor = Stream;
if (Stream.SkipBlock() || // Skip with the main cursor
// Read the abbreviations
ReadBlockAbbrevs(F.InputFilesCursor, INPUT_FILES_BLOCK_ID)) {
Error("malformed block record in AST file");
return Failure;
}
continue;
[modules] Write the options records to a separate subblock rather than writing them directly to the control block. These are fairly large, and in a build with lots of modules / chained PCH, we don't need to read most of them. No functionality change intended. llvm-svn: 247055
2015-09-09 03:40:14 +08:00
case OPTIONS_BLOCK_ID:
// If we're reading the first module for this group, check its options
// are compatible with ours. For modules it imports, no further checking
// is required, because we checked them when we built it.
if (Listener && !ImportedBy) {
// Should we allow the configuration of the module file to differ from
// the configuration of the current translation unit in a compatible
// way?
//
// FIXME: Allow this for files explicitly specified with -include-pch.
bool AllowCompatibleConfigurationMismatch =
F.Kind == MK_ExplicitModule;
[modules] If we're given a module file, via -fmodule-file=, for a module, but we can't load that file due to a configuration mismatch, and implicit module building is disabled, and the user turns off the error-by-default warning for that situation, then fall back to textual inclusion for the module rather than giving an error if any of its headers are included. llvm-svn: 252114
2015-11-05 08:54:55 +08:00
Result = ReadOptionsBlock(Stream, ClientLoadCapabilities,
AllowCompatibleConfigurationMismatch,
*Listener, SuggestedPredefines);
[modules] Write the options records to a separate subblock rather than writing them directly to the control block. These are fairly large, and in a build with lots of modules / chained PCH, we don't need to read most of them. No functionality change intended. llvm-svn: 247055
2015-09-09 03:40:14 +08:00
if (Result == Failure) {
Error("malformed block record in AST file");
return Result;
}
[modules] If we're given a module file, via -fmodule-file=, for a module, but we can't load that file due to a configuration mismatch, and implicit module building is disabled, and the user turns off the error-by-default warning for that situation, then fall back to textual inclusion for the module rather than giving an error if any of its headers are included. llvm-svn: 252114
2015-11-05 08:54:55 +08:00
if (DisableValidation ||
(AllowConfigurationMismatch && Result == ConfigurationMismatch))
Result = Success;
// If we've diagnosed a problem, we're done.
if (Result != Success &&
isDiagnosedResult(Result, ClientLoadCapabilities))
[modules] Write the options records to a separate subblock rather than writing them directly to the control block. These are fairly large, and in a build with lots of modules / chained PCH, we don't need to read most of them. No functionality change intended. llvm-svn: 247055
2015-09-09 03:40:14 +08:00
return Result;
} else if (Stream.SkipBlock()) {
Error("malformed block record in AST file");
return Failure;
}
continue;
switch a bunch of ASTReader to use the new BitstreamCursor::advance* methods, which hide a bunch of private details of the cursor from clients and simplify their code. More to come. llvm-svn: 172922
2013-01-20 05:39:22 +08:00
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
default:
switch a bunch of ASTReader to use the new BitstreamCursor::advance* methods, which hide a bunch of private details of the cursor from clients and simplify their code. More to come. llvm-svn: 172922
2013-01-20 05:39:22 +08:00
if (Stream.SkipBlock()) {
Error("malformed block record in AST file");
return Failure;
}
continue;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
switch a bunch of ASTReader to use the new BitstreamCursor::advance* methods, which hide a bunch of private details of the cursor from clients and simplify their code. More to come. llvm-svn: 172922
2013-01-20 05:39:22 +08:00
case llvm::BitstreamEntry::Record:
// The interesting case.
break;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
// Read and process a record.
Record.clear();
update to use the new BitcodeCursor readRecord that takes a StringRef blob parameter, and adopt "advance" in more places. llvm-svn: 172951
2013-01-20 10:38:54 +08:00
StringRef Blob;
switch ((ControlRecordTypes)Stream.readRecord(Entry.ID, Record, &Blob)) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
case METADATA: {
if (Record[0] != VERSION_MAJOR && !DisableValidation) {
if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
Rename some PCH-related errors to have 'err_' as their prefix llvm-svn: 201157
2014-02-11 23:40:09 +08:00
Diag(Record[0] < VERSION_MAJOR? diag::err_pch_version_too_old
: diag::err_pch_version_too_new);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
return VersionMismatch;
}
[modules] When explicitly building a module file, don't include timestamps in the produced pcm file for stable file creation across distributed build systems. llvm-svn: 245199
2015-08-17 15:13:32 +08:00
bool hasErrors = Record[6];
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
if (hasErrors && !DisableValidation && !AllowASTWithCompilerErrors) {
Diag(diag::err_pch_with_compiler_errors);
return HadErrors;
}
F.RelocatablePCH = Record[4];
[modules] Instead of storing absolute paths in a .pcm file, store the path to the root of the module and use paths relative to that directory wherever possible. This is a step towards allowing explicit modules to be relocated without being rebuilt, which is important for some kinds of distributed builds, for good paths in diagnostics, and for appropriate .d output. This is a recommit of r223443, reverted in r223465; when joining together imported file paths, we now use the system's separator rather than always using '/'. This avoids path mismatches between the original module build and the module user on Windows (at least, in some cases). A more comprehensive fix will follow. llvm-svn: 223539
2014-12-06 06:42:13 +08:00
// Relative paths in a relocatable PCH are relative to our sysroot.
if (F.RelocatablePCH)
F.BaseDirectory = isysroot.empty() ? "/" : isysroot;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
[modules] When explicitly building a module file, don't include timestamps in the produced pcm file for stable file creation across distributed build systems. llvm-svn: 245199
2015-08-17 15:13:32 +08:00
F.HasTimestamps = Record[5];
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
const std::string &CurBranch = getClangFullRepositoryVersion();
update to use the new BitcodeCursor readRecord that takes a StringRef blob parameter, and adopt "advance" in more places. llvm-svn: 172951
2013-01-20 10:38:54 +08:00
StringRef ASTBranch = Blob;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
if (StringRef(CurBranch) != ASTBranch && !DisableValidation) {
if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
Rename some PCH-related errors to have 'err_' as their prefix llvm-svn: 201157
2014-02-11 23:40:09 +08:00
Diag(diag::err_pch_different_branch) << ASTBranch << CurBranch;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
return VersionMismatch;
}
break;
}
Add a "signature" to AST files to verify that they haven't changed Since the order of the IDs in the AST file (e.g. DeclIDs, SelectorIDs) is not stable, it is not safe to load an AST file that depends on another AST file that has been rebuilt since the importer was built, even if "nothing changed". We previously used size and modtime to check this, but I've seen cases where a module rebuilt quickly enough to foil this check and caused very hard to debug build errors. To save cycles when we're loading the AST, we just generate a random nonce value and check that it hasn't changed when we load an imported module, rather than actually hash the whole file. This is slightly complicated by the fact that we need to verify the signature inside addModule, since we might otherwise consider that a mdoule is "OutOfDate" when really it is the importer that is out of date. I didn't see any regressions in module load time after this change. llvm-svn: 220493
2014-10-24 02:05:36 +08:00
case SIGNATURE:
assert((!F.Signature || F.Signature == Record[0]) && "signature changed");
F.Signature = Record[0];
break;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
case IMPORTS: {
// Load each of the imported PCH files.
unsigned Idx = 0, N = Record.size();
while (Idx < N) {
// Read information about the AST file.
ModuleKind ImportedKind = (ModuleKind)Record[Idx++];
// The import location will be the local one for now; we will adjust
// all import locations of module imports after the global source
// location info are setup.
SourceLocation ImportLoc =
SourceLocation::getFromRawEncoding(Record[Idx++]);
<rdar://problem/13363214> Eliminate race condition between module rebuild and the global module index. The global module index was querying the file manager for each of the module files it knows about at load time, to prune out any out-of-date information. The file manager would then cache the results of the stat() falls used to find that module file. Later, the same translation unit could end up trying to import one of the module files that had previously been ignored by the module cache, but after some other Clang instance rebuilt the module file to bring it up-to-date. The stale stat() results in the file manager would trigger a second rebuild of the already-up-to-date module, causing failures down the line. The global module index now lazily resolves its module file references to actual AST reader module files only after the module file has been loaded, eliminating the stat-caching race. Moreover, the AST reader can communicate to its caller that a module file is missing (rather than simply being out-of-date), allowing us to simplify the module-loading logic and allowing the compiler to recover if a dependent module file ends up getting deleted. llvm-svn: 177367
2013-03-19 08:28:20 +08:00
off_t StoredSize = (off_t)Record[Idx++];
time_t StoredModTime = (time_t)Record[Idx++];
Add a "signature" to AST files to verify that they haven't changed Since the order of the IDs in the AST file (e.g. DeclIDs, SelectorIDs) is not stable, it is not safe to load an AST file that depends on another AST file that has been rebuilt since the importer was built, even if "nothing changed". We previously used size and modtime to check this, but I've seen cases where a module rebuilt quickly enough to foil this check and caused very hard to debug build errors. To save cycles when we're loading the AST, we just generate a random nonce value and check that it hasn't changed when we load an imported module, rather than actually hash the whole file. This is slightly complicated by the fact that we need to verify the signature inside addModule, since we might otherwise consider that a mdoule is "OutOfDate" when really it is the importer that is out of date. I didn't see any regressions in module load time after this change. llvm-svn: 220493
2014-10-24 02:05:36 +08:00
ASTFileSignature StoredSignature = Record[Idx++];
[modules] Instead of storing absolute paths in a .pcm file, store the path to the root of the module and use paths relative to that directory wherever possible. This is a step towards allowing explicit modules to be relocated without being rebuilt, which is important for some kinds of distributed builds, for good paths in diagnostics, and for appropriate .d output. This is a recommit of r223443, reverted in r223465; when joining together imported file paths, we now use the system's separator rather than always using '/'. This avoids path mismatches between the original module build and the module user on Windows (at least, in some cases). A more comprehensive fix will follow. llvm-svn: 223539
2014-12-06 06:42:13 +08:00
auto ImportedFile = ReadPath(F, Record, Idx);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
[modules] PR22534: Load files specified by -fmodule-file= eagerly. In particular, this avoids the need to re-parse module map files when using such a module. llvm-svn: 244416
2015-08-09 16:48:41 +08:00
// If our client can't cope with us being out of date, we can't cope with
// our dependency being missing.
unsigned Capabilities = ClientLoadCapabilities;
if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
Capabilities &= ~ARR_Missing;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
// Load the AST file.
[modules] PR22534: Load files specified by -fmodule-file= eagerly. In particular, this avoids the need to re-parse module map files when using such a module. llvm-svn: 244416
2015-08-09 16:48:41 +08:00
auto Result = ReadASTCore(ImportedFile, ImportedKind, ImportLoc, &F,
Loaded, StoredSize, StoredModTime,
StoredSignature, Capabilities);
// If we diagnosed a problem, produce a backtrace.
if (isDiagnosedResult(Result, Capabilities))
Diag(diag::note_module_file_imported_by)
<< F.FileName << !F.ModuleName.empty() << F.ModuleName;
switch (Result) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
case Failure: return Failure;
// If we have to ignore the dependency, we'll have to ignore this too.
Minor optimization to r177367 to treat a module with missing dependencies as out-of-date rather than missing. llvm-svn: 177369
2013-03-19 08:38:50 +08:00
case Missing:
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
case OutOfDate: return OutOfDate;
case VersionMismatch: return VersionMismatch;
case ConfigurationMismatch: return ConfigurationMismatch;
case HadErrors: return HadErrors;
case Success: break;
}
}
break;
}
case ORIGINAL_FILE:
F.OriginalSourceFileID = FileID::get(Record[0]);
update to use the new BitcodeCursor readRecord that takes a StringRef blob parameter, and adopt "advance" in more places. llvm-svn: 172951
2013-01-20 10:38:54 +08:00
F.ActualOriginalSourceFileName = Blob;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
F.OriginalSourceFileName = F.ActualOriginalSourceFileName;
[modules] Instead of storing absolute paths in a .pcm file, store the path to the root of the module and use paths relative to that directory wherever possible. This is a step towards allowing explicit modules to be relocated without being rebuilt, which is important for some kinds of distributed builds, for good paths in diagnostics, and for appropriate .d output. This is a recommit of r223443, reverted in r223465; when joining together imported file paths, we now use the system's separator rather than always using '/'. This avoids path mismatches between the original module build and the module user on Windows (at least, in some cases). A more comprehensive fix will follow. llvm-svn: 223539
2014-12-06 06:42:13 +08:00
ResolveImportedPath(F, F.OriginalSourceFileName);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
break;
case ORIGINAL_FILE_ID:
F.OriginalSourceFileID = FileID::get(Record[0]);
break;
case ORIGINAL_PCH_DIR:
update to use the new BitcodeCursor readRecord that takes a StringRef blob parameter, and adopt "advance" in more places. llvm-svn: 172951
2013-01-20 10:38:54 +08:00
F.OriginalDir = Blob;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
break;
Allow multiple modules with the same name to coexist in the module cache To differentiate between two modules with the same name, we will consider the path the module map file that they are defined by* part of the ‘key’ for looking up the precompiled module (pcm file). Specifically, this patch renames the precompiled module (pcm) files from cache-path/<module hash>/Foo.pcm to cache-path/<module hash>/Foo-<hash of module map path>.pcm In addition, I’ve taught the ASTReader to re-resolve the names of imported modules during module loading so that if the header search context changes between when a module was originally built and when it is loaded we can rebuild it if necessary. For example, if module A imports module B first time: clang -I /path/to/A -I /path/to/B ... second time: clang -I /path/to/A -I /different/path/to/B ... will now rebuild A as expected. * in the case of inferred modules, we use the module map file that allowed the inference, not the __inferred_module.map file, since the inferred file path is the same for every inferred module. llvm-svn: 206201
2014-04-15 02:00:01 +08:00
case MODULE_NAME:
F.ModuleName = Blob;
Add module name and module map file to -module-file-info llvm-svn: 206217
2014-04-15 06:12:44 +08:00
if (Listener)
Listener->ReadModuleName(F.ModuleName);
Allow multiple modules with the same name to coexist in the module cache To differentiate between two modules with the same name, we will consider the path the module map file that they are defined by* part of the ‘key’ for looking up the precompiled module (pcm file). Specifically, this patch renames the precompiled module (pcm) files from cache-path/<module hash>/Foo.pcm to cache-path/<module hash>/Foo-<hash of module map path>.pcm In addition, I’ve taught the ASTReader to re-resolve the names of imported modules during module loading so that if the header search context changes between when a module was originally built and when it is loaded we can rebuild it if necessary. For example, if module A imports module B first time: clang -I /path/to/A -I /path/to/B ... second time: clang -I /path/to/A -I /different/path/to/B ... will now rebuild A as expected. * in the case of inferred modules, we use the module map file that allowed the inference, not the __inferred_module.map file, since the inferred file path is the same for every inferred module. llvm-svn: 206201
2014-04-15 02:00:01 +08:00
break;
[modules] If we import a module, and we've seen a module map that describes the module, use the path from the module map file in preference to the path from the .pcm file when resolving relative paths in the .pcm file. This allows diagnostics (and .d output) to give relative paths if the module was found via a relative path. llvm-svn: 223577
2014-12-06 11:21:08 +08:00
case MODULE_DIRECTORY: {
assert(!F.ModuleName.empty() &&
"MODULE_DIRECTORY found before MODULE_NAME");
// If we've already loaded a module map file covering this module, we may
// have a better path for it (relative to the current build).
Module *M = PP.getHeaderSearchInfo().lookupModule(F.ModuleName);
if (M && M->Directory) {
// If we're implicitly loading a module, the base directory can't
// change between the build and use.
if (F.Kind != MK_ExplicitModule) {
const DirectoryEntry *BuildDir =
PP.getFileManager().getDirectory(Blob);
if (!BuildDir || BuildDir != M->Directory) {
if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
Diag(diag::err_imported_module_relocated)
<< F.ModuleName << Blob << M->Directory->getName();
return OutOfDate;
}
}
F.BaseDirectory = M->Directory->getName();
} else {
F.BaseDirectory = Blob;
}
[modules] Instead of storing absolute paths in a .pcm file, store the path to the root of the module and use paths relative to that directory wherever possible. This is a step towards allowing explicit modules to be relocated without being rebuilt, which is important for some kinds of distributed builds, for good paths in diagnostics, and for appropriate .d output. This is a recommit of r223443, reverted in r223465; when joining together imported file paths, we now use the system's separator rather than always using '/'. This avoids path mismatches between the original module build and the module user on Windows (at least, in some cases). A more comprehensive fix will follow. llvm-svn: 223539
2014-12-06 06:42:13 +08:00
break;
[modules] If we import a module, and we've seen a module map that describes the module, use the path from the module map file in preference to the path from the .pcm file when resolving relative paths in the .pcm file. This allows diagnostics (and .d output) to give relative paths if the module was found via a relative path. llvm-svn: 223577
2014-12-06 11:21:08 +08:00
}
[modules] Instead of storing absolute paths in a .pcm file, store the path to the root of the module and use paths relative to that directory wherever possible. This is a step towards allowing explicit modules to be relocated without being rebuilt, which is important for some kinds of distributed builds, for good paths in diagnostics, and for appropriate .d output. This is a recommit of r223443, reverted in r223465; when joining together imported file paths, we now use the system's separator rather than always using '/'. This avoids path mismatches between the original module build and the module user on Windows (at least, in some cases). A more comprehensive fix will follow. llvm-svn: 223539
2014-12-06 06:42:13 +08:00
Allow multiple modules with the same name to coexist in the module cache To differentiate between two modules with the same name, we will consider the path the module map file that they are defined by* part of the ‘key’ for looking up the precompiled module (pcm file). Specifically, this patch renames the precompiled module (pcm) files from cache-path/<module hash>/Foo.pcm to cache-path/<module hash>/Foo-<hash of module map path>.pcm In addition, I’ve taught the ASTReader to re-resolve the names of imported modules during module loading so that if the header search context changes between when a module was originally built and when it is loaded we can rebuild it if necessary. For example, if module A imports module B first time: clang -I /path/to/A -I /path/to/B ... second time: clang -I /path/to/A -I /different/path/to/B ... will now rebuild A as expected. * in the case of inferred modules, we use the module map file that allowed the inference, not the __inferred_module.map file, since the inferred file path is the same for every inferred module. llvm-svn: 206201
2014-04-15 02:00:01 +08:00
case MODULE_MAP_FILE:
Verify all the module map files for a pcm are the same on load We already verified the primary module map file (either the one that defines the top-level module, or the one that allows inferring it if it is an inferred framework module). Now we also verify any other module map files that define submodules, such as when there is a module.private.modulemap file. llvm-svn: 215455
2014-08-13 00:42:33 +08:00
if (ASTReadResult Result =
ReadModuleMapFileBlock(Record, F, ImportedBy, ClientLoadCapabilities))
return Result;
Fix unintended fallthrough in ASTReader llvm-svn: 221567
2014-11-08 08:06:39 +08:00
break;
Revert "ASTReader: Copy input file offset data to avoid unaligned accesses" We can do this better by changing the type to unaligned_uint64_t and paying the cost on use instead of up front. This reverts r240228 llvm-svn: 240246
2015-06-22 04:32:36 +08:00
case INPUT_FILE_OFFSETS:
[modules] Simplify reading of INPUT_FILE_OFFSETS record and make it robust against changes to record order. llvm-svn: 220524
2014-10-24 06:18:29 +08:00
NumInputs = Record[0];
NumUserInputs = Record[1];
ASTReader: Treat InputFileOffsets as unaligned to avoid UB This is a better approach to fixing the undefined behaviour I tried to fix in r240228. This data doesn't necessarily have suitable alignment for uint64_t, so use unaligned_uint64_t instead. This fixes 225 test failures when clang is built with ubsan. llvm-svn: 240247
2015-06-22 04:32:40 +08:00
F.InputFileOffsets =
(const llvm::support::unaligned_uint64_t *)Blob.data();
[modules] Simplify reading of INPUT_FILE_OFFSETS record and make it robust against changes to record order. llvm-svn: 220524
2014-10-24 06:18:29 +08:00
F.InputFilesLoaded.resize(NumInputs);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
break;
}
}
}
When module umbrellas change, rebuild them With the VFS, it is easy to hit modified umbrellas by overriding the umbrella header, and what we want is to rebuild, not to fail. llvm-svn: 205975
2014-04-11 01:57:43 +08:00
ASTReader::ASTReadResult
ASTReader::ReadASTBlock(ModuleFile &F, unsigned ClientLoadCapabilities) {
finish converting the normal cases in ASTReader to use the new BitstreamCursor APIs. llvm-svn: 172937
2013-01-20 08:56:42 +08:00
BitstreamCursor &Stream = F.Stream;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
if (Stream.EnterSubBlock(AST_BLOCK_ID)) {
Error("malformed block record in AST file");
When module umbrellas change, rebuild them With the VFS, it is easy to hit modified umbrellas by overriding the umbrella header, and what we want is to rebuild, not to fail. llvm-svn: 205975
2014-04-11 01:57:43 +08:00
return Failure;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
// Read all of the records and blocks for the AST file.
RecordData Record;
switch a bunch of ASTReader to use the new BitstreamCursor::advance* methods, which hide a bunch of private details of the cursor from clients and simplify their code. More to come. llvm-svn: 172922
2013-01-20 05:39:22 +08:00
while (1) {
llvm::BitstreamEntry Entry = Stream.advance();
switch (Entry.Kind) {
case llvm::BitstreamEntry::Error:
Error("error at end of module block in AST file");
When module umbrellas change, rebuild them With the VFS, it is easy to hit modified umbrellas by overriding the umbrella header, and what we want is to rebuild, not to fail. llvm-svn: 205975
2014-04-11 01:57:43 +08:00
return Failure;
switch a bunch of ASTReader to use the new BitstreamCursor::advance* methods, which hide a bunch of private details of the cursor from clients and simplify their code. More to come. llvm-svn: 172922
2013-01-20 05:39:22 +08:00
case llvm::BitstreamEntry::EndBlock: {
Pare back r164351 somewhat. The problem that change was addressing was that we don't serialize a lookup map for the translation unit outside C++ mode, so we can't tell when lookup within the TU needs to look within modules. Only apply the fix outside C++ mode, and only to the translation unit. llvm-svn: 178706
2013-04-04 06:49:41 +08:00
// Outside of C++, we do not store a lookup map for the translation unit.
// Instead, mark it as needing a lookup map to be built if this module
// contains any declarations lexically within it (which it always does!).
// This usually has no cost, since we very rarely need the lookup map for
// the translation unit outside C++.
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
DeclContext *DC = Context.getTranslationUnitDecl();
Pare back r164351 somewhat. The problem that change was addressing was that we don't serialize a lookup map for the translation unit outside C++ mode, so we can't tell when lookup within the TU needs to look within modules. Only apply the fix outside C++ mode, and only to the translation unit. llvm-svn: 178706
2013-04-04 06:49:41 +08:00
if (DC->hasExternalLexicalStorage() &&
!getContext().getLangOpts().CPlusPlus)
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
DC->setMustBuildLookupTable();
switch a bunch of ASTReader to use the new BitstreamCursor::advance* methods, which hide a bunch of private details of the cursor from clients and simplify their code. More to come. llvm-svn: 172922
2013-01-20 05:39:22 +08:00
When module umbrellas change, rebuild them With the VFS, it is easy to hit modified umbrellas by overriding the umbrella header, and what we want is to rebuild, not to fail. llvm-svn: 205975
2014-04-11 01:57:43 +08:00
return Success;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
switch a bunch of ASTReader to use the new BitstreamCursor::advance* methods, which hide a bunch of private details of the cursor from clients and simplify their code. More to come. llvm-svn: 172922
2013-01-20 05:39:22 +08:00
case llvm::BitstreamEntry::SubBlock:
switch (Entry.ID) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
case DECLTYPES_BLOCK_ID:
// 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.
F.DeclsCursor = Stream;
if (Stream.SkipBlock() || // Skip with the main cursor.
// Read the abbrevs.
ReadBlockAbbrevs(F.DeclsCursor, DECLTYPES_BLOCK_ID)) {
Error("malformed block record in AST file");
When module umbrellas change, rebuild them With the VFS, it is easy to hit modified umbrellas by overriding the umbrella header, and what we want is to rebuild, not to fail. llvm-svn: 205975
2014-04-11 01:57:43 +08:00
return Failure;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
break;
Rearrange serialization block order to put decl update emission into the same block as decl and type emission. This allows decl updates include statements and expressions. No functionality change (but the generated PCM files are incompatible with earlier versions of Clang). llvm-svn: 204385
2014-03-21 03:44:17 +08:00
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
case PREPROCESSOR_BLOCK_ID:
F.MacroCursor = Stream;
if (!PP.getExternalSource())
PP.setExternalSource(this);
switch a bunch of ASTReader to use the new BitstreamCursor::advance* methods, which hide a bunch of private details of the cursor from clients and simplify their code. More to come. llvm-svn: 172922
2013-01-20 05:39:22 +08:00
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
if (Stream.SkipBlock() ||
ReadBlockAbbrevs(F.MacroCursor, PREPROCESSOR_BLOCK_ID)) {
Error("malformed block record in AST file");
When module umbrellas change, rebuild them With the VFS, it is easy to hit modified umbrellas by overriding the umbrella header, and what we want is to rebuild, not to fail. llvm-svn: 205975
2014-04-11 01:57:43 +08:00
return Failure;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
F.MacroStartOffset = F.MacroCursor.GetCurrentBitNo();
break;
switch a bunch of ASTReader to use the new BitstreamCursor::advance* methods, which hide a bunch of private details of the cursor from clients and simplify their code. More to come. llvm-svn: 172922
2013-01-20 05:39:22 +08:00
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
case PREPROCESSOR_DETAIL_BLOCK_ID:
F.PreprocessorDetailCursor = Stream;
if (Stream.SkipBlock() ||
switch a bunch of ASTReader to use the new BitstreamCursor::advance* methods, which hide a bunch of private details of the cursor from clients and simplify their code. More to come. llvm-svn: 172922
2013-01-20 05:39:22 +08:00
ReadBlockAbbrevs(F.PreprocessorDetailCursor,
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
PREPROCESSOR_DETAIL_BLOCK_ID)) {
switch a bunch of ASTReader to use the new BitstreamCursor::advance* methods, which hide a bunch of private details of the cursor from clients and simplify their code. More to come. llvm-svn: 172922
2013-01-20 05:39:22 +08:00
Error("malformed preprocessor detail record in AST file");
When module umbrellas change, rebuild them With the VFS, it is easy to hit modified umbrellas by overriding the umbrella header, and what we want is to rebuild, not to fail. llvm-svn: 205975
2014-04-11 01:57:43 +08:00
return Failure;
switch a bunch of ASTReader to use the new BitstreamCursor::advance* methods, which hide a bunch of private details of the cursor from clients and simplify their code. More to come. llvm-svn: 172922
2013-01-20 05:39:22 +08:00
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
F.PreprocessorDetailStartOffset
switch a bunch of ASTReader to use the new BitstreamCursor::advance* methods, which hide a bunch of private details of the cursor from clients and simplify their code. More to come. llvm-svn: 172922
2013-01-20 05:39:22 +08:00
= F.PreprocessorDetailCursor.GetCurrentBitNo();
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
if (!PP.getPreprocessingRecord())
PP.createPreprocessingRecord();
if (!PP.getPreprocessingRecord()->getExternalSource())
PP.getPreprocessingRecord()->SetExternalSource(*this);
break;
case SOURCE_MANAGER_BLOCK_ID:
if (ReadSourceManagerBlock(F))
When module umbrellas change, rebuild them With the VFS, it is easy to hit modified umbrellas by overriding the umbrella header, and what we want is to rebuild, not to fail. llvm-svn: 205975
2014-04-11 01:57:43 +08:00
return Failure;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
break;
switch a bunch of ASTReader to use the new BitstreamCursor::advance* methods, which hide a bunch of private details of the cursor from clients and simplify their code. More to come. llvm-svn: 172922
2013-01-20 05:39:22 +08:00
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
case SUBMODULE_BLOCK_ID:
When module umbrellas change, rebuild them With the VFS, it is easy to hit modified umbrellas by overriding the umbrella header, and what we want is to rebuild, not to fail. llvm-svn: 205975
2014-04-11 01:57:43 +08:00
if (ASTReadResult Result = ReadSubmoduleBlock(F, ClientLoadCapabilities))
return Result;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
break;
switch a bunch of ASTReader to use the new BitstreamCursor::advance* methods, which hide a bunch of private details of the cursor from clients and simplify their code. More to come. llvm-svn: 172922
2013-01-20 05:39:22 +08:00
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
case COMMENTS_BLOCK_ID: {
finish converting the normal cases in ASTReader to use the new BitstreamCursor APIs. llvm-svn: 172937
2013-01-20 08:56:42 +08:00
BitstreamCursor C = Stream;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
if (Stream.SkipBlock() ||
ReadBlockAbbrevs(C, COMMENTS_BLOCK_ID)) {
Error("malformed comments block in AST file");
When module umbrellas change, rebuild them With the VFS, it is easy to hit modified umbrellas by overriding the umbrella header, and what we want is to rebuild, not to fail. llvm-svn: 205975
2014-04-11 01:57:43 +08:00
return Failure;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
CommentsCursors.push_back(std::make_pair(C, &F));
break;
}
switch a bunch of ASTReader to use the new BitstreamCursor::advance* methods, which hide a bunch of private details of the cursor from clients and simplify their code. More to come. llvm-svn: 172922
2013-01-20 05:39:22 +08:00
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
default:
switch a bunch of ASTReader to use the new BitstreamCursor::advance* methods, which hide a bunch of private details of the cursor from clients and simplify their code. More to come. llvm-svn: 172922
2013-01-20 05:39:22 +08:00
if (Stream.SkipBlock()) {
Error("malformed block record in AST file");
When module umbrellas change, rebuild them With the VFS, it is easy to hit modified umbrellas by overriding the umbrella header, and what we want is to rebuild, not to fail. llvm-svn: 205975
2014-04-11 01:57:43 +08:00
return Failure;
switch a bunch of ASTReader to use the new BitstreamCursor::advance* methods, which hide a bunch of private details of the cursor from clients and simplify their code. More to come. llvm-svn: 172922
2013-01-20 05:39:22 +08:00
}
break;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
continue;
switch a bunch of ASTReader to use the new BitstreamCursor::advance* methods, which hide a bunch of private details of the cursor from clients and simplify their code. More to come. llvm-svn: 172922
2013-01-20 05:39:22 +08:00
case llvm::BitstreamEntry::Record:
// The interesting case.
break;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
// Read and process a record.
Record.clear();
update to use the new BitcodeCursor readRecord that takes a StringRef blob parameter, and adopt "advance" in more places. llvm-svn: 172951
2013-01-20 10:38:54 +08:00
StringRef Blob;
switch ((ASTRecordTypes)Stream.readRecord(Entry.ID, Record, &Blob)) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
default: // Default behavior: ignore.
break;
case TYPE_OFFSET: {
if (F.LocalNumTypes != 0) {
Error("duplicate TYPE_OFFSET record in AST file");
When module umbrellas change, rebuild them With the VFS, it is easy to hit modified umbrellas by overriding the umbrella header, and what we want is to rebuild, not to fail. llvm-svn: 205975
2014-04-11 01:57:43 +08:00
return Failure;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
update to use the new BitcodeCursor readRecord that takes a StringRef blob parameter, and adopt "advance" in more places. llvm-svn: 172951
2013-01-20 10:38:54 +08:00
F.TypeOffsets = (const uint32_t *)Blob.data();
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
F.LocalNumTypes = Record[0];
unsigned LocalBaseTypeIndex = Record[1];
F.BaseTypeIndex = getTotalNumTypes();
if (F.LocalNumTypes > 0) {
// Introduce the global -> local mapping for types within this module.
GlobalTypeMap.insert(std::make_pair(getTotalNumTypes(), &F));
// Introduce the local -> global mapping for types within this module.
F.TypeRemap.insertOrReplace(
std::make_pair(LocalBaseTypeIndex,
F.BaseTypeIndex - LocalBaseTypeIndex));
Revert most of r215810, which is no longer needed Now that we no longer add mappings when there are no local entities, there is no need to always bump the size of the tables that correspond to ContinuousRangeMaps. llvm-svn: 220208
2014-10-21 00:27:32 +08:00
TypesLoaded.resize(TypesLoaded.size() + F.LocalNumTypes);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
break;
}
case DECL_OFFSET: {
if (F.LocalNumDecls != 0) {
Error("duplicate DECL_OFFSET record in AST file");
When module umbrellas change, rebuild them With the VFS, it is easy to hit modified umbrellas by overriding the umbrella header, and what we want is to rebuild, not to fail. llvm-svn: 205975
2014-04-11 01:57:43 +08:00
return Failure;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
update to use the new BitcodeCursor readRecord that takes a StringRef blob parameter, and adopt "advance" in more places. llvm-svn: 172951
2013-01-20 10:38:54 +08:00
F.DeclOffsets = (const DeclOffset *)Blob.data();
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
F.LocalNumDecls = Record[0];
unsigned LocalBaseDeclID = Record[1];
F.BaseDeclID = getTotalNumDecls();
if (F.LocalNumDecls > 0) {
// Introduce the global -> local mapping for declarations within this
// module.
GlobalDeclMap.insert(
std::make_pair(getTotalNumDecls() + NUM_PREDEF_DECL_IDS, &F));
// Introduce the local -> global mapping for declarations within this
// module.
F.DeclRemap.insertOrReplace(
std::make_pair(LocalBaseDeclID, F.BaseDeclID - LocalBaseDeclID));
// Introduce the global -> local mapping for declarations within this
// module.
F.GlobalToLocalDeclIDs[&F] = LocalBaseDeclID;
When loading a module with no local entities, still bump the size of the tables that correspond to ContinuousRangeMaps, since the keys to those maps need to be unique, or we may map to the wrong offset. This fixes a crash + malformed AST file seen when loading some modules that import Cocoa on Darwin, which is a module with no contents except imports of other modules. Unfortunately I have not been able to find a reduced test case that reproduces this problem. Also add an assert that we aren't mapping one key to multiple values in CRM. We ought to be able to say there are no duplicate keys at all, but there are a bunch of 0 -> 0 mappings that are showing up, probably coming from the source location table. llvm-svn: 215810
2014-08-16 12:54:18 +08:00
Revert most of r215810, which is no longer needed Now that we no longer add mappings when there are no local entities, there is no need to always bump the size of the tables that correspond to ContinuousRangeMaps. llvm-svn: 220208
2014-10-21 00:27:32 +08:00
DeclsLoaded.resize(DeclsLoaded.size() + F.LocalNumDecls);
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
break;
}
case TU_UPDATE_LEXICAL: {
DeclContext *TU = Context.getTranslationUnitDecl();
[modules] Stop walking all modules when looking for lexical decls for a DeclContext. These only ever come from the owning module file for the Decl. llvm-svn: 244285
2015-08-07 06:07:25 +08:00
LexicalContents Contents(
reinterpret_cast<const llvm::support::unaligned_uint32_t *>(
Blob.data()),
static_cast<unsigned int>(Blob.size() / 4));
TULexicalDecls.push_back(std::make_pair(&F, Contents));
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
TU->setHasExternalLexicalStorage(true);
break;
}
case UPDATE_VISIBLE: {
unsigned Idx = 0;
serialization::DeclID ID = ReadDeclID(F, Record, Idx);
[modules] Defer setting up the lookup table for a DeclContext until we can determine the primary context, rather than sometimes registering the lookup table on the wrong context. This exposed a couple of bugs: * the odr violation check didn't deal properly with mergeable declarations if the declaration retained by name lookup wasn't in the canonical definition of the class * the (broken) RewriteDecl mechanism would emit two name lookup tables for the same DeclContext into the same module file (one as part of the rewritten declaration and one as a visible update for the old declaration) These are both fixed too. llvm-svn: 244192
2015-08-06 12:23:48 +08:00
auto *Data = (const unsigned char*)Blob.data();
Re-commit r246497 (and dependent changes r246524 and r246521), reverted in r246546, with a workaround for an MSVC 2013 miscompile and an MSVC 2015 rejects-valid. Original commit message: [modules] Rework serialized DeclContext lookup table management. Instead of walking the loaded ModuleFiles looking for lookup tables for the context, store them all in one place, and merge them together if we find we have too many (currently, more than 4). If we do merge, include the merged form in our serialized lookup table, so that downstream readers never need to look at our imports' tables. This gives a huge performance improvement to builds with very large numbers of modules (in some cases, more than a 2x speedup was observed). llvm-svn: 246582
2015-09-02 04:35:42 +08:00
PendingVisibleUpdates[ID].push_back(PendingVisibleUpdate{&F, Data});
[modules] Defer setting up the lookup table for a DeclContext until we can determine the primary context, rather than sometimes registering the lookup table on the wrong context. This exposed a couple of bugs: * the odr violation check didn't deal properly with mergeable declarations if the declaration retained by name lookup wasn't in the canonical definition of the class * the (broken) RewriteDecl mechanism would emit two name lookup tables for the same DeclContext into the same module file (one as part of the rewritten declaration and one as a visible update for the old declaration) These are both fixed too. llvm-svn: 244192
2015-08-06 12:23:48 +08:00
// If we've already loaded the decl, perform the updates when we finish
// loading this block.
if (Decl *D = GetExistingDecl(ID))
PendingUpdateRecords.push_back(std::make_pair(ID, D));
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
break;
}
case IDENTIFIER_TABLE:
update to use the new BitcodeCursor readRecord that takes a StringRef blob parameter, and adopt "advance" in more places. llvm-svn: 172951
2013-01-20 10:38:54 +08:00
F.IdentifierTableData = Blob.data();
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
if (Record[0]) {
OnDiskHashTable: Make the iterable version separate. Currently the on disk hash table's key_iterator and data_iterator make the assumption that the table data starts exactly four bytes after the base of the table. This happens to be true for all of the tables we currently iterate over, but not for all of the OnDiskHashTables we currently use. For example, key_ and data_iterator would iterate over meaningless data if they were used on the hash tables in PTHLexer. We make the API safer by breaking this into two types. One doesn't have the iterators, and the other must be told where the payload starts. llvm-svn: 206189
2014-04-15 00:34:29 +08:00
F.IdentifierLookupTable = ASTIdentifierLookupTable::Create(
(const unsigned char *)F.IdentifierTableData + Record[0],
(const unsigned char *)F.IdentifierTableData + sizeof(uint32_t),
(const unsigned char *)F.IdentifierTableData,
ASTIdentifierLookupTrait(*this, F));
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
PP.getIdentifierTable().setExternalIdentifierLookup(this);
}
break;
case IDENTIFIER_OFFSET: {
if (F.LocalNumIdentifiers != 0) {
Error("duplicate IDENTIFIER_OFFSET record in AST file");
When module umbrellas change, rebuild them With the VFS, it is easy to hit modified umbrellas by overriding the umbrella header, and what we want is to rebuild, not to fail. llvm-svn: 205975
2014-04-11 01:57:43 +08:00
return Failure;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
update to use the new BitcodeCursor readRecord that takes a StringRef blob parameter, and adopt "advance" in more places. llvm-svn: 172951
2013-01-20 10:38:54 +08:00
F.IdentifierOffsets = (const uint32_t *)Blob.data();
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
F.LocalNumIdentifiers = Record[0];
unsigned LocalBaseIdentifierID = Record[1];
F.BaseIdentifierID = getTotalNumIdentifiers();
if (F.LocalNumIdentifiers > 0) {
// Introduce the global -> local mapping for identifiers within this
// module.
GlobalIdentifierMap.insert(std::make_pair(getTotalNumIdentifiers() + 1,
&F));
// Introduce the local -> global mapping for identifiers within this
// module.
F.IdentifierRemap.insertOrReplace(
std::make_pair(LocalBaseIdentifierID,
F.BaseIdentifierID - LocalBaseIdentifierID));
When loading a module with no local entities, still bump the size of the tables that correspond to ContinuousRangeMaps, since the keys to those maps need to be unique, or we may map to the wrong offset. This fixes a crash + malformed AST file seen when loading some modules that import Cocoa on Darwin, which is a module with no contents except imports of other modules. Unfortunately I have not been able to find a reduced test case that reproduces this problem. Also add an assert that we aren't mapping one key to multiple values in CRM. We ought to be able to say there are no duplicate keys at all, but there are a bunch of 0 -> 0 mappings that are showing up, probably coming from the source location table. llvm-svn: 215810
2014-08-16 12:54:18 +08:00
Revert most of r215810, which is no longer needed Now that we no longer add mappings when there are no local entities, there is no need to always bump the size of the tables that correspond to ContinuousRangeMaps. llvm-svn: 220208
2014-10-21 00:27:32 +08:00
IdentifiersLoaded.resize(IdentifiersLoaded.size()
+ F.LocalNumIdentifiers);
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
break;
}
[modules] Stop performing PCM lookups for all identifiers when building with C++ modules. Instead, serialize a list of interesting identifiers and mark those ones out of date on module import. Avoiding the identifier lookups here gives a 20-30% speedup in builds with large numbers of modules. No functionality change intended. llvm-svn: 242868
2015-07-22 10:08:40 +08:00
case INTERESTING_IDENTIFIERS:
F.PreloadIdentifierOffsets.assign(Record.begin(), Record.end());
break;
Fix autolinking when modules are imported in pch files Add the ImportDecl to the set of interesting delcarations that are deserialized eagerly when an AST file is loaded (rather than lazily like most decls). This is required to get auto linking to work when there is no explicit import in the main file. Also resolve a FIXME to rename 'ExternalDefinitions', since that is only one of the things that need eager deserialization. The new name is 'EagerlyDeserializedDecls'. The corresponding AST bitcode is also renamed. llvm-svn: 200505
2014-01-31 09:06:56 +08:00
case EAGERLY_DESERIALIZED_DECLS:
[modules] Remove redundant import of lexical decls when building a lookup table for a DeclContext, and fix propagation of exception specifications along redeclaration chains. This reverts r232905, r232907, and r232907, which reverted r232793, r232853, and r232853. One additional change is present here to resolve issues with LLDB: distinguish between whether lexical decls missing from the lookup table are local or are provided by the external AST source, and still look in the external source if that's where they came from. llvm-svn: 232928
2015-03-23 11:25:59 +08:00
// FIXME: Skip reading this record if our ASTConsumer doesn't care
// about "interesting" decls (for instance, if we're building a module).
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
for (unsigned I = 0, N = Record.size(); I != N; ++I)
Fix autolinking when modules are imported in pch files Add the ImportDecl to the set of interesting delcarations that are deserialized eagerly when an AST file is loaded (rather than lazily like most decls). This is required to get auto linking to work when there is no explicit import in the main file. Also resolve a FIXME to rename 'ExternalDefinitions', since that is only one of the things that need eager deserialization. The new name is 'EagerlyDeserializedDecls'. The corresponding AST bitcode is also renamed. llvm-svn: 200505
2014-01-31 09:06:56 +08:00
EagerlyDeserializedDecls.push_back(getGlobalDeclID(F, Record[I]));
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
break;
case SPECIAL_TYPES:
Merge "special" types from different modules in the AST reader. Different modules may have different views of the various "special" types in the AST, such as the redefinition type for "id". Merge those types rather than only considering the redefinition types for the first AST file loaded. llvm-svn: 174234
2013-02-02 07:45:03 +08:00
if (SpecialTypes.empty()) {
for (unsigned I = 0, N = Record.size(); I != N; ++I)
SpecialTypes.push_back(getGlobalTypeID(F, Record[I]));
break;
}
if (SpecialTypes.size() != Record.size()) {
Error("invalid special-types record");
When module umbrellas change, rebuild them With the VFS, it is easy to hit modified umbrellas by overriding the umbrella header, and what we want is to rebuild, not to fail. llvm-svn: 205975
2014-04-11 01:57:43 +08:00
return Failure;
Merge "special" types from different modules in the AST reader. Different modules may have different views of the various "special" types in the AST, such as the redefinition type for "id". Merge those types rather than only considering the redefinition types for the first AST file loaded. llvm-svn: 174234
2013-02-02 07:45:03 +08:00
}
for (unsigned I = 0, N = Record.size(); I != N; ++I) {
serialization::TypeID ID = getGlobalTypeID(F, Record[I]);
if (!SpecialTypes[I])
SpecialTypes[I] = ID;
// FIXME: If ID && SpecialTypes[I] != ID, do we need a separate
// merge step?
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
break;
case STATISTICS:
TotalNumStatements += Record[0];
TotalNumMacros += Record[1];
TotalLexicalDeclContexts += Record[2];
TotalVisibleDeclContexts += Record[3];
break;
case UNUSED_FILESCOPED_DECLS:
for (unsigned I = 0, N = Record.size(); I != N; ++I)
UnusedFileScopedDecls.push_back(getGlobalDeclID(F, Record[I]));
break;
case DELEGATING_CTORS:
for (unsigned I = 0, N = Record.size(); I != N; ++I)
DelegatingCtorDecls.push_back(getGlobalDeclID(F, Record[I]));
break;
case WEAK_UNDECLARED_IDENTIFIERS:
if (Record.size() % 4 != 0) {
Error("invalid weak identifiers record");
When module umbrellas change, rebuild them With the VFS, it is easy to hit modified umbrellas by overriding the umbrella header, and what we want is to rebuild, not to fail. llvm-svn: 205975
2014-04-11 01:57:43 +08:00
return Failure;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
// FIXME: Ignore weak undeclared identifiers from non-original PCH
// files. This isn't the way to do it :)
WeakUndeclaredIdentifiers.clear();
// Translate the weak, undeclared identifiers into global IDs.
for (unsigned I = 0, N = Record.size(); I < N; /* in loop */) {
WeakUndeclaredIdentifiers.push_back(
getGlobalIdentifierID(F, Record[I++]));
WeakUndeclaredIdentifiers.push_back(
getGlobalIdentifierID(F, Record[I++]));
WeakUndeclaredIdentifiers.push_back(
ReadSourceLocation(F, Record, I).getRawEncoding());
WeakUndeclaredIdentifiers.push_back(Record[I++]);
}
break;
case SELECTOR_OFFSETS: {
update to use the new BitcodeCursor readRecord that takes a StringRef blob parameter, and adopt "advance" in more places. llvm-svn: 172951
2013-01-20 10:38:54 +08:00
F.SelectorOffsets = (const uint32_t *)Blob.data();
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
F.LocalNumSelectors = Record[0];
unsigned LocalBaseSelectorID = Record[1];
F.BaseSelectorID = getTotalNumSelectors();
if (F.LocalNumSelectors > 0) {
// Introduce the global -> local mapping for selectors within this
// module.
GlobalSelectorMap.insert(std::make_pair(getTotalNumSelectors()+1, &F));
// Introduce the local -> global mapping for selectors within this
// module.
F.SelectorRemap.insertOrReplace(
std::make_pair(LocalBaseSelectorID,
F.BaseSelectorID - LocalBaseSelectorID));
Revert most of r215810, which is no longer needed Now that we no longer add mappings when there are no local entities, there is no need to always bump the size of the tables that correspond to ContinuousRangeMaps. llvm-svn: 220208
2014-10-21 00:27:32 +08:00
SelectorsLoaded.resize(SelectorsLoaded.size() + F.LocalNumSelectors);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
break;
}
case METHOD_POOL:
update to use the new BitcodeCursor readRecord that takes a StringRef blob parameter, and adopt "advance" in more places. llvm-svn: 172951
2013-01-20 10:38:54 +08:00
F.SelectorLookupTableData = (const unsigned char *)Blob.data();
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
if (Record[0])
F.SelectorLookupTable
= ASTSelectorLookupTable::Create(
F.SelectorLookupTableData + Record[0],
F.SelectorLookupTableData,
ASTSelectorLookupTrait(*this, F));
TotalNumMethodPoolEntries += Record[1];
break;
case REFERENCED_SELECTOR_POOL:
if (!Record.empty()) {
for (unsigned Idx = 0, N = Record.size() - 1; Idx < N; /* in loop */) {
ReferencedSelectorsData.push_back(getGlobalSelectorID(F,
Record[Idx++]));
ReferencedSelectorsData.push_back(ReadSourceLocation(F, Record, Idx).
getRawEncoding());
}
}
break;
case PP_COUNTER_VALUE:
if (!Record.empty() && Listener)
Listener->ReadCounter(F, Record[0]);
break;
case FILE_SORTED_DECLS:
update to use the new BitcodeCursor readRecord that takes a StringRef blob parameter, and adopt "advance" in more places. llvm-svn: 172951
2013-01-20 10:38:54 +08:00
F.FileSortedDecls = (const DeclID *)Blob.data();
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
F.NumFileSortedDecls = Record[0];
break;
case SOURCE_LOCATION_OFFSETS: {
update to use the new BitcodeCursor readRecord that takes a StringRef blob parameter, and adopt "advance" in more places. llvm-svn: 172951
2013-01-20 10:38:54 +08:00
F.SLocEntryOffsets = (const uint32_t *)Blob.data();
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
F.LocalNumSLocEntries = Record[0];
unsigned SLocSpaceSize = Record[1];
[C++11] Replace llvm::tie with std::tie. llvm-svn: 202639
2014-03-02 21:01:17 +08:00
std::tie(F.SLocEntryBaseID, F.SLocEntryBaseOffset) =
Revert most of r215810, which is no longer needed Now that we no longer add mappings when there are no local entities, there is no need to always bump the size of the tables that correspond to ContinuousRangeMaps. llvm-svn: 220208
2014-10-21 00:27:32 +08:00
SourceMgr.AllocateLoadedSLocEntries(F.LocalNumSLocEntries,
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
SLocSpaceSize);
[modules] If loading a .pcm file would cause us to run out of source locations, attempt to fail more gracefully. (No test; this requires >= 4GB of preprocessed input...) llvm-svn: 244822
2015-08-13 06:25:24 +08:00
if (!F.SLocEntryBaseID) {
Error("ran out of source locations");
break;
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
// Make our entry in the range map. BaseID is negative and growing, so
// we invert it. Because we invert it, though, we need the other end of
// the range.
unsigned RangeStart =
unsigned(-F.SLocEntryBaseID) - F.LocalNumSLocEntries + 1;
GlobalSLocEntryMap.insert(std::make_pair(RangeStart, &F));
F.FirstLoc = SourceLocation::getFromRawEncoding(F.SLocEntryBaseOffset);
// SLocEntryBaseOffset is lower than MaxLoadedOffset and decreasing.
assert((F.SLocEntryBaseOffset & (1U << 31U)) == 0);
GlobalSLocOffsetMap.insert(
std::make_pair(SourceManager::MaxLoadedOffset - F.SLocEntryBaseOffset
- SLocSpaceSize,&F));
// Initialize the remapping table.
// Invalid stays invalid.
Rearrange serialization block order to put decl update emission into the same block as decl and type emission. This allows decl updates include statements and expressions. No functionality change (but the generated PCM files are incompatible with earlier versions of Clang). llvm-svn: 204385
2014-03-21 03:44:17 +08:00
F.SLocRemap.insertOrReplace(std::make_pair(0U, 0));
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
// This module. Base was 2 when being compiled.
Rearrange serialization block order to put decl update emission into the same block as decl and type emission. This allows decl updates include statements and expressions. No functionality change (but the generated PCM files are incompatible with earlier versions of Clang). llvm-svn: 204385
2014-03-21 03:44:17 +08:00
F.SLocRemap.insertOrReplace(std::make_pair(2U,
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
static_cast<int>(F.SLocEntryBaseOffset - 2)));
TotalNumSLocEntries += F.LocalNumSLocEntries;
break;
}
case MODULE_OFFSET_MAP: {
// Additional remapping information.
update to use the new BitcodeCursor readRecord that takes a StringRef blob parameter, and adopt "advance" in more places. llvm-svn: 172951
2013-01-20 10:38:54 +08:00
const unsigned char *Data = (const unsigned char*)Blob.data();
const unsigned char *DataEnd = Data + Blob.size();
Rearrange serialization block order to put decl update emission into the same block as decl and type emission. This allows decl updates include statements and expressions. No functionality change (but the generated PCM files are incompatible with earlier versions of Clang). llvm-svn: 204385
2014-03-21 03:44:17 +08:00
// If we see this entry before SOURCE_LOCATION_OFFSETS, add placeholders.
if (F.SLocRemap.find(0) == F.SLocRemap.end()) {
F.SLocRemap.insert(std::make_pair(0U, 0));
F.SLocRemap.insert(std::make_pair(2U, 1));
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
// Continuous range maps we may be updating in our module.
Don't add ID mappings for offsets with no entities in a module This is a better fix for 'duplicate key' problems in module continuous range maps (vs what I added in r215810) by not adding any mappings at all when there are no local entities. Now it also covers selectors, which were not always being bumped because the record SELECTOR_OFFSET is not always emitted. I'll back out most of r215810 in a future commit, since it should no longer be needed. llvm-svn: 220207
2014-10-21 00:27:30 +08:00
typedef ContinuousRangeMap<uint32_t, int, 2>::Builder
RemapBuilder;
RemapBuilder SLocRemap(F.SLocRemap);
RemapBuilder IdentifierRemap(F.IdentifierRemap);
RemapBuilder MacroRemap(F.MacroRemap);
RemapBuilder PreprocessedEntityRemap(F.PreprocessedEntityRemap);
RemapBuilder SubmoduleRemap(F.SubmoduleRemap);
RemapBuilder SelectorRemap(F.SelectorRemap);
RemapBuilder DeclRemap(F.DeclRemap);
RemapBuilder TypeRemap(F.TypeRemap);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
[modules] Remove unnecessary deserialization of fully-external HeaderFileInfos for all files we've seen in this compilation. llvm-svn: 245881
2015-08-25 05:59:32 +08:00
while (Data < DataEnd) {
Reapply "OnDiskHashTable: Use Endian.h to read little endian ostreams" Committed this by accident before it was done last time. Original message: Rather than rolling our own functions to read little endian data from a buffer, we can use the support in llvm's Endian.h. No functional change. llvm-svn: 205062
2014-03-29 06:03:24 +08:00
using namespace llvm::support;
uint16_t Len = endian::readNext<uint16_t, little, unaligned>(Data);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
StringRef Name = StringRef((const char*)Data, Len);
Data += Len;
ModuleFile *OM = ModuleMgr.lookup(Name);
if (!OM) {
Error("SourceLocation remap refers to unknown module");
When module umbrellas change, rebuild them With the VFS, it is easy to hit modified umbrellas by overriding the umbrella header, and what we want is to rebuild, not to fail. llvm-svn: 205975
2014-04-11 01:57:43 +08:00
return Failure;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
Reapply "OnDiskHashTable: Use Endian.h to read little endian ostreams" Committed this by accident before it was done last time. Original message: Rather than rolling our own functions to read little endian data from a buffer, we can use the support in llvm's Endian.h. No functional change. llvm-svn: 205062
2014-03-29 06:03:24 +08:00
uint32_t SLocOffset =
endian::readNext<uint32_t, little, unaligned>(Data);
uint32_t IdentifierIDOffset =
endian::readNext<uint32_t, little, unaligned>(Data);
uint32_t MacroIDOffset =
endian::readNext<uint32_t, little, unaligned>(Data);
uint32_t PreprocessedEntityIDOffset =
endian::readNext<uint32_t, little, unaligned>(Data);
uint32_t SubmoduleIDOffset =
endian::readNext<uint32_t, little, unaligned>(Data);
uint32_t SelectorIDOffset =
endian::readNext<uint32_t, little, unaligned>(Data);
uint32_t DeclIDOffset =
endian::readNext<uint32_t, little, unaligned>(Data);
uint32_t TypeIndexOffset =
endian::readNext<uint32_t, little, unaligned>(Data);
Don't add ID mappings for offsets with no entities in a module This is a better fix for 'duplicate key' problems in module continuous range maps (vs what I added in r215810) by not adding any mappings at all when there are no local entities. Now it also covers selectors, which were not always being bumped because the record SELECTOR_OFFSET is not always emitted. I'll back out most of r215810 in a future commit, since it should no longer be needed. llvm-svn: 220207
2014-10-21 00:27:30 +08:00
uint32_t None = std::numeric_limits<uint32_t>::max();
auto mapOffset = [&](uint32_t Offset, uint32_t BaseOffset,
RemapBuilder &Remap) {
if (Offset != None)
Remap.insert(std::make_pair(Offset,
static_cast<int>(BaseOffset - Offset)));
};
mapOffset(SLocOffset, OM->SLocEntryBaseOffset, SLocRemap);
mapOffset(IdentifierIDOffset, OM->BaseIdentifierID, IdentifierRemap);
mapOffset(MacroIDOffset, OM->BaseMacroID, MacroRemap);
mapOffset(PreprocessedEntityIDOffset, OM->BasePreprocessedEntityID,
PreprocessedEntityRemap);
mapOffset(SubmoduleIDOffset, OM->BaseSubmoduleID, SubmoduleRemap);
mapOffset(SelectorIDOffset, OM->BaseSelectorID, SelectorRemap);
mapOffset(DeclIDOffset, OM->BaseDeclID, DeclRemap);
mapOffset(TypeIndexOffset, OM->BaseTypeIndex, TypeRemap);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
// Global -> local mappings.
F.GlobalToLocalDeclIDs[OM] = DeclIDOffset;
}
break;
}
case SOURCE_MANAGER_LINE_TABLE:
if (ParseLineTable(F, Record))
When module umbrellas change, rebuild them With the VFS, it is easy to hit modified umbrellas by overriding the umbrella header, and what we want is to rebuild, not to fail. llvm-svn: 205975
2014-04-11 01:57:43 +08:00
return Failure;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
break;
case SOURCE_LOCATION_PRELOADS: {
// Need to transform from the local view (1-based IDs) to the global view,
// which is based off F.SLocEntryBaseID.
if (!F.PreloadSLocEntries.empty()) {
Error("Multiple SOURCE_LOCATION_PRELOADS records in AST file");
When module umbrellas change, rebuild them With the VFS, it is easy to hit modified umbrellas by overriding the umbrella header, and what we want is to rebuild, not to fail. llvm-svn: 205975
2014-04-11 01:57:43 +08:00
return Failure;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
F.PreloadSLocEntries.swap(Record);
break;
}
case EXT_VECTOR_DECLS:
for (unsigned I = 0, N = Record.size(); I != N; ++I)
ExtVectorDecls.push_back(getGlobalDeclID(F, Record[I]));
break;
case VTABLE_USES:
if (Record.size() % 3 != 0) {
Error("Invalid VTABLE_USES record");
When module umbrellas change, rebuild them With the VFS, it is easy to hit modified umbrellas by overriding the umbrella header, and what we want is to rebuild, not to fail. llvm-svn: 205975
2014-04-11 01:57:43 +08:00
return Failure;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
// Later tables overwrite earlier ones.
// FIXME: Modules will have some trouble with this. This is clearly not
// the right way to do this.
VTableUses.clear();
for (unsigned Idx = 0, N = Record.size(); Idx != N; /* In loop */) {
VTableUses.push_back(getGlobalDeclID(F, Record[Idx++]));
VTableUses.push_back(
ReadSourceLocation(F, Record, Idx).getRawEncoding());
VTableUses.push_back(Record[Idx++]);
}
break;
case PENDING_IMPLICIT_INSTANTIATIONS:
if (PendingInstantiations.size() % 2 != 0) {
Error("Invalid existing PendingInstantiations");
When module umbrellas change, rebuild them With the VFS, it is easy to hit modified umbrellas by overriding the umbrella header, and what we want is to rebuild, not to fail. llvm-svn: 205975
2014-04-11 01:57:43 +08:00
return Failure;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
if (Record.size() % 2 != 0) {
Error("Invalid PENDING_IMPLICIT_INSTANTIATIONS block");
When module umbrellas change, rebuild them With the VFS, it is easy to hit modified umbrellas by overriding the umbrella header, and what we want is to rebuild, not to fail. llvm-svn: 205975
2014-04-11 01:57:43 +08:00
return Failure;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) {
PendingInstantiations.push_back(getGlobalDeclID(F, Record[I++]));
PendingInstantiations.push_back(
ReadSourceLocation(F, Record, I).getRawEncoding());
}
break;
case SEMA_DECL_REFS:
C++ modules: don't lose track of a 'namespace std' that is imported from a module. llvm-svn: 192951
2013-10-18 14:54:39 +08:00
if (Record.size() != 2) {
Error("Invalid SEMA_DECL_REFS block");
When module umbrellas change, rebuild them With the VFS, it is easy to hit modified umbrellas by overriding the umbrella header, and what we want is to rebuild, not to fail. llvm-svn: 205975
2014-04-11 01:57:43 +08:00
return Failure;
C++ modules: don't lose track of a 'namespace std' that is imported from a module. llvm-svn: 192951
2013-10-18 14:54:39 +08:00
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
for (unsigned I = 0, N = Record.size(); I != N; ++I)
SemaDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
break;
case PPD_ENTITIES_OFFSETS: {
update to use the new BitcodeCursor readRecord that takes a StringRef blob parameter, and adopt "advance" in more places. llvm-svn: 172951
2013-01-20 10:38:54 +08:00
F.PreprocessedEntityOffsets = (const PPEntityOffset *)Blob.data();
assert(Blob.size() % sizeof(PPEntityOffset) == 0);
F.NumPreprocessedEntities = Blob.size() / sizeof(PPEntityOffset);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
unsigned LocalBasePreprocessedEntityID = Record[0];
unsigned StartingID;
if (!PP.getPreprocessingRecord())
PP.createPreprocessingRecord();
if (!PP.getPreprocessingRecord()->getExternalSource())
PP.getPreprocessingRecord()->SetExternalSource(*this);
StartingID
= PP.getPreprocessingRecord()
Revert most of r215810, which is no longer needed Now that we no longer add mappings when there are no local entities, there is no need to always bump the size of the tables that correspond to ContinuousRangeMaps. llvm-svn: 220208
2014-10-21 00:27:32 +08:00
->allocateLoadedEntities(F.NumPreprocessedEntities);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
F.BasePreprocessedEntityID = StartingID;
if (F.NumPreprocessedEntities > 0) {
// Introduce the global -> local mapping for preprocessed entities in
// this module.
GlobalPreprocessedEntityMap.insert(std::make_pair(StartingID, &F));
// Introduce the local -> global mapping for preprocessed entities in
// this module.
F.PreprocessedEntityRemap.insertOrReplace(
std::make_pair(LocalBasePreprocessedEntityID,
F.BasePreprocessedEntityID - LocalBasePreprocessedEntityID));
}
break;
}
case DECL_UPDATE_OFFSETS: {
if (Record.size() % 2 != 0) {
Error("invalid DECL_UPDATE_OFFSETS block in AST file");
When module umbrellas change, rebuild them With the VFS, it is easy to hit modified umbrellas by overriding the umbrella header, and what we want is to rebuild, not to fail. llvm-svn: 205975
2014-04-11 01:57:43 +08:00
return Failure;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
When a module completes the definition of a class template specialization imported from another module, emit an update record, rather than using the broken decl rewriting mechanism. If multiple modules do this, merge the definitions together, much as we would if they were separate declarations. llvm-svn: 206680
2014-04-19 11:48:30 +08:00
for (unsigned I = 0, N = Record.size(); I != N; I += 2) {
GlobalDeclID ID = getGlobalDeclID(F, Record[I]);
DeclUpdateOffsets[ID].push_back(std::make_pair(&F, Record[I + 1]));
// If we've already loaded the decl, perform the updates when we finish
// loading this block.
if (Decl *D = GetExistingDecl(ID))
PendingUpdateRecords.push_back(std::make_pair(ID, D));
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
break;
}
case DECL_REPLACEMENTS: {
if (Record.size() % 3 != 0) {
Error("invalid DECL_REPLACEMENTS block in AST file");
When module umbrellas change, rebuild them With the VFS, it is easy to hit modified umbrellas by overriding the umbrella header, and what we want is to rebuild, not to fail. llvm-svn: 205975
2014-04-11 01:57:43 +08:00
return Failure;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
for (unsigned I = 0, N = Record.size(); I != N; I += 3)
ReplacedDecls[getGlobalDeclID(F, Record[I])]
= ReplacedDeclInfo(&F, Record[I+1], Record[I+2]);
break;
}
case OBJC_CATEGORIES_MAP: {
if (F.LocalNumObjCCategoriesInMap != 0) {
Error("duplicate OBJC_CATEGORIES_MAP record in AST file");
When module umbrellas change, rebuild them With the VFS, it is easy to hit modified umbrellas by overriding the umbrella header, and what we want is to rebuild, not to fail. llvm-svn: 205975
2014-04-11 01:57:43 +08:00
return Failure;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
F.LocalNumObjCCategoriesInMap = Record[0];
update to use the new BitcodeCursor readRecord that takes a StringRef blob parameter, and adopt "advance" in more places. llvm-svn: 172951
2013-01-20 10:38:54 +08:00
F.ObjCCategoriesMap = (const ObjCCategoriesInfo *)Blob.data();
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
break;
}
case OBJC_CATEGORIES:
F.ObjCCategories.swap(Record);
break;
[modules] Deserialize CXXCtorInitializer list for a constructor lazily. Previously we'd deserialize the list of mem-initializers for a constructor when we deserialized the declaration of the constructor. That could trigger a significant amount of unnecessary work (pulling in all base classes recursively, for a start) and was causing problems for the modules buildbot due to cyclic deserializations. We now deserialize these on demand. This creates a certain amount of duplication with the handling of CXXBaseSpecifiers; I'll look into reducing that next. llvm-svn: 233052
2015-03-24 14:36:48 +08:00
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
case CXX_BASE_SPECIFIER_OFFSETS: {
if (F.LocalNumCXXBaseSpecifiers != 0) {
Error("duplicate CXX_BASE_SPECIFIER_OFFSETS record in AST file");
When module umbrellas change, rebuild them With the VFS, it is easy to hit modified umbrellas by overriding the umbrella header, and what we want is to rebuild, not to fail. llvm-svn: 205975
2014-04-11 01:57:43 +08:00
return Failure;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
[modules] Deserialize CXXCtorInitializer list for a constructor lazily. Previously we'd deserialize the list of mem-initializers for a constructor when we deserialized the declaration of the constructor. That could trigger a significant amount of unnecessary work (pulling in all base classes recursively, for a start) and was causing problems for the modules buildbot due to cyclic deserializations. We now deserialize these on demand. This creates a certain amount of duplication with the handling of CXXBaseSpecifiers; I'll look into reducing that next. llvm-svn: 233052
2015-03-24 14:36:48 +08:00
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
F.LocalNumCXXBaseSpecifiers = Record[0];
update to use the new BitcodeCursor readRecord that takes a StringRef blob parameter, and adopt "advance" in more places. llvm-svn: 172951
2013-01-20 10:38:54 +08:00
F.CXXBaseSpecifiersOffsets = (const uint32_t *)Blob.data();
[modules] Deserialize CXXCtorInitializer list for a constructor lazily. Previously we'd deserialize the list of mem-initializers for a constructor when we deserialized the declaration of the constructor. That could trigger a significant amount of unnecessary work (pulling in all base classes recursively, for a start) and was causing problems for the modules buildbot due to cyclic deserializations. We now deserialize these on demand. This creates a certain amount of duplication with the handling of CXXBaseSpecifiers; I'll look into reducing that next. llvm-svn: 233052
2015-03-24 14:36:48 +08:00
break;
}
case CXX_CTOR_INITIALIZERS_OFFSETS: {
if (F.LocalNumCXXCtorInitializers != 0) {
Error("duplicate CXX_CTOR_INITIALIZERS_OFFSETS record in AST file");
return Failure;
}
F.LocalNumCXXCtorInitializers = Record[0];
F.CXXCtorInitializersOffsets = (const uint32_t *)Blob.data();
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
break;
}
case DIAG_PRAGMA_MAPPINGS:
if (F.PragmaDiagMappings.empty())
F.PragmaDiagMappings.swap(Record);
else
F.PragmaDiagMappings.insert(F.PragmaDiagMappings.end(),
Record.begin(), Record.end());
break;
case CUDA_SPECIAL_DECL_REFS:
// Later tables overwrite earlier ones.
// FIXME: Modules will have trouble with this.
CUDASpecialDeclRefs.clear();
for (unsigned I = 0, N = Record.size(); I != N; ++I)
CUDASpecialDeclRefs.push_back(getGlobalDeclID(F, Record[I]));
break;
case HEADER_SEARCH_TABLE: {
update to use the new BitcodeCursor readRecord that takes a StringRef blob parameter, and adopt "advance" in more places. llvm-svn: 172951
2013-01-20 10:38:54 +08:00
F.HeaderFileInfoTableData = Blob.data();
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
F.LocalNumHeaderFileInfos = Record[1];
if (Record[0]) {
F.HeaderFileInfoTable
= HeaderFileInfoLookupTable::Create(
(const unsigned char *)F.HeaderFileInfoTableData + Record[0],
(const unsigned char *)F.HeaderFileInfoTableData,
HeaderFileInfoTrait(*this, F,
&PP.getHeaderSearchInfo(),
update to use the new BitcodeCursor readRecord that takes a StringRef blob parameter, and adopt "advance" in more places. llvm-svn: 172951
2013-01-20 10:38:54 +08:00
Blob.data() + Record[2]));
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
PP.getHeaderSearchInfo().SetExternalSource(this);
if (!PP.getHeaderSearchInfo().getExternalLookup())
PP.getHeaderSearchInfo().SetExternalLookup(this);
}
break;
}
case FP_PRAGMA_OPTIONS:
// Later tables overwrite earlier ones.
FPPragmaOptions.swap(Record);
break;
case OPENCL_EXTENSIONS:
// Later tables overwrite earlier ones.
OpenCLExtensions.swap(Record);
break;
case TENTATIVE_DEFINITIONS:
for (unsigned I = 0, N = Record.size(); I != N; ++I)
TentativeDefinitions.push_back(getGlobalDeclID(F, Record[I]));
break;
case KNOWN_NAMESPACES:
for (unsigned I = 0, N = Record.size(); I != N; ++I)
KnownNamespaces.push_back(getGlobalDeclID(F, Record[I]));
break;
Preserve Sema::UndefinedInternals across PCH boundaries. Fixes -Wundefined-internal warnings with PCH. llvm-svn: 173538
2013-01-26 08:35:08 +08:00
Add a new -Wundefined-inline warning for inline functions which are used but not defined. Fixes PR14993! llvm-svn: 174158
2013-02-01 16:13:20 +08:00
case UNDEFINED_BUT_USED:
if (UndefinedButUsed.size() % 2 != 0) {
Error("Invalid existing UndefinedButUsed");
When module umbrellas change, rebuild them With the VFS, it is easy to hit modified umbrellas by overriding the umbrella header, and what we want is to rebuild, not to fail. llvm-svn: 205975
2014-04-11 01:57:43 +08:00
return Failure;
Preserve Sema::UndefinedInternals across PCH boundaries. Fixes -Wundefined-internal warnings with PCH. llvm-svn: 173538
2013-01-26 08:35:08 +08:00
}
if (Record.size() % 2 != 0) {
Add a new -Wundefined-inline warning for inline functions which are used but not defined. Fixes PR14993! llvm-svn: 174158
2013-02-01 16:13:20 +08:00
Error("invalid undefined-but-used record");
When module umbrellas change, rebuild them With the VFS, it is easy to hit modified umbrellas by overriding the umbrella header, and what we want is to rebuild, not to fail. llvm-svn: 205975
2014-04-11 01:57:43 +08:00
return Failure;
Preserve Sema::UndefinedInternals across PCH boundaries. Fixes -Wundefined-internal warnings with PCH. llvm-svn: 173538
2013-01-26 08:35:08 +08:00
}
for (unsigned I = 0, N = Record.size(); I != N; /* in loop */) {
Add a new -Wundefined-inline warning for inline functions which are used but not defined. Fixes PR14993! llvm-svn: 174158
2013-02-01 16:13:20 +08:00
UndefinedButUsed.push_back(getGlobalDeclID(F, Record[I++]));
UndefinedButUsed.push_back(
Preserve Sema::UndefinedInternals across PCH boundaries. Fixes -Wundefined-internal warnings with PCH. llvm-svn: 173538
2013-01-26 08:35:08 +08:00
ReadSourceLocation(F, Record, I).getRawEncoding());
}
break;
Detect uses of mismatching forms of 'new' and 'delete' Emit warning when operand to `delete` is allocated with `new[]` or operand to `delete[]` is allocated with `new`. rev 2 update: `getNewExprFromInitListOrExpr` should return `dyn_cast_or_null` instead of `dyn_cast`, since `E` might be null. Reviewers: rtrieu, jordan_rose, rsmith Subscribers: majnemer, cfe-commits Differential Revision: http://reviews.llvm.org/D4661 llvm-svn: 237608
2015-05-19 03:59:11 +08:00
case DELETE_EXPRS_TO_ANALYZE:
for (unsigned I = 0, N = Record.size(); I != N;) {
DelayedDeleteExprs.push_back(getGlobalDeclID(F, Record[I++]));
const uint64_t Count = Record[I++];
DelayedDeleteExprs.push_back(Count);
for (uint64_t C = 0; C < Count; ++C) {
DelayedDeleteExprs.push_back(ReadSourceLocation(F, Record, I).getRawEncoding());
bool IsArrayForm = Record[I++] == 1;
DelayedDeleteExprs.push_back(IsArrayForm);
}
}
break;
Preserve Sema::UndefinedInternals across PCH boundaries. Fixes -Wundefined-internal warnings with PCH. llvm-svn: 173538
2013-01-26 08:35:08 +08:00
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
case IMPORTED_MODULES: {
[modules] Initial support for explicitly loading .pcm files. Implicit module builds are not well-suited to a lot of build systems. In particular, they fare badly in distributed build systems, and they lead to build artifacts that are not tracked as part of the usual dependency management process. This change allows explicitly-built module files (which are already supported through the -emit-module flag) to be explicitly loaded into a build, allowing build systems to opt to manage module builds and dependencies themselves. This is only the first step in supporting such configurations, and it should be considered experimental and subject to change or removal for now. llvm-svn: 220359
2014-10-22 10:05:46 +08:00
if (F.Kind != MK_ImplicitModule && F.Kind != MK_ExplicitModule) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
// If we aren't loading a module (which has its own exports), make
// all of the imported modules visible.
// FIXME: Deal with macros-only imports.
PR19215: When writing/reading a PCH that imported a module, store the location at which that PCH imported each visible submodule of the module. Such locations are needed when synthesizing macro directives resulting from the import. llvm-svn: 204417
2014-03-21 08:33:59 +08:00
for (unsigned I = 0, N = Record.size(); I != N; /**/) {
unsigned GlobalID = getGlobalSubmoduleID(F, Record[I++]);
SourceLocation Loc = ReadSourceLocation(F, Record, I);
if (GlobalID)
Fixing code that doesn't compile in MSVC 2012 (but does in MSVC 2013) from r204417 and related commits. llvm-svn: 204471
2014-03-21 23:22:56 +08:00
ImportedModules.push_back(ImportedSubmodule(GlobalID, Loc));
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
}
break;
}
case MACRO_OFFSET: {
if (F.LocalNumMacros != 0) {
Error("duplicate MACRO_OFFSET record in AST file");
When module umbrellas change, rebuild them With the VFS, it is easy to hit modified umbrellas by overriding the umbrella header, and what we want is to rebuild, not to fail. llvm-svn: 205975
2014-04-11 01:57:43 +08:00
return Failure;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
update to use the new BitcodeCursor readRecord that takes a StringRef blob parameter, and adopt "advance" in more places. llvm-svn: 172951
2013-01-20 10:38:54 +08:00
F.MacroOffsets = (const uint32_t *)Blob.data();
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
F.LocalNumMacros = Record[0];
unsigned LocalBaseMacroID = Record[1];
F.BaseMacroID = getTotalNumMacros();
if (F.LocalNumMacros > 0) {
// Introduce the global -> local mapping for macros within this module.
GlobalMacroMap.insert(std::make_pair(getTotalNumMacros() + 1, &F));
// Introduce the local -> global mapping for macros within this module.
F.MacroRemap.insertOrReplace(
std::make_pair(LocalBaseMacroID,
F.BaseMacroID - LocalBaseMacroID));
Revert most of r215810, which is no longer needed Now that we no longer add mappings when there are no local entities, there is no need to always bump the size of the tables that correspond to ContinuousRangeMaps. llvm-svn: 220208
2014-10-21 00:27:32 +08:00
MacrosLoaded.resize(MacrosLoaded.size() + F.LocalNumMacros);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
break;
}
PR9992: Serialize and deserialize the token sequence for a function template in -fdelayed-template-parsing mode. Patch by Will Wilson! llvm-svn: 187916
2013-08-08 05:41:30 +08:00
case LATE_PARSED_TEMPLATE: {
LateParsedTemplates.append(Record.begin(), Record.end());
break;
}
Implemented support for "pragma clang optimize on/off", based on attribute 'optnone'. This patch implements support for selectively disabling optimizations on a range of function definitions through a pragma. The implementation is that all function definitions in the range are decorated with attribute 'optnone'. #pragma clang optimize off // All function definitions in here are decorated with 'optnone'. #pragma clang optimize on // Compilation resumes as normal. llvm-svn: 209510
2014-05-23 20:13:25 +08:00
case OPTIMIZE_PRAGMA_OPTIONS:
if (Record.size() != 1) {
Error("invalid pragma optimize record");
return Failure;
}
OptimizeOffPragmaLocation = ReadSourceLocation(F, Record[0]);
break;
Add -Wunused-local-typedef, a warning that finds unused local typedefs. The warning warns on TypedefNameDecls -- typedefs and C++11 using aliases -- that are !isReferenced(). Since the isReferenced() bit on TypedefNameDecls wasn't used for anything before this warning it wasn't always set correctly, so this patch also adds a few missing MarkAnyDeclReferenced() calls in various places for TypedefNameDecls. This is made a bit complicated due to local typedefs possibly being used only after their local scope has closed. Consider: template <class T> void template_fun(T t) { typename T::Foo s3foo; // YYY (void)s3foo; } void template_fun_user() { struct Local { typedef int Foo; // XXX } p; template_fun(p); } Here the typedef in XXX is only used at end-of-translation unit, when YYY in template_fun() gets instantiated. To handle this, typedefs that are unused when their scope exits are added to a set of potentially unused typedefs, and that set gets checked at end-of-TU. Typedefs that are still unused at that point then get warned on. There's also serialization code for this set, so that the warning works with precompiled headers and modules. For modules, the warning is emitted when the module is built, for precompiled headers each time the header gets used. Finally, consider a function using C++14 auto return types to return a local type defined in a header: auto f() { struct S { typedef int a; }; return S(); } Here, the typedef escapes its local scope and could be used by only some translation units including the header. To not warn on this, add a RecursiveASTVisitor that marks all delcs on local types returned from auto functions as referenced. (Except if it's a function with internal linkage, or the decls are private and the local type has no friends -- in these cases, it _is_ safe to warn.) Several of the included testcases (most of the interesting ones) were provided by Richard Smith. (gcc's spelling -Wunused-local-typedefs is supported as an alias for this warning.) llvm-svn: 217298
2014-09-06 09:25:55 +08:00
case UNUSED_LOCAL_TYPEDEF_NAME_CANDIDATES:
for (unsigned I = 0, N = Record.size(); I != N; ++I)
UnusedLocalTypedefNameCandidates.push_back(
getGlobalDeclID(F, Record[I]));
break;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
}
}
Verify all the module map files for a pcm are the same on load We already verified the primary module map file (either the one that defines the top-level module, or the one that allows inferring it if it is an inferred framework module). Now we also verify any other module map files that define submodules, such as when there is a module.private.modulemap file. llvm-svn: 215455
2014-08-13 00:42:33 +08:00
ASTReader::ASTReadResult
ASTReader::ReadModuleMapFileBlock(RecordData &Record, ModuleFile &F,
const ModuleFile *ImportedBy,
unsigned ClientLoadCapabilities) {
unsigned Idx = 0;
[modules] Instead of storing absolute paths in a .pcm file, store the path to the root of the module and use paths relative to that directory wherever possible. This is a step towards allowing explicit modules to be relocated without being rebuilt, which is important for some kinds of distributed builds, for good paths in diagnostics, and for appropriate .d output. This is a recommit of r223443, reverted in r223465; when joining together imported file paths, we now use the system's separator rather than always using '/'. This avoids path mismatches between the original module build and the module user on Windows (at least, in some cases). A more comprehensive fix will follow. llvm-svn: 223539
2014-12-06 06:42:13 +08:00
F.ModuleMapPath = ReadPath(F, Record, Idx);
Verify all the module map files for a pcm are the same on load We already verified the primary module map file (either the one that defines the top-level module, or the one that allows inferring it if it is an inferred framework module). Now we also verify any other module map files that define submodules, such as when there is a module.private.modulemap file. llvm-svn: 215455
2014-08-13 00:42:33 +08:00
[modules] Initial support for explicitly loading .pcm files. Implicit module builds are not well-suited to a lot of build systems. In particular, they fare badly in distributed build systems, and they lead to build artifacts that are not tracked as part of the usual dependency management process. This change allows explicitly-built module files (which are already supported through the -emit-module flag) to be explicitly loaded into a build, allowing build systems to opt to manage module builds and dependencies themselves. This is only the first step in supporting such configurations, and it should be considered experimental and subject to change or removal for now. llvm-svn: 220359
2014-10-22 10:05:46 +08:00
if (F.Kind == MK_ExplicitModule) {
// For an explicitly-loaded module, we don't care whether the original
// module map file exists or matches.
return Success;
}
Verify all the module map files for a pcm are the same on load We already verified the primary module map file (either the one that defines the top-level module, or the one that allows inferring it if it is an inferred framework module). Now we also verify any other module map files that define submodules, such as when there is a module.private.modulemap file. llvm-svn: 215455
2014-08-13 00:42:33 +08:00
// Try to resolve ModuleName in the current header search context and
// verify that it is found in the same module map file as we saved. If the
// top-level AST file is a main file, skip this check because there is no
// usable header search context.
assert(!F.ModuleName.empty() &&
[modules] Initial support for explicitly loading .pcm files. Implicit module builds are not well-suited to a lot of build systems. In particular, they fare badly in distributed build systems, and they lead to build artifacts that are not tracked as part of the usual dependency management process. This change allows explicitly-built module files (which are already supported through the -emit-module flag) to be explicitly loaded into a build, allowing build systems to opt to manage module builds and dependencies themselves. This is only the first step in supporting such configurations, and it should be considered experimental and subject to change or removal for now. llvm-svn: 220359
2014-10-22 10:05:46 +08:00
"MODULE_NAME should come before MODULE_MAP_FILE");
if (F.Kind == MK_ImplicitModule &&
(*ModuleMgr.begin())->Kind != MK_MainFile) {
// An implicitly-loaded module file should have its module listed in some
// module map file that we've already loaded.
Verify all the module map files for a pcm are the same on load We already verified the primary module map file (either the one that defines the top-level module, or the one that allows inferring it if it is an inferred framework module). Now we also verify any other module map files that define submodules, such as when there is a module.private.modulemap file. llvm-svn: 215455
2014-08-13 00:42:33 +08:00
Module *M = PP.getHeaderSearchInfo().lookupModule(F.ModuleName);
[modules] Initial support for explicitly loading .pcm files. Implicit module builds are not well-suited to a lot of build systems. In particular, they fare badly in distributed build systems, and they lead to build artifacts that are not tracked as part of the usual dependency management process. This change allows explicitly-built module files (which are already supported through the -emit-module flag) to be explicitly loaded into a build, allowing build systems to opt to manage module builds and dependencies themselves. This is only the first step in supporting such configurations, and it should be considered experimental and subject to change or removal for now. llvm-svn: 220359
2014-10-22 10:05:46 +08:00
auto &Map = PP.getHeaderSearchInfo().getModuleMap();
const FileEntry *ModMap = M ? Map.getModuleMapFileForUniquing(M) : nullptr;
if (!ModMap) {
Verify all the module map files for a pcm are the same on load We already verified the primary module map file (either the one that defines the top-level module, or the one that allows inferring it if it is an inferred framework module). Now we also verify any other module map files that define submodules, such as when there is a module.private.modulemap file. llvm-svn: 215455
2014-08-13 00:42:33 +08:00
assert(ImportedBy && "top-level import should be verified");
[modules] PR22534: Load files specified by -fmodule-file= eagerly. In particular, this avoids the need to re-parse module map files when using such a module. llvm-svn: 244416
2015-08-09 16:48:41 +08:00
if ((ClientLoadCapabilities & ARR_OutOfDate) == 0) {
if (auto *ASTFE = M ? M->getASTFile() : nullptr)
// This module was defined by an imported (explicit) module.
Diag(diag::err_module_file_conflict) << F.ModuleName << F.FileName
<< ASTFE->getName();
else
// This module was built with a different module map.
Diag(diag::err_imported_module_not_found)
<< F.ModuleName << F.FileName << ImportedBy->FileName
<< F.ModuleMapPath;
}
return OutOfDate;
Verify all the module map files for a pcm are the same on load We already verified the primary module map file (either the one that defines the top-level module, or the one that allows inferring it if it is an inferred framework module). Now we also verify any other module map files that define submodules, such as when there is a module.private.modulemap file. llvm-svn: 215455
2014-08-13 00:42:33 +08:00
}
[modules] Initial support for explicitly loading .pcm files. Implicit module builds are not well-suited to a lot of build systems. In particular, they fare badly in distributed build systems, and they lead to build artifacts that are not tracked as part of the usual dependency management process. This change allows explicitly-built module files (which are already supported through the -emit-module flag) to be explicitly loaded into a build, allowing build systems to opt to manage module builds and dependencies themselves. This is only the first step in supporting such configurations, and it should be considered experimental and subject to change or removal for now. llvm-svn: 220359
2014-10-22 10:05:46 +08:00
assert(M->Name == F.ModuleName && "found module with different name");
Verify all the module map files for a pcm are the same on load We already verified the primary module map file (either the one that defines the top-level module, or the one that allows inferring it if it is an inferred framework module). Now we also verify any other module map files that define submodules, such as when there is a module.private.modulemap file. llvm-svn: 215455
2014-08-13 00:42:33 +08:00
// Check the primary module map file.
const FileEntry *StoredModMap = FileMgr.getFile(F.ModuleMapPath);
if (StoredModMap == nullptr || StoredModMap != ModMap) {
assert(ModMap && "found module is missing module map file");
assert(ImportedBy && "top-level import should be verified");
if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
Diag(diag::err_imported_module_modmap_changed)
<< F.ModuleName << ImportedBy->FileName
<< ModMap->getName() << F.ModuleMapPath;
return OutOfDate;
}
llvm::SmallPtrSet<const FileEntry *, 1> AdditionalStoredMaps;
for (unsigned I = 0, N = Record[Idx++]; I < N; ++I) {
// FIXME: we should use input files rather than storing names.
[modules] Instead of storing absolute paths in a .pcm file, store the path to the root of the module and use paths relative to that directory wherever possible. This is a step towards allowing explicit modules to be relocated without being rebuilt, which is important for some kinds of distributed builds, for good paths in diagnostics, and for appropriate .d output. This is a recommit of r223443, reverted in r223465; when joining together imported file paths, we now use the system's separator rather than always using '/'. This avoids path mismatches between the original module build and the module user on Windows (at least, in some cases). A more comprehensive fix will follow. llvm-svn: 223539
2014-12-06 06:42:13 +08:00
std::string Filename = ReadPath(F, Record, Idx);
Verify all the module map files for a pcm are the same on load We already verified the primary module map file (either the one that defines the top-level module, or the one that allows inferring it if it is an inferred framework module). Now we also verify any other module map files that define submodules, such as when there is a module.private.modulemap file. llvm-svn: 215455
2014-08-13 00:42:33 +08:00
const FileEntry *F =
FileMgr.getFile(Filename, false, false);
if (F == nullptr) {
if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
Error("could not find file '" + Filename +"' referenced by AST file");
return OutOfDate;
}
AdditionalStoredMaps.insert(F);
}
// Check any additional module map files (e.g. module.private.modulemap)
// that are not in the pcm.
if (auto *AdditionalModuleMaps = Map.getAdditionalModuleMapFiles(M)) {
for (const FileEntry *ModMap : *AdditionalModuleMaps) {
// Remove files that match
// Note: SmallPtrSet::erase is really remove
if (!AdditionalStoredMaps.erase(ModMap)) {
if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
Diag(diag::err_module_different_modmap)
<< F.ModuleName << /*new*/0 << ModMap->getName();
return OutOfDate;
}
}
}
// Check any additional module map files that are in the pcm, but not
// found in header search. Cases that match are already removed.
for (const FileEntry *ModMap : AdditionalStoredMaps) {
if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
Diag(diag::err_module_different_modmap)
<< F.ModuleName << /*not new*/1 << ModMap->getName();
return OutOfDate;
}
}
if (Listener)
Listener->ReadModuleMapFile(F.ModuleMapPath);
return Success;
}
Order the methods in the global method pool based on when they become visible, not when they become deserialized <rdar://problem/13203033>. llvm-svn: 175018
2013-02-13 07:36:21 +08:00
/// \brief Move the given method to the back of the global list of methods.
static void moveMethodToBackOfGlobalList(Sema &S, ObjCMethodDecl *Method) {
// Find the entry for this selector in the method pool.
Sema::GlobalMethodPool::iterator Known
= S.MethodPool.find(Method->getSelector());
if (Known == S.MethodPool.end())
return;
// Retrieve the appropriate method list.
ObjCMethodList &Start = Method->isInstanceMethod()? Known->second.first
: Known->second.second;
bool Found = false;
Enhance the ObjC global method pool to record whether there were 0, 1, or >= 2 methods (with a particular selector) inside categories. This is done by extending ObjCMethodList (which is only used by the global method pool) to have 2 extra bits of information. We will later take advantage of this info in global method pool for the overridden methods calculation. llvm-svn: 179652
2013-04-17 08:08:58 +08:00
for (ObjCMethodList *List = &Start; List; List = List->getNext()) {
Order the methods in the global method pool based on when they become visible, not when they become deserialized <rdar://problem/13203033>. llvm-svn: 175018
2013-02-13 07:36:21 +08:00
if (!Found) {
Address review feedback on r221933. Remove ObjCMethodList::Count, instead store a "has more than one decl" bit in the low bit of the ObjCMethodDecl pointer, using a PointerIntPair. Most of this patch is replacing ".Method" with ".getMethod()". No intended behavior change. llvm-svn: 224876
2014-12-27 11:58:08 +08:00
if (List->getMethod() == Method) {
Order the methods in the global method pool based on when they become visible, not when they become deserialized <rdar://problem/13203033>. llvm-svn: 175018
2013-02-13 07:36:21 +08:00
Found = true;
} else {
// Keep searching.
continue;
}
}
Enhance the ObjC global method pool to record whether there were 0, 1, or >= 2 methods (with a particular selector) inside categories. This is done by extending ObjCMethodList (which is only used by the global method pool) to have 2 extra bits of information. We will later take advantage of this info in global method pool for the overridden methods calculation. llvm-svn: 179652
2013-04-17 08:08:58 +08:00
if (List->getNext())
Address review feedback on r221933. Remove ObjCMethodList::Count, instead store a "has more than one decl" bit in the low bit of the ObjCMethodDecl pointer, using a PointerIntPair. Most of this patch is replacing ".Method" with ".getMethod()". No intended behavior change. llvm-svn: 224876
2014-12-27 11:58:08 +08:00
List->setMethod(List->getNext()->getMethod());
Order the methods in the global method pool based on when they become visible, not when they become deserialized <rdar://problem/13203033>. llvm-svn: 175018
2013-02-13 07:36:21 +08:00
else
Address review feedback on r221933. Remove ObjCMethodList::Count, instead store a "has more than one decl" bit in the low bit of the ObjCMethodDecl pointer, using a PointerIntPair. Most of this patch is replacing ".Method" with ".getMethod()". No intended behavior change. llvm-svn: 224876
2014-12-27 11:58:08 +08:00
List->setMethod(Method);
Order the methods in the global method pool based on when they become visible, not when they become deserialized <rdar://problem/13203033>. llvm-svn: 175018
2013-02-13 07:36:21 +08:00
}
}
[modules] Remove the now-redundant import of all pending macros at the end of building a module. Since we now track module macros separately from their visibility state, this is no longer necessary. llvm-svn: 235648
2015-04-24 05:20:19 +08:00
void ASTReader::makeNamesVisible(const HiddenNames &Names, Module *Owner) {
[modules] Remove dead code from Module for tracking macro import locations. llvm-svn: 236376
2015-05-02 10:08:26 +08:00
assert(Owner->NameVisibility != Module::Hidden && "nothing to make visible?");
[modules] Stop trying to fake up a linear MacroDirective history. Modules builds fundamentally have a non-linear macro history. In the interest of better source fidelity, represent the macro definition information faithfully: we have a linear macro directive history within each module, and at any point we have a unique "latest" local macro directive and a collection of visible imported directives. This also removes the attendent complexity of attempting to create a correct MacroDirective history (which we got wrong in the general case). No functionality change intended. llvm-svn: 236176
2015-04-30 07:20:19 +08:00
for (Decl *D : Names) {
If a module A exports a macro M, and a module B imports that macro and #undef's it, importers of B should not see the macro. This is complicated by the fact that A's macro could also be visible through a different path. The rules (as hashed out on cfe-commits) are included as a documentation update in this change. With this, the number of regressions in libc++'s testsuite when modules are enabled drops from 47 to 7. Those remaining 7 are also macro-related, and are due to remaining bugs in this change (in particular, the handling of submodules is imperfect). llvm-svn: 202560
2014-03-01 08:08:04 +08:00
bool wasHidden = D->Hidden;
D->Hidden = false;
if (wasHidden && SemaObj) {
if (ObjCMethodDecl *Method = dyn_cast<ObjCMethodDecl>(D)) {
moveMethodToBackOfGlobalList(*SemaObj, Method);
Order the methods in the global method pool based on when they become visible, not when they become deserialized <rdar://problem/13203033>. llvm-svn: 175018
2013-02-13 07:36:21 +08:00
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
}
}
If a module A exports a macro M, and a module B imports that macro and #undef's it, importers of B should not see the macro. This is complicated by the fact that A's macro could also be visible through a different path. The rules (as hashed out on cfe-commits) are included as a documentation update in this change. With this, the number of regressions in libc++'s testsuite when modules are enabled drops from 47 to 7. Those remaining 7 are also macro-related, and are due to remaining bugs in this change (in particular, the handling of submodules is imperfect). llvm-svn: 202560
2014-03-01 08:08:04 +08:00
void ASTReader::makeModuleVisible(Module *Mod,
For ModuleLoader::makeModuleVisible() also pass the source location where the module import occurred. llvm-svn: 174191
2013-02-02 00:36:12 +08:00
Module::NameVisibilityKind NameVisibility,
[modules] Start moving the module visibility information off the Module itself. It has no place there; it's not a property of the Module, and it makes restoring the visibility set when we leave a submodule more difficult. llvm-svn: 236300
2015-05-01 09:53:09 +08:00
SourceLocation ImportLoc) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
llvm::SmallPtrSet<Module *, 4> Visited;
Remove useless 'llvm::' qualifier from names like StringRef and others that are brought into 'clang' namespace by clang/Basic/LLVM.h llvm-svn: 172323
2013-01-13 03:30:44 +08:00
SmallVector<Module *, 4> Stack;
Use pop_back_val() instead of both back() and pop_back(). No functionality change intended. llvm-svn: 189112
2013-08-24 00:11:15 +08:00
Stack.push_back(Mod);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
while (!Stack.empty()) {
Use pop_back_val() instead of both back() and pop_back(). No functionality change intended. llvm-svn: 189112
2013-08-24 00:11:15 +08:00
Mod = Stack.pop_back_val();
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
if (NameVisibility <= Mod->NameVisibility) {
Use pop_back_val() instead of both back() and pop_back(). No functionality change intended. llvm-svn: 189112
2013-08-24 00:11:15 +08:00
// This module already has this level of visibility (or greater), so
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
// there is nothing more to do.
continue;
}
If a module A exports a macro M, and a module B imports that macro and #undef's it, importers of B should not see the macro. This is complicated by the fact that A's macro could also be visible through a different path. The rules (as hashed out on cfe-commits) are included as a documentation update in this change. With this, the number of regressions in libc++'s testsuite when modules are enabled drops from 47 to 7. Those remaining 7 are also macro-related, and are due to remaining bugs in this change (in particular, the handling of submodules is imperfect). llvm-svn: 202560
2014-03-01 08:08:04 +08:00
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
if (!Mod->isAvailable()) {
// Modules that aren't available cannot be made visible.
continue;
}
// Update the module's name visibility.
Mod->NameVisibility = NameVisibility;
If a module A exports a macro M, and a module B imports that macro and #undef's it, importers of B should not see the macro. This is complicated by the fact that A's macro could also be visible through a different path. The rules (as hashed out on cfe-commits) are included as a documentation update in this change. With this, the number of regressions in libc++'s testsuite when modules are enabled drops from 47 to 7. Those remaining 7 are also macro-related, and are due to remaining bugs in this change (in particular, the handling of submodules is imperfect). llvm-svn: 202560
2014-03-01 08:08:04 +08:00
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
// If we've already deserialized any names from this module,
// mark them as visible.
HiddenNamesMapType::iterator Hidden = HiddenNamesMap.find(Mod);
if (Hidden != HiddenNamesMap.end()) {
[modules] Fix some of the confusion when computing the override set for a macro introduced by finalization. This is still not entirely correct; more fixes to follow. llvm-svn: 213498
2014-07-21 12:10:40 +08:00
auto HiddenNames = std::move(*Hidden);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
HiddenNamesMap.erase(Hidden);
[modules] Remove the now-redundant import of all pending macros at the end of building a module. Since we now track module macros separately from their visibility state, this is no longer necessary. llvm-svn: 235648
2015-04-24 05:20:19 +08:00
makeNamesVisible(HiddenNames.second, HiddenNames.first);
[modules] Fix some of the confusion when computing the override set for a macro introduced by finalization. This is still not entirely correct; more fixes to follow. llvm-svn: 213498
2014-07-21 12:10:40 +08:00
assert(HiddenNamesMap.find(Mod) == HiddenNamesMap.end() &&
"making names visible added hidden names");
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
Include non-explicit submodules in exported module list This change fixes Richard's testcase for r193815. Now we include non-explicit submodules into the list of exports. The test failed previously because: - recursive_visibility_a1.inner is not imported (only recursive_visibility_a1 is), - thus the 'inner' submodule is not showing up in any of the import lists, - and because of this getExportedModules() is not returning the correct module set -- it only considers modules that are imported. The fix is to make Module::getExportedModules() include non-explicit submodules into the list of exports. llvm-svn: 194018
2013-11-05 05:51:33 +08:00
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
// Push any exported modules onto the stack to be marked as visible.
[modules] Refactor code from ASTReader::makeModuleVisible() into a new function, Module::getExportedModules() so it can be reused. llvm-svn: 175548
2013-02-20 03:34:40 +08:00
SmallVector<Module *, 16> Exports;
Mod->getExportedModules(Exports);
for (SmallVectorImpl<Module *>::iterator
I = Exports.begin(), E = Exports.end(); I != E; ++I) {
Module *Exported = *I;
Update for LLVM API change to make Small(Ptr)Set::insert return pair<iterator, bool> as per the C++ standard's associative container concept. llvm-svn: 222335
2014-11-19 15:49:47 +08:00
if (Visited.insert(Exported).second)
[modules] Refactor code from ASTReader::makeModuleVisible() into a new function, Module::getExportedModules() so it can be reused. llvm-svn: 175548
2013-02-20 03:34:40 +08:00
Stack.push_back(Exported);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
}
}
Implement the reader of the global module index and wire it into the AST reader. The global module index tracks all of the identifiers known to a set of module files. Lookup of those identifiers looks first in the global module index, which returns the set of module files in which that identifier can be found. The AST reader only needs to look into those module files and any module files not known to the global index (e.g., because they were (re)built after the global index), reducing the number of on-disk hash tables to visit. For an example source I'm looking at, we go from 237844 total identifier lookups into on-disk hash tables down to 126817. Unfortunately, this does not translate into a performance advantage. At best, it's a wash once the global module index has been built, but that's ignore the cost of building the global module index (which is itself fairly large). Profiles show that the global module index code is far less efficient than it should be; optimizing it might give enough of an advantage to justify its continued inclusion. llvm-svn: 173405
2013-01-25 09:03:03 +08:00
bool ASTReader::loadGlobalIndex() {
if (GlobalIndex)
return false;
if (TriedLoadingGlobalIndex || !UseGlobalIndex ||
!Context.getLangOpts().Modules)
return true;
// Try to load the global index.
TriedLoadingGlobalIndex = true;
StringRef ModuleCachePath
= getPreprocessor().getHeaderSearchInfo().getModuleCachePath();
std::pair<GlobalModuleIndex *, GlobalModuleIndex::ErrorCode> Result
<rdar://problem/13363214> Eliminate race condition between module rebuild and the global module index. The global module index was querying the file manager for each of the module files it knows about at load time, to prune out any out-of-date information. The file manager would then cache the results of the stat() falls used to find that module file. Later, the same translation unit could end up trying to import one of the module files that had previously been ignored by the module cache, but after some other Clang instance rebuilt the module file to bring it up-to-date. The stale stat() results in the file manager would trigger a second rebuild of the already-up-to-date module, causing failures down the line. The global module index now lazily resolves its module file references to actual AST reader module files only after the module file has been loaded, eliminating the stat-caching race. Moreover, the AST reader can communicate to its caller that a module file is missing (rather than simply being out-of-date), allowing us to simplify the module-loading logic and allowing the compiler to recover if a dependent module file ends up getting deleted. llvm-svn: 177367
2013-03-19 08:28:20 +08:00
= GlobalModuleIndex::readIndex(ModuleCachePath);
Implement the reader of the global module index and wire it into the AST reader. The global module index tracks all of the identifiers known to a set of module files. Lookup of those identifiers looks first in the global module index, which returns the set of module files in which that identifier can be found. The AST reader only needs to look into those module files and any module files not known to the global index (e.g., because they were (re)built after the global index), reducing the number of on-disk hash tables to visit. For an example source I'm looking at, we go from 237844 total identifier lookups into on-disk hash tables down to 126817. Unfortunately, this does not translate into a performance advantage. At best, it's a wash once the global module index has been built, but that's ignore the cost of building the global module index (which is itself fairly large). Profiles show that the global module index code is far less efficient than it should be; optimizing it might give enough of an advantage to justify its continued inclusion. llvm-svn: 173405
2013-01-25 09:03:03 +08:00
if (!Result.first)
return true;
GlobalIndex.reset(Result.first);
Improve coordination between the module manager and the global module index, optimizing the operation that skips lookup in modules where we know the identifier will not be found. This makes the global module index optimization actually useful, providing an 8.5% speedup over modules without the global module index for -fsyntax-only. llvm-svn: 173529
2013-01-26 07:32:03 +08:00
ModuleMgr.setGlobalIndex(GlobalIndex.get());
Implement the reader of the global module index and wire it into the AST reader. The global module index tracks all of the identifiers known to a set of module files. Lookup of those identifiers looks first in the global module index, which returns the set of module files in which that identifier can be found. The AST reader only needs to look into those module files and any module files not known to the global index (e.g., because they were (re)built after the global index), reducing the number of on-disk hash tables to visit. For an example source I'm looking at, we go from 237844 total identifier lookups into on-disk hash tables down to 126817. Unfortunately, this does not translate into a performance advantage. At best, it's a wash once the global module index has been built, but that's ignore the cost of building the global module index (which is itself fairly large). Profiles show that the global module index code is far less efficient than it should be; optimizing it might give enough of an advantage to justify its continued inclusion. llvm-svn: 173405
2013-01-25 09:03:03 +08:00
return false;
}
bool ASTReader::isGlobalIndexUnavailable() const {
return Context.getLangOpts().Modules && UseGlobalIndex &&
!hasGlobalIndex() && TriedLoadingGlobalIndex;
}
Add an option to allow Clang verify source files for a module only once during the build When Clang loads the module, it verifies the user source files that the module was built from. If any file was changed, the module is rebuilt. There are two problems with this: 1. correctness: we don't verify system files (there are too many of them, and stat'ing all of them would take a lot of time); 2. performance: the same module file is verified again and again during a single build. This change allows the build system to optimize source file verification. The idea is based on the fact that while the project is being built, the source files don't change. This allows us to verify the module only once during a single build session. The build system passes a flag, -fbuild-session-timestamp=, to inform Clang of the time when the build started. The build system also requests to enable this feature by passing -fmodules-validate-once-per-build-session. If these flags are not passed, the behavior is not changed. When Clang verifies the module the first time, it writes out a timestamp file. Then, when Clang loads the module the second time, it finds a timestamp file, so it can compare the verification timestamp of the module with the time when the build started. If the verification timestamp is too old, the module is verified again, and the timestamp file is updated. llvm-svn: 201224
2014-02-12 18:33:14 +08:00
static void updateModuleTimestamp(ModuleFile &MF) {
// Overwrite the timestamp file contents so that file's mtime changes.
std::string TimestampFilename = MF.getTimestampFilename();
Update for llvm api change. llvm-svn: 216397
2014-08-26 02:17:04 +08:00
std::error_code EC;
llvm::raw_fd_ostream OS(TimestampFilename, EC, llvm::sys::fs::F_Text);
if (EC)
Add an option to allow Clang verify source files for a module only once during the build When Clang loads the module, it verifies the user source files that the module was built from. If any file was changed, the module is rebuilt. There are two problems with this: 1. correctness: we don't verify system files (there are too many of them, and stat'ing all of them would take a lot of time); 2. performance: the same module file is verified again and again during a single build. This change allows the build system to optimize source file verification. The idea is based on the fact that while the project is being built, the source files don't change. This allows us to verify the module only once during a single build session. The build system passes a flag, -fbuild-session-timestamp=, to inform Clang of the time when the build started. The build system also requests to enable this feature by passing -fmodules-validate-once-per-build-session. If these flags are not passed, the behavior is not changed. When Clang verifies the module the first time, it writes out a timestamp file. Then, when Clang loads the module the second time, it finds a timestamp file, so it can compare the verification timestamp of the module with the time when the build started. If the verification timestamp is too old, the module is verified again, and the timestamp file is updated. llvm-svn: 201224
2014-02-12 18:33:14 +08:00
return;
OS << "Timestamp file\n";
}
Introduce module file extensions to piggy-back data onto module files. Introduce the notion of a module file extension, which introduces additional information into a module file at the time it is built that can then be queried when the module file is read. Module file extensions are identified by a block name (which must be unique to the extension) and can write any bitstream records into their own extension block within the module file. When a module file is loaded, any extension blocks are matched up with module file extension readers, that are per-module-file and are given access to the input bitstream. Note that module file extensions can only be introduced by programmatic clients that have access to the CompilerInvocation. There is only one such extension at the moment, which is used for testing the module file extension harness. As a future direction, one could imagine allowing the plugin mechanism to introduce new module file extensions. llvm-svn: 251955
2015-11-04 02:33:07 +08:00
/// \brief Given a cursor at the start of an AST file, scan ahead and drop the
/// cursor into the start of the given block ID, returning false on success and
/// true on failure.
static bool SkipCursorToBlock(BitstreamCursor &Cursor, unsigned BlockID) {
while (1) {
llvm::BitstreamEntry Entry = Cursor.advance();
switch (Entry.Kind) {
case llvm::BitstreamEntry::Error:
case llvm::BitstreamEntry::EndBlock:
return true;
case llvm::BitstreamEntry::Record:
// Ignore top-level records.
Cursor.skipRecord(Entry.ID);
break;
case llvm::BitstreamEntry::SubBlock:
if (Entry.ID == BlockID) {
if (Cursor.EnterSubBlock(BlockID))
return true;
// Found it!
return false;
}
if (Cursor.SkipBlock())
return true;
}
}
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
ASTReader::ASTReadResult ASTReader::ReadAST(const std::string &FileName,
ModuleKind Type,
SourceLocation ImportLoc,
unsigned ClientLoadCapabilities) {
[modules] If we hit a failure while loading a PCH/module, abort parsing instead of trying to continue in an invalid state. Also don't let libclang create a PCH with such an error. Fixes rdar://13953768 llvm-svn: 182629
2013-05-24 13:44:08 +08:00
llvm::SaveAndRestore<SourceLocation>
SetCurImportLocRAII(CurrentImportLoc, ImportLoc);
Defer loading any pending update records until we've finished deserializing. This fixes a bug where an update record causes us to load an entity that refers to an entity we've not finished loading yet, resulting in badness. llvm-svn: 207603
2014-04-30 10:24:17 +08:00
// Defer any pending actions until we get to the end of reading the AST file.
Deserializing AnASTFile(this);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
// Bump the generation number.
If a declaration is loaded, and then a module import adds a redeclaration, then ensure that querying the first declaration for its most recent declaration checks for redeclarations from the imported module. This works as follows: * The 'most recent' pointer on a canonical declaration grows a pointer to the external AST source and a generation number (space- and time-optimized for the case where there is no external source). * Each time the 'most recent' pointer is queried, if it has an external source, we check whether it's up to date, and update it if not. * The ancillary data stored on the canonical declaration is allocated lazily to avoid filling it in for declarations that end up being non-canonical. We'll still perform a redundant (ASTContext) allocation if someone asks for the most recent declaration from a decl before setPreviousDecl is called, but such cases are probably all bugs, and are now easy to find. Some finessing is still in order here -- in particular, we use a very general mechanism for handling the DefinitionData pointer on CXXRecordData, and a more targeted approach would be more compact. Also, the MayHaveOutOfDateDef mechanism should now be expunged, since it was addressing only a corner of the full problem space here. That's not covered by this patch. Early performance benchmarks show that this makes no measurable difference to Clang performance without modules enabled (and fixes a major correctness issue with modules enabled). I'll revert if a full performance comparison shows any problems. llvm-svn: 209046
2014-05-17 07:01:30 +08:00
unsigned PreviousGeneration = incrementGeneration(Context);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
unsigned NumModules = ModuleMgr.size();
Remove useless 'llvm::' qualifier from names like StringRef and others that are brought into 'clang' namespace by clang/Basic/LLVM.h llvm-svn: 172323
2013-01-13 03:30:44 +08:00
SmallVector<ImportedModule, 4> Loaded;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
switch(ASTReadResult ReadResult = ReadASTCore(FileName, Type, ImportLoc,
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
/*ImportedBy=*/nullptr, Loaded,
Add a "signature" to AST files to verify that they haven't changed Since the order of the IDs in the AST file (e.g. DeclIDs, SelectorIDs) is not stable, it is not safe to load an AST file that depends on another AST file that has been rebuilt since the importer was built, even if "nothing changed". We previously used size and modtime to check this, but I've seen cases where a module rebuilt quickly enough to foil this check and caused very hard to debug build errors. To save cycles when we're loading the AST, we just generate a random nonce value and check that it hasn't changed when we load an imported module, rather than actually hash the whole file. This is slightly complicated by the fact that we need to verify the signature inside addModule, since we might otherwise consider that a mdoule is "OutOfDate" when really it is the importer that is out of date. I didn't see any regressions in module load time after this change. llvm-svn: 220493
2014-10-24 02:05:36 +08:00
0, 0, 0,
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
ClientLoadCapabilities)) {
case Failure:
<rdar://problem/13363214> Eliminate race condition between module rebuild and the global module index. The global module index was querying the file manager for each of the module files it knows about at load time, to prune out any out-of-date information. The file manager would then cache the results of the stat() falls used to find that module file. Later, the same translation unit could end up trying to import one of the module files that had previously been ignored by the module cache, but after some other Clang instance rebuilt the module file to bring it up-to-date. The stale stat() results in the file manager would trigger a second rebuild of the already-up-to-date module, causing failures down the line. The global module index now lazily resolves its module file references to actual AST reader module files only after the module file has been loaded, eliminating the stat-caching race. Moreover, the AST reader can communicate to its caller that a module file is missing (rather than simply being out-of-date), allowing us to simplify the module-loading logic and allowing the compiler to recover if a dependent module file ends up getting deleted. llvm-svn: 177367
2013-03-19 08:28:20 +08:00
case Missing:
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
case OutOfDate:
case VersionMismatch:
case ConfigurationMismatch:
Avoid invalidating successfully loaded module files Successfully loaded module files may be referenced in other ModuleManagers, so don't invalidate them. Two related things are fixed: 1) I thought the last module in the manager was always the one that failed, but it isn't. So check explicitly against the list of vetted modules from ReadASTCore. 2) We now keep the file descriptor of pcm file open, which avoids the possibility of having two different pcms for the same module loaded when building in parallel with headers being modified during a build. <rdar://problem/16835846> llvm-svn: 211330
2014-06-20 08:24:56 +08:00
case HadErrors: {
llvm::SmallPtrSet<ModuleFile *, 4> LoadedSet;
for (const ImportedModule &IM : Loaded)
LoadedSet.insert(IM.Mod);
<rdar://problem/13363214> Eliminate race condition between module rebuild and the global module index. The global module index was querying the file manager for each of the module files it knows about at load time, to prune out any out-of-date information. The file manager would then cache the results of the stat() falls used to find that module file. Later, the same translation unit could end up trying to import one of the module files that had previously been ignored by the module cache, but after some other Clang instance rebuilt the module file to bring it up-to-date. The stale stat() results in the file manager would trigger a second rebuild of the already-up-to-date module, causing failures down the line. The global module index now lazily resolves its module file references to actual AST reader module files only after the module file has been loaded, eliminating the stat-caching race. Moreover, the AST reader can communicate to its caller that a module file is missing (rather than simply being out-of-date), allowing us to simplify the module-loading logic and allowing the compiler to recover if a dependent module file ends up getting deleted. llvm-svn: 177367
2013-03-19 08:28:20 +08:00
ModuleMgr.removeModules(ModuleMgr.begin() + NumModules, ModuleMgr.end(),
Avoid invalidating successfully loaded module files Successfully loaded module files may be referenced in other ModuleManagers, so don't invalidate them. Two related things are fixed: 1) I thought the last module in the manager was always the one that failed, but it isn't. So check explicitly against the list of vetted modules from ReadASTCore. 2) We now keep the file descriptor of pcm file open, which avoids the possibility of having two different pcms for the same module loaded when building in parallel with headers being modified during a build. <rdar://problem/16835846> llvm-svn: 211330
2014-06-20 08:24:56 +08:00
LoadedSet,
<rdar://problem/13363214> Eliminate race condition between module rebuild and the global module index. The global module index was querying the file manager for each of the module files it knows about at load time, to prune out any out-of-date information. The file manager would then cache the results of the stat() falls used to find that module file. Later, the same translation unit could end up trying to import one of the module files that had previously been ignored by the module cache, but after some other Clang instance rebuilt the module file to bring it up-to-date. The stale stat() results in the file manager would trigger a second rebuild of the already-up-to-date module, causing failures down the line. The global module index now lazily resolves its module file references to actual AST reader module files only after the module file has been loaded, eliminating the stat-caching race. Moreover, the AST reader can communicate to its caller that a module file is missing (rather than simply being out-of-date), allowing us to simplify the module-loading logic and allowing the compiler to recover if a dependent module file ends up getting deleted. llvm-svn: 177367
2013-03-19 08:28:20 +08:00
Context.getLangOpts().Modules
? &PP.getHeaderSearchInfo().getModuleMap()
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
: nullptr);
Implement the reader of the global module index and wire it into the AST reader. The global module index tracks all of the identifiers known to a set of module files. Lookup of those identifiers looks first in the global module index, which returns the set of module files in which that identifier can be found. The AST reader only needs to look into those module files and any module files not known to the global index (e.g., because they were (re)built after the global index), reducing the number of on-disk hash tables to visit. For an example source I'm looking at, we go from 237844 total identifier lookups into on-disk hash tables down to 126817. Unfortunately, this does not translate into a performance advantage. At best, it's a wash once the global module index has been built, but that's ignore the cost of building the global module index (which is itself fairly large). Profiles show that the global module index code is far less efficient than it should be; optimizing it might give enough of an advantage to justify its continued inclusion. llvm-svn: 173405
2013-01-25 09:03:03 +08:00
// If we find that any modules are unusable, the global index is going
// to be out-of-date. Just remove it.
GlobalIndex.reset();
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
ModuleMgr.setGlobalIndex(nullptr);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
return ReadResult;
Avoid invalidating successfully loaded module files Successfully loaded module files may be referenced in other ModuleManagers, so don't invalidate them. Two related things are fixed: 1) I thought the last module in the manager was always the one that failed, but it isn't. So check explicitly against the list of vetted modules from ReadASTCore. 2) We now keep the file descriptor of pcm file open, which avoids the possibility of having two different pcms for the same module loaded when building in parallel with headers being modified during a build. <rdar://problem/16835846> llvm-svn: 211330
2014-06-20 08:24:56 +08:00
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
case Success:
break;
}
// Here comes stuff that we only do once the entire chain is loaded.
// Load the AST blocks of all of the modules that we loaded.
Remove useless 'llvm::' qualifier from names like StringRef and others that are brought into 'clang' namespace by clang/Basic/LLVM.h llvm-svn: 172323
2013-01-13 03:30:44 +08:00
for (SmallVectorImpl<ImportedModule>::iterator M = Loaded.begin(),
MEnd = Loaded.end();
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
M != MEnd; ++M) {
ModuleFile &F = *M->Mod;
// Read the AST block.
When module umbrellas change, rebuild them With the VFS, it is easy to hit modified umbrellas by overriding the umbrella header, and what we want is to rebuild, not to fail. llvm-svn: 205975
2014-04-11 01:57:43 +08:00
if (ASTReadResult Result = ReadASTBlock(F, ClientLoadCapabilities))
return Result;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
Introduce module file extensions to piggy-back data onto module files. Introduce the notion of a module file extension, which introduces additional information into a module file at the time it is built that can then be queried when the module file is read. Module file extensions are identified by a block name (which must be unique to the extension) and can write any bitstream records into their own extension block within the module file. When a module file is loaded, any extension blocks are matched up with module file extension readers, that are per-module-file and are given access to the input bitstream. Note that module file extensions can only be introduced by programmatic clients that have access to the CompilerInvocation. There is only one such extension at the moment, which is used for testing the module file extension harness. As a future direction, one could imagine allowing the plugin mechanism to introduce new module file extensions. llvm-svn: 251955
2015-11-04 02:33:07 +08:00
// Read the extension blocks.
while (!SkipCursorToBlock(F.Stream, EXTENSION_BLOCK_ID)) {
if (ASTReadResult Result = ReadExtensionBlock(F))
return Result;
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
// Once read, set the ModuleFile bit base offset and update the size in
// bits of all files we've seen.
F.GlobalBitOffset = TotalModulesSizeInBits;
TotalModulesSizeInBits += F.SizeInBits;
GlobalBitOffsetsMap.insert(std::make_pair(F.GlobalBitOffset, &F));
// Preload SLocEntries.
for (unsigned I = 0, N = F.PreloadSLocEntries.size(); I != N; ++I) {
int Index = int(F.PreloadSLocEntries[I] - 1) + F.SLocEntryBaseID;
// Load it through the SourceManager and don't call ReadSLocEntry()
// directly because the entry may have already been loaded in which case
// calling ReadSLocEntry() directly would trigger an assertion in
// SourceManager.
SourceMgr.getLoadedSLocEntryByID(Index);
}
[modules] Stop performing PCM lookups for all identifiers when building with C++ modules. Instead, serialize a list of interesting identifiers and mark those ones out of date on module import. Avoiding the identifier lookups here gives a 20-30% speedup in builds with large numbers of modules. No functionality change intended. llvm-svn: 242868
2015-07-22 10:08:40 +08:00
// Preload all the pending interesting identifiers by marking them out of
// date.
for (auto Offset : F.PreloadIdentifierOffsets) {
const unsigned char *Data = reinterpret_cast<const unsigned char *>(
F.IdentifierTableData + Offset);
ASTIdentifierLookupTrait Trait(*this, F);
auto KeyDataLen = Trait.ReadKeyDataLength(Data);
auto Key = Trait.ReadKey(Data, KeyDataLen.first);
[modules] Stop updating all identifiers when writing a module. This is unnecessary in C++ modules (where we don't need the identifiers for their Decls) and expensive. llvm-svn: 245821
2015-08-24 11:33:22 +08:00
auto &II = PP.getIdentifierTable().getOwn(Key);
II.setOutOfDate(true);
// Mark this identifier as being from an AST file so that we can track
// whether we need to serialize it.
if (!II.isFromAST()) {
II.setIsFromAST();
Fix missing builtin identifier infos with PCH+modules Use the *current* state of "is-moduleness" rather than the state at serialization time so that if we read a builtin identifier from a module that wasn't "interesting" to that module, we will still write it out to a PCH that imports that module. Otherwise, we would get mysterious "unknown builtin" errors when using PCH+modules. rdar://problem/23287656 llvm-svn: 251565
2015-10-29 06:25:37 +08:00
bool IsModule = PP.getCurrentModule() != nullptr;
if (isInterestingIdentifier(*this, II, IsModule))
[modules] Stop updating all identifiers when writing a module. This is unnecessary in C++ modules (where we don't need the identifiers for their Decls) and expensive. llvm-svn: 245821
2015-08-24 11:33:22 +08:00
II.setChangedSinceDeserialization();
}
// Associate the ID with the identifier so that the writer can reuse it.
auto ID = Trait.ReadIdentifierID(Data + KeyDataLen.first);
SetIdentifierInfo(ID, &II);
[modules] Stop performing PCM lookups for all identifiers when building with C++ modules. Instead, serialize a list of interesting identifiers and mark those ones out of date on module import. Avoiding the identifier lookups here gives a 20-30% speedup in builds with large numbers of modules. No functionality change intended. llvm-svn: 242868
2015-07-22 10:08:40 +08:00
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
<rdar://problem/13479539> Simplify ModuleManager/GlobalModuleIndex interaction to eliminate a pile of extraneous stats(). The refactoring in r177367 introduced a serious performance bug where the "lazy" resolution of module file names in the global module index to actual module file entries in the module manager would perform repeated negative stats(). The new interaction requires the module manager to inform the global module index when a module file has been loaded, eliminating the extraneous stat()s and a bunch of bookkeeping on both sides. llvm-svn: 177750
2013-03-23 02:50:14 +08:00
// Setup the import locations and notify the module manager that we've
// committed to these module files.
Remove useless 'llvm::' qualifier from names like StringRef and others that are brought into 'clang' namespace by clang/Basic/LLVM.h llvm-svn: 172323
2013-01-13 03:30:44 +08:00
for (SmallVectorImpl<ImportedModule>::iterator M = Loaded.begin(),
MEnd = Loaded.end();
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
M != MEnd; ++M) {
ModuleFile &F = *M->Mod;
<rdar://problem/13479539> Simplify ModuleManager/GlobalModuleIndex interaction to eliminate a pile of extraneous stats(). The refactoring in r177367 introduced a serious performance bug where the "lazy" resolution of module file names in the global module index to actual module file entries in the module manager would perform repeated negative stats(). The new interaction requires the module manager to inform the global module index when a module file has been loaded, eliminating the extraneous stat()s and a bunch of bookkeeping on both sides. llvm-svn: 177750
2013-03-23 02:50:14 +08:00
ModuleMgr.moduleFileAccepted(&F);
// Set the import location.
[modules] Introduce ModuleFile::DirectImportLoc which is the source location where the module was explicitly or implicitly imported in the local translation unit. llvm-svn: 174192
2013-02-02 00:36:14 +08:00
F.DirectImportLoc = ImportLoc;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
if (!M->ImportedBy)
F.ImportLoc = M->ImportLoc;
else
F.ImportLoc = ReadSourceLocation(*M->ImportedBy,
M->ImportLoc.getRawEncoding());
}
[modules] Stop performing PCM lookups for all identifiers when building with C++ modules. Instead, serialize a list of interesting identifiers and mark those ones out of date on module import. Avoiding the identifier lookups here gives a 20-30% speedup in builds with large numbers of modules. No functionality change intended. llvm-svn: 242868
2015-07-22 10:08:40 +08:00
if (!Context.getLangOpts().CPlusPlus ||
(Type != MK_ImplicitModule && Type != MK_ExplicitModule)) {
// Mark all of the identifiers in the identifier table as being out of date,
// so that various accessors know to check the loaded modules when the
// identifier is used.
//
// For C++ modules, we don't need information on many identifiers (just
// those that provide macros or are poisoned), so we mark all of
// the interesting ones via PreloadIdentifierOffsets.
for (IdentifierTable::iterator Id = PP.getIdentifierTable().begin(),
IdEnd = PP.getIdentifierTable().end();
Id != IdEnd; ++Id)
Id->second->setOutOfDate(true);
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
// Resolve any unresolved module exports.
<rdar://problem/12368093> Extend module maps with a 'conflict' declaration, and warn when a newly-imported module conflicts with an already-imported module. llvm-svn: 177577
2013-03-21 05:10:35 +08:00
for (unsigned I = 0, N = UnresolvedModuleRefs.size(); I != N; ++I) {
UnresolvedModuleRef &Unresolved = UnresolvedModuleRefs[I];
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
SubmoduleID GlobalID = getGlobalSubmoduleID(*Unresolved.File,Unresolved.ID);
Module *ResolvedMod = getSubmodule(GlobalID);
<rdar://problem/12368093> Extend module maps with a 'conflict' declaration, and warn when a newly-imported module conflicts with an already-imported module. llvm-svn: 177577
2013-03-21 05:10:35 +08:00
switch (Unresolved.Kind) {
case UnresolvedModuleRef::Conflict:
if (ResolvedMod) {
Module::Conflict Conflict;
Conflict.Other = ResolvedMod;
Conflict.Message = Unresolved.String.str();
Unresolved.Mod->Conflicts.push_back(Conflict);
}
continue;
case UnresolvedModuleRef::Import:
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
if (ResolvedMod)
[modules] If a module #includes a modular header that #undef's its macro, it should not export the macro. ... at least, not unless we have local submodule visibility enabled. llvm-svn: 236369
2015-05-02 08:45:56 +08:00
Unresolved.Mod->Imports.insert(ResolvedMod);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
continue;
<rdar://problem/12368093> Extend module maps with a 'conflict' declaration, and warn when a newly-imported module conflicts with an already-imported module. llvm-svn: 177577
2013-03-21 05:10:35 +08:00
case UnresolvedModuleRef::Export:
if (ResolvedMod || Unresolved.IsWildcard)
Unresolved.Mod->Exports.push_back(
Module::ExportDecl(ResolvedMod, Unresolved.IsWildcard));
continue;
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
<rdar://problem/12368093> Extend module maps with a 'conflict' declaration, and warn when a newly-imported module conflicts with an already-imported module. llvm-svn: 177577
2013-03-21 05:10:35 +08:00
UnresolvedModuleRefs.clear();
Module use declarations (II) Review: http://llvm-reviews.chandlerc.com/D1546. I have picked up this patch form Lawrence (http://llvm-reviews.chandlerc.com/D1063) and did a few changes. From the original change description (updated as appropriate): This patch adds a check that ensures that modules only use modules they have so declared. To this end, it adds a statement on intended module use to the module.map grammar: use module-id A module can then only use headers from other modules if it 'uses' them. This enforcement is off by default, but may be turned on with the new option -fmodules-decluse. When enforcing the module semantics, we also need to consider a source file part of a module. This is achieved with a compiler option -fmodule-name=<module-id>. The compiler at present only applies restrictions to the module directly being built. llvm-svn: 191283
2013-09-24 17:14:14 +08:00
// FIXME: How do we load the 'use'd modules? They may not be submodules.
// Might be unnecessary as use declarations are only used to build the
// module itself.
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
InitializeContext();
C++ modules: don't lose track of a 'namespace std' that is imported from a module. llvm-svn: 192951
2013-10-18 14:54:39 +08:00
if (SemaObj)
UpdateSema();
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
if (DeserializationListener)
DeserializationListener->ReaderInitialized(this);
ModuleFile &PrimaryModule = ModuleMgr.getPrimaryModule();
Replace double negation of !FileID.isInvalid() with FileID.isValid(). +couple more of double-negated !SourceLocation.isInvalid() unfixed in r249228. llvm-svn: 249235
2015-10-03 18:46:20 +08:00
if (PrimaryModule.OriginalSourceFileID.isValid()) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
PrimaryModule.OriginalSourceFileID
= FileID::get(PrimaryModule.SLocEntryBaseID
+ PrimaryModule.OriginalSourceFileID.getOpaqueValue() - 1);
// If this AST file is a precompiled preamble, then set the
// preamble file ID of the source manager to the file source file
// from which the preamble was built.
if (Type == MK_Preamble) {
SourceMgr.setPreambleFileID(PrimaryModule.OriginalSourceFileID);
} else if (Type == MK_MainFile) {
SourceMgr.setMainFileID(PrimaryModule.OriginalSourceFileID);
}
}
// For any Objective-C class definitions we have already loaded, make sure
// that we load any additional categories.
for (unsigned I = 0, N = ObjCClassesLoaded.size(); I != N; ++I) {
loadObjCCategories(ObjCClassesLoaded[I]->getGlobalID(),
ObjCClassesLoaded[I],
PreviousGeneration);
}
Implement the reader of the global module index and wire it into the AST reader. The global module index tracks all of the identifiers known to a set of module files. Lookup of those identifiers looks first in the global module index, which returns the set of module files in which that identifier can be found. The AST reader only needs to look into those module files and any module files not known to the global index (e.g., because they were (re)built after the global index), reducing the number of on-disk hash tables to visit. For an example source I'm looking at, we go from 237844 total identifier lookups into on-disk hash tables down to 126817. Unfortunately, this does not translate into a performance advantage. At best, it's a wash once the global module index has been built, but that's ignore the cost of building the global module index (which is itself fairly large). Profiles show that the global module index code is far less efficient than it should be; optimizing it might give enough of an advantage to justify its continued inclusion. llvm-svn: 173405
2013-01-25 09:03:03 +08:00
Add an option to allow Clang verify source files for a module only once during the build When Clang loads the module, it verifies the user source files that the module was built from. If any file was changed, the module is rebuilt. There are two problems with this: 1. correctness: we don't verify system files (there are too many of them, and stat'ing all of them would take a lot of time); 2. performance: the same module file is verified again and again during a single build. This change allows the build system to optimize source file verification. The idea is based on the fact that while the project is being built, the source files don't change. This allows us to verify the module only once during a single build session. The build system passes a flag, -fbuild-session-timestamp=, to inform Clang of the time when the build started. The build system also requests to enable this feature by passing -fmodules-validate-once-per-build-session. If these flags are not passed, the behavior is not changed. When Clang verifies the module the first time, it writes out a timestamp file. Then, when Clang loads the module the second time, it finds a timestamp file, so it can compare the verification timestamp of the module with the time when the build started. If the verification timestamp is too old, the module is verified again, and the timestamp file is updated. llvm-svn: 201224
2014-02-12 18:33:14 +08:00
if (PP.getHeaderSearchInfo()
.getHeaderSearchOpts()
.ModulesValidateOncePerBuildSession) {
// Now we are certain that the module and all modules it depends on are
// up to date. Create or update timestamp files for modules that are
// located in the module cache (not for PCH files that could be anywhere
// in the filesystem).
for (unsigned I = 0, N = Loaded.size(); I != N; ++I) {
ImportedModule &M = Loaded[I];
[modules] Initial support for explicitly loading .pcm files. Implicit module builds are not well-suited to a lot of build systems. In particular, they fare badly in distributed build systems, and they lead to build artifacts that are not tracked as part of the usual dependency management process. This change allows explicitly-built module files (which are already supported through the -emit-module flag) to be explicitly loaded into a build, allowing build systems to opt to manage module builds and dependencies themselves. This is only the first step in supporting such configurations, and it should be considered experimental and subject to change or removal for now. llvm-svn: 220359
2014-10-22 10:05:46 +08:00
if (M.Mod->Kind == MK_ImplicitModule) {
Add an option to allow Clang verify source files for a module only once during the build When Clang loads the module, it verifies the user source files that the module was built from. If any file was changed, the module is rebuilt. There are two problems with this: 1. correctness: we don't verify system files (there are too many of them, and stat'ing all of them would take a lot of time); 2. performance: the same module file is verified again and again during a single build. This change allows the build system to optimize source file verification. The idea is based on the fact that while the project is being built, the source files don't change. This allows us to verify the module only once during a single build session. The build system passes a flag, -fbuild-session-timestamp=, to inform Clang of the time when the build started. The build system also requests to enable this feature by passing -fmodules-validate-once-per-build-session. If these flags are not passed, the behavior is not changed. When Clang verifies the module the first time, it writes out a timestamp file. Then, when Clang loads the module the second time, it finds a timestamp file, so it can compare the verification timestamp of the module with the time when the build started. If the verification timestamp is too old, the module is verified again, and the timestamp file is updated. llvm-svn: 201224
2014-02-12 18:33:14 +08:00
updateModuleTimestamp(*M.Mod);
}
}
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
return Success;
}
Add a "signature" to AST files to verify that they haven't changed Since the order of the IDs in the AST file (e.g. DeclIDs, SelectorIDs) is not stable, it is not safe to load an AST file that depends on another AST file that has been rebuilt since the importer was built, even if "nothing changed". We previously used size and modtime to check this, but I've seen cases where a module rebuilt quickly enough to foil this check and caused very hard to debug build errors. To save cycles when we're loading the AST, we just generate a random nonce value and check that it hasn't changed when we load an imported module, rather than actually hash the whole file. This is slightly complicated by the fact that we need to verify the signature inside addModule, since we might otherwise consider that a mdoule is "OutOfDate" when really it is the importer that is out of date. I didn't see any regressions in module load time after this change. llvm-svn: 220493
2014-10-24 02:05:36 +08:00
static ASTFileSignature readASTFileSignature(llvm::BitstreamReader &StreamFile);
A couple of readASTFileSignature improvements (NFC) * Strength reduce a std::function to a function pointer, * Factor out checking the AST file magic number, * Add a brief doc comment to readAStFileSignature Thanks to Chandler for spotting these oddities. llvm-svn: 233050
2015-03-24 12:43:52 +08:00
/// \brief Whether \p Stream starts with the AST/PCH file magic number 'CPCH'.
static bool startsWithASTFileMagic(BitstreamCursor &Stream) {
return Stream.Read(8) == 'C' &&
Stream.Read(8) == 'P' &&
Stream.Read(8) == 'C' &&
Stream.Read(8) == 'H';
}
[modules] PR22534: Load files specified by -fmodule-file= eagerly. In particular, this avoids the need to re-parse module map files when using such a module. llvm-svn: 244416
2015-08-09 16:48:41 +08:00
static unsigned moduleKindForDiagnostic(ModuleKind Kind) {
switch (Kind) {
case MK_PCH:
return 0; // PCH
case MK_ImplicitModule:
case MK_ExplicitModule:
return 1; // module
case MK_MainFile:
case MK_Preamble:
return 2; // main source file
}
llvm_unreachable("unknown module kind");
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
ASTReader::ASTReadResult
ASTReader::ReadASTCore(StringRef FileName,
ModuleKind Type,
SourceLocation ImportLoc,
ModuleFile *ImportedBy,
Remove useless 'llvm::' qualifier from names like StringRef and others that are brought into 'clang' namespace by clang/Basic/LLVM.h llvm-svn: 172323
2013-01-13 03:30:44 +08:00
SmallVectorImpl<ImportedModule> &Loaded,
<rdar://problem/13363214> Eliminate race condition between module rebuild and the global module index. The global module index was querying the file manager for each of the module files it knows about at load time, to prune out any out-of-date information. The file manager would then cache the results of the stat() falls used to find that module file. Later, the same translation unit could end up trying to import one of the module files that had previously been ignored by the module cache, but after some other Clang instance rebuilt the module file to bring it up-to-date. The stale stat() results in the file manager would trigger a second rebuild of the already-up-to-date module, causing failures down the line. The global module index now lazily resolves its module file references to actual AST reader module files only after the module file has been loaded, eliminating the stat-caching race. Moreover, the AST reader can communicate to its caller that a module file is missing (rather than simply being out-of-date), allowing us to simplify the module-loading logic and allowing the compiler to recover if a dependent module file ends up getting deleted. llvm-svn: 177367
2013-03-19 08:28:20 +08:00
off_t ExpectedSize, time_t ExpectedModTime,
Add a "signature" to AST files to verify that they haven't changed Since the order of the IDs in the AST file (e.g. DeclIDs, SelectorIDs) is not stable, it is not safe to load an AST file that depends on another AST file that has been rebuilt since the importer was built, even if "nothing changed". We previously used size and modtime to check this, but I've seen cases where a module rebuilt quickly enough to foil this check and caused very hard to debug build errors. To save cycles when we're loading the AST, we just generate a random nonce value and check that it hasn't changed when we load an imported module, rather than actually hash the whole file. This is slightly complicated by the fact that we need to verify the signature inside addModule, since we might otherwise consider that a mdoule is "OutOfDate" when really it is the importer that is out of date. I didn't see any regressions in module load time after this change. llvm-svn: 220493
2014-10-24 02:05:36 +08:00
ASTFileSignature ExpectedSignature,
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
unsigned ClientLoadCapabilities) {
ModuleFile *M;
std::string ErrorStr;
<rdar://problem/13363214> Eliminate race condition between module rebuild and the global module index. The global module index was querying the file manager for each of the module files it knows about at load time, to prune out any out-of-date information. The file manager would then cache the results of the stat() falls used to find that module file. Later, the same translation unit could end up trying to import one of the module files that had previously been ignored by the module cache, but after some other Clang instance rebuilt the module file to bring it up-to-date. The stale stat() results in the file manager would trigger a second rebuild of the already-up-to-date module, causing failures down the line. The global module index now lazily resolves its module file references to actual AST reader module files only after the module file has been loaded, eliminating the stat-caching race. Moreover, the AST reader can communicate to its caller that a module file is missing (rather than simply being out-of-date), allowing us to simplify the module-loading logic and allowing the compiler to recover if a dependent module file ends up getting deleted. llvm-svn: 177367
2013-03-19 08:28:20 +08:00
ModuleManager::AddModuleResult AddResult
= ModuleMgr.addModule(FileName, Type, ImportLoc, ImportedBy,
If a declaration is loaded, and then a module import adds a redeclaration, then ensure that querying the first declaration for its most recent declaration checks for redeclarations from the imported module. This works as follows: * The 'most recent' pointer on a canonical declaration grows a pointer to the external AST source and a generation number (space- and time-optimized for the case where there is no external source). * Each time the 'most recent' pointer is queried, if it has an external source, we check whether it's up to date, and update it if not. * The ancillary data stored on the canonical declaration is allocated lazily to avoid filling it in for declarations that end up being non-canonical. We'll still perform a redundant (ASTContext) allocation if someone asks for the most recent declaration from a decl before setPreviousDecl is called, but such cases are probably all bugs, and are now easy to find. Some finessing is still in order here -- in particular, we use a very general mechanism for handling the DefinitionData pointer on CXXRecordData, and a more targeted approach would be more compact. Also, the MayHaveOutOfDateDef mechanism should now be expunged, since it was addressing only a corner of the full problem space here. That's not covered by this patch. Early performance benchmarks show that this makes no measurable difference to Clang performance without modules enabled (and fixes a major correctness issue with modules enabled). I'll revert if a full performance comparison shows any problems. llvm-svn: 209046
2014-05-17 07:01:30 +08:00
getGeneration(), ExpectedSize, ExpectedModTime,
Add a "signature" to AST files to verify that they haven't changed Since the order of the IDs in the AST file (e.g. DeclIDs, SelectorIDs) is not stable, it is not safe to load an AST file that depends on another AST file that has been rebuilt since the importer was built, even if "nothing changed". We previously used size and modtime to check this, but I've seen cases where a module rebuilt quickly enough to foil this check and caused very hard to debug build errors. To save cycles when we're loading the AST, we just generate a random nonce value and check that it hasn't changed when we load an imported module, rather than actually hash the whole file. This is slightly complicated by the fact that we need to verify the signature inside addModule, since we might otherwise consider that a mdoule is "OutOfDate" when really it is the importer that is out of date. I didn't see any regressions in module load time after this change. llvm-svn: 220493
2014-10-24 02:05:36 +08:00
ExpectedSignature, readASTFileSignature,
<rdar://problem/13363214> Eliminate race condition between module rebuild and the global module index. The global module index was querying the file manager for each of the module files it knows about at load time, to prune out any out-of-date information. The file manager would then cache the results of the stat() falls used to find that module file. Later, the same translation unit could end up trying to import one of the module files that had previously been ignored by the module cache, but after some other Clang instance rebuilt the module file to bring it up-to-date. The stale stat() results in the file manager would trigger a second rebuild of the already-up-to-date module, causing failures down the line. The global module index now lazily resolves its module file references to actual AST reader module files only after the module file has been loaded, eliminating the stat-caching race. Moreover, the AST reader can communicate to its caller that a module file is missing (rather than simply being out-of-date), allowing us to simplify the module-loading logic and allowing the compiler to recover if a dependent module file ends up getting deleted. llvm-svn: 177367
2013-03-19 08:28:20 +08:00
M, ErrorStr);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
<rdar://problem/13363214> Eliminate race condition between module rebuild and the global module index. The global module index was querying the file manager for each of the module files it knows about at load time, to prune out any out-of-date information. The file manager would then cache the results of the stat() falls used to find that module file. Later, the same translation unit could end up trying to import one of the module files that had previously been ignored by the module cache, but after some other Clang instance rebuilt the module file to bring it up-to-date. The stale stat() results in the file manager would trigger a second rebuild of the already-up-to-date module, causing failures down the line. The global module index now lazily resolves its module file references to actual AST reader module files only after the module file has been loaded, eliminating the stat-caching race. Moreover, the AST reader can communicate to its caller that a module file is missing (rather than simply being out-of-date), allowing us to simplify the module-loading logic and allowing the compiler to recover if a dependent module file ends up getting deleted. llvm-svn: 177367
2013-03-19 08:28:20 +08:00
switch (AddResult) {
case ModuleManager::AlreadyLoaded:
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
return Success;
<rdar://problem/13363214> Eliminate race condition between module rebuild and the global module index. The global module index was querying the file manager for each of the module files it knows about at load time, to prune out any out-of-date information. The file manager would then cache the results of the stat() falls used to find that module file. Later, the same translation unit could end up trying to import one of the module files that had previously been ignored by the module cache, but after some other Clang instance rebuilt the module file to bring it up-to-date. The stale stat() results in the file manager would trigger a second rebuild of the already-up-to-date module, causing failures down the line. The global module index now lazily resolves its module file references to actual AST reader module files only after the module file has been loaded, eliminating the stat-caching race. Moreover, the AST reader can communicate to its caller that a module file is missing (rather than simply being out-of-date), allowing us to simplify the module-loading logic and allowing the compiler to recover if a dependent module file ends up getting deleted. llvm-svn: 177367
2013-03-19 08:28:20 +08:00
case ModuleManager::NewlyLoaded:
// Load module file below.
break;
case ModuleManager::Missing:
[modules] Initial support for explicitly loading .pcm files. Implicit module builds are not well-suited to a lot of build systems. In particular, they fare badly in distributed build systems, and they lead to build artifacts that are not tracked as part of the usual dependency management process. This change allows explicitly-built module files (which are already supported through the -emit-module flag) to be explicitly loaded into a build, allowing build systems to opt to manage module builds and dependencies themselves. This is only the first step in supporting such configurations, and it should be considered experimental and subject to change or removal for now. llvm-svn: 220359
2014-10-22 10:05:46 +08:00
// The module file was missing; if the client can handle that, return
<rdar://problem/13363214> Eliminate race condition between module rebuild and the global module index. The global module index was querying the file manager for each of the module files it knows about at load time, to prune out any out-of-date information. The file manager would then cache the results of the stat() falls used to find that module file. Later, the same translation unit could end up trying to import one of the module files that had previously been ignored by the module cache, but after some other Clang instance rebuilt the module file to bring it up-to-date. The stale stat() results in the file manager would trigger a second rebuild of the already-up-to-date module, causing failures down the line. The global module index now lazily resolves its module file references to actual AST reader module files only after the module file has been loaded, eliminating the stat-caching race. Moreover, the AST reader can communicate to its caller that a module file is missing (rather than simply being out-of-date), allowing us to simplify the module-loading logic and allowing the compiler to recover if a dependent module file ends up getting deleted. llvm-svn: 177367
2013-03-19 08:28:20 +08:00
// it.
if (ClientLoadCapabilities & ARR_Missing)
return Missing;
// Otherwise, return an error.
[modules] PR22534: Load files specified by -fmodule-file= eagerly. In particular, this avoids the need to re-parse module map files when using such a module. llvm-svn: 244416
2015-08-09 16:48:41 +08:00
Diag(diag::err_module_file_not_found) << moduleKindForDiagnostic(Type)
<< FileName << ErrorStr.empty()
<< ErrorStr;
<rdar://problem/13363214> Eliminate race condition between module rebuild and the global module index. The global module index was querying the file manager for each of the module files it knows about at load time, to prune out any out-of-date information. The file manager would then cache the results of the stat() falls used to find that module file. Later, the same translation unit could end up trying to import one of the module files that had previously been ignored by the module cache, but after some other Clang instance rebuilt the module file to bring it up-to-date. The stale stat() results in the file manager would trigger a second rebuild of the already-up-to-date module, causing failures down the line. The global module index now lazily resolves its module file references to actual AST reader module files only after the module file has been loaded, eliminating the stat-caching race. Moreover, the AST reader can communicate to its caller that a module file is missing (rather than simply being out-of-date), allowing us to simplify the module-loading logic and allowing the compiler to recover if a dependent module file ends up getting deleted. llvm-svn: 177367
2013-03-19 08:28:20 +08:00
return Failure;
case ModuleManager::OutOfDate:
// We couldn't load the module file because it is out-of-date. If the
// client can handle out-of-date, return it.
if (ClientLoadCapabilities & ARR_OutOfDate)
return OutOfDate;
// Otherwise, return an error.
[modules] PR22534: Load files specified by -fmodule-file= eagerly. In particular, this avoids the need to re-parse module map files when using such a module. llvm-svn: 244416
2015-08-09 16:48:41 +08:00
Diag(diag::err_module_file_out_of_date) << moduleKindForDiagnostic(Type)
<< FileName << ErrorStr.empty()
<< ErrorStr;
<rdar://problem/13363214> Eliminate race condition between module rebuild and the global module index. The global module index was querying the file manager for each of the module files it knows about at load time, to prune out any out-of-date information. The file manager would then cache the results of the stat() falls used to find that module file. Later, the same translation unit could end up trying to import one of the module files that had previously been ignored by the module cache, but after some other Clang instance rebuilt the module file to bring it up-to-date. The stale stat() results in the file manager would trigger a second rebuild of the already-up-to-date module, causing failures down the line. The global module index now lazily resolves its module file references to actual AST reader module files only after the module file has been loaded, eliminating the stat-caching race. Moreover, the AST reader can communicate to its caller that a module file is missing (rather than simply being out-of-date), allowing us to simplify the module-loading logic and allowing the compiler to recover if a dependent module file ends up getting deleted. llvm-svn: 177367
2013-03-19 08:28:20 +08:00
return Failure;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
<rdar://problem/13363214> Eliminate race condition between module rebuild and the global module index. The global module index was querying the file manager for each of the module files it knows about at load time, to prune out any out-of-date information. The file manager would then cache the results of the stat() falls used to find that module file. Later, the same translation unit could end up trying to import one of the module files that had previously been ignored by the module cache, but after some other Clang instance rebuilt the module file to bring it up-to-date. The stale stat() results in the file manager would trigger a second rebuild of the already-up-to-date module, causing failures down the line. The global module index now lazily resolves its module file references to actual AST reader module files only after the module file has been loaded, eliminating the stat-caching race. Moreover, the AST reader can communicate to its caller that a module file is missing (rather than simply being out-of-date), allowing us to simplify the module-loading logic and allowing the compiler to recover if a dependent module file ends up getting deleted. llvm-svn: 177367
2013-03-19 08:28:20 +08:00
assert(M && "Missing module file");
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
// FIXME: This seems rather a hack. Should CurrentDir be part of the
// module?
if (FileName != "-") {
CurrentDir = llvm::sys::path::parent_path(FileName);
if (CurrentDir.empty()) CurrentDir = ".";
}
ModuleFile &F = *M;
finish converting the normal cases in ASTReader to use the new BitstreamCursor APIs. llvm-svn: 172937
2013-01-20 08:56:42 +08:00
BitstreamCursor &Stream = F.Stream;
Make the clang module container format selectable from the command line. - introduces a new cc1 option -fmodule-format=[raw,obj] with 'raw' being the default - supports arbitrary module container formats that libclang is agnostic to - adds the format to the module hash to avoid collisions - splits the old PCHContainerOperations into PCHContainerWriter and a PCHContainerReader. Thanks to Richard Smith for reviewing this patch! llvm-svn: 242499
2015-07-17 09:19:54 +08:00
PCHContainerRdr.ExtractPCH(F.Buffer->getMemBufferRef(), F.StreamFile);
Update for llvm api change. llvm-svn: 221786
2014-11-12 22:48:44 +08:00
Stream.init(&F.StreamFile);
Revert "Wrap clang module files in a Mach-O, ELF, or COFF container." llvm-svn: 230454
2015-02-25 10:44:04 +08:00
F.SizeInBits = F.Buffer->getBufferSize() * 8;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
// Sniff for the signature.
A couple of readASTFileSignature improvements (NFC) * Strength reduce a std::function to a function pointer, * Factor out checking the AST file magic number, * Add a brief doc comment to readAStFileSignature Thanks to Chandler for spotting these oddities. llvm-svn: 233050
2015-03-24 12:43:52 +08:00
if (!startsWithASTFileMagic(Stream)) {
[modules] PR22534: Load files specified by -fmodule-file= eagerly. In particular, this avoids the need to re-parse module map files when using such a module. llvm-svn: 244416
2015-08-09 16:48:41 +08:00
Diag(diag::err_module_file_invalid) << moduleKindForDiagnostic(Type)
<< FileName;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
return Failure;
}
// This is used for compatibility with older PCH formats.
bool HaveReadControlBlock = false;
convert some more stuff over to use new cursor APIs. llvm-svn: 172932
2013-01-20 08:00:22 +08:00
while (1) {
llvm::BitstreamEntry Entry = Stream.advance();
switch (Entry.Kind) {
case llvm::BitstreamEntry::Error:
case llvm::BitstreamEntry::Record:
Introduce module file extensions to piggy-back data onto module files. Introduce the notion of a module file extension, which introduces additional information into a module file at the time it is built that can then be queried when the module file is read. Module file extensions are identified by a block name (which must be unique to the extension) and can write any bitstream records into their own extension block within the module file. When a module file is loaded, any extension blocks are matched up with module file extension readers, that are per-module-file and are given access to the input bitstream. Note that module file extensions can only be introduced by programmatic clients that have access to the CompilerInvocation. There is only one such extension at the moment, which is used for testing the module file extension harness. As a future direction, one could imagine allowing the plugin mechanism to introduce new module file extensions. llvm-svn: 251955
2015-11-04 02:33:07 +08:00
case llvm::BitstreamEntry::EndBlock:
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
Error("invalid record at top-level of AST file");
return Failure;
convert some more stuff over to use new cursor APIs. llvm-svn: 172932
2013-01-20 08:00:22 +08:00
case llvm::BitstreamEntry::SubBlock:
break;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
convert some more stuff over to use new cursor APIs. llvm-svn: 172932
2013-01-20 08:00:22 +08:00
switch (Entry.ID) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
case CONTROL_BLOCK_ID:
HaveReadControlBlock = true;
Allow multiple modules with the same name to coexist in the module cache To differentiate between two modules with the same name, we will consider the path the module map file that they are defined by* part of the ‘key’ for looking up the precompiled module (pcm file). Specifically, this patch renames the precompiled module (pcm) files from cache-path/<module hash>/Foo.pcm to cache-path/<module hash>/Foo-<hash of module map path>.pcm In addition, I’ve taught the ASTReader to re-resolve the names of imported modules during module loading so that if the header search context changes between when a module was originally built and when it is loaded we can rebuild it if necessary. For example, if module A imports module B first time: clang -I /path/to/A -I /path/to/B ... second time: clang -I /path/to/A -I /different/path/to/B ... will now rebuild A as expected. * in the case of inferred modules, we use the module map file that allowed the inference, not the __inferred_module.map file, since the inferred file path is the same for every inferred module. llvm-svn: 206201
2014-04-15 02:00:01 +08:00
switch (ReadControlBlock(F, Loaded, ImportedBy, ClientLoadCapabilities)) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
case Success:
[modules] PR22534: Load files specified by -fmodule-file= eagerly. In particular, this avoids the need to re-parse module map files when using such a module. llvm-svn: 244416
2015-08-09 16:48:41 +08:00
// Check that we didn't try to load a non-module AST file as a module.
//
// FIXME: Should we also perform the converse check? Loading a module as
// a PCH file sort of works, but it's a bit wonky.
if ((Type == MK_ImplicitModule || Type == MK_ExplicitModule) &&
F.ModuleName.empty()) {
auto Result = (Type == MK_ImplicitModule) ? OutOfDate : Failure;
if (Result != OutOfDate ||
(ClientLoadCapabilities & ARR_OutOfDate) == 0)
Diag(diag::err_module_file_not_module) << FileName;
return Result;
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
break;
case Failure: return Failure;
<rdar://problem/13363214> Eliminate race condition between module rebuild and the global module index. The global module index was querying the file manager for each of the module files it knows about at load time, to prune out any out-of-date information. The file manager would then cache the results of the stat() falls used to find that module file. Later, the same translation unit could end up trying to import one of the module files that had previously been ignored by the module cache, but after some other Clang instance rebuilt the module file to bring it up-to-date. The stale stat() results in the file manager would trigger a second rebuild of the already-up-to-date module, causing failures down the line. The global module index now lazily resolves its module file references to actual AST reader module files only after the module file has been loaded, eliminating the stat-caching race. Moreover, the AST reader can communicate to its caller that a module file is missing (rather than simply being out-of-date), allowing us to simplify the module-loading logic and allowing the compiler to recover if a dependent module file ends up getting deleted. llvm-svn: 177367
2013-03-19 08:28:20 +08:00
case Missing: return Missing;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
case OutOfDate: return OutOfDate;
case VersionMismatch: return VersionMismatch;
case ConfigurationMismatch: return ConfigurationMismatch;
case HadErrors: return HadErrors;
}
break;
[modules] Don't waste time reading in the names the module file writer gave to blocks. We don't need these names, and decoding the corresponding bitcode has a significant cost. llvm-svn: 246680
2015-09-03 01:45:54 +08:00
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
case AST_BLOCK_ID:
if (!HaveReadControlBlock) {
if ((ClientLoadCapabilities & ARR_VersionMismatch) == 0)
Rename some PCH-related errors to have 'err_' as their prefix llvm-svn: 201157
2014-02-11 23:40:09 +08:00
Diag(diag::err_pch_version_too_old);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
return VersionMismatch;
}
// Record that we've loaded this module.
Loaded.push_back(ImportedModule(M, ImportedBy, ImportLoc));
return Success;
default:
if (Stream.SkipBlock()) {
Error("malformed block record in AST file");
return Failure;
}
break;
}
}
Introduce module file extensions to piggy-back data onto module files. Introduce the notion of a module file extension, which introduces additional information into a module file at the time it is built that can then be queried when the module file is read. Module file extensions are identified by a block name (which must be unique to the extension) and can write any bitstream records into their own extension block within the module file. When a module file is loaded, any extension blocks are matched up with module file extension readers, that are per-module-file and are given access to the input bitstream. Note that module file extensions can only be introduced by programmatic clients that have access to the CompilerInvocation. There is only one such extension at the moment, which is used for testing the module file extension harness. As a future direction, one could imagine allowing the plugin mechanism to introduce new module file extensions. llvm-svn: 251955
2015-11-04 02:33:07 +08:00
return Success;
}
/// Parse a record and blob containing module file extension metadata.
static bool parseModuleFileExtensionMetadata(
const SmallVectorImpl<uint64_t> &Record,
StringRef Blob,
ModuleFileExtensionMetadata &Metadata) {
if (Record.size() < 4) return true;
Metadata.MajorVersion = Record[0];
Metadata.MinorVersion = Record[1];
unsigned BlockNameLen = Record[2];
unsigned UserInfoLen = Record[3];
if (BlockNameLen + UserInfoLen > Blob.size()) return true;
Metadata.BlockName = std::string(Blob.data(), Blob.data() + BlockNameLen);
Metadata.UserInfo = std::string(Blob.data() + BlockNameLen,
Blob.data() + BlockNameLen + UserInfoLen);
return false;
}
ASTReader::ASTReadResult ASTReader::ReadExtensionBlock(ModuleFile &F) {
BitstreamCursor &Stream = F.Stream;
RecordData Record;
while (true) {
llvm::BitstreamEntry Entry = Stream.advance();
switch (Entry.Kind) {
case llvm::BitstreamEntry::SubBlock:
if (Stream.SkipBlock())
return Failure;
continue;
case llvm::BitstreamEntry::EndBlock:
return Success;
case llvm::BitstreamEntry::Error:
return HadErrors;
case llvm::BitstreamEntry::Record:
break;
}
Record.clear();
StringRef Blob;
unsigned RecCode = Stream.readRecord(Entry.ID, Record, &Blob);
switch (RecCode) {
case EXTENSION_METADATA: {
ModuleFileExtensionMetadata Metadata;
if (parseModuleFileExtensionMetadata(Record, Blob, Metadata))
return Failure;
// Find a module file extension with this block name.
auto Known = ModuleFileExtensions.find(Metadata.BlockName);
if (Known == ModuleFileExtensions.end()) break;
// Form a reader.
if (auto Reader = Known->second->createExtensionReader(Metadata, *this,
F, Stream)) {
F.ExtensionReaders.push_back(std::move(Reader));
}
break;
}
}
}
return Success;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
[modules] Start moving the module visibility information off the Module itself. It has no place there; it's not a property of the Module, and it makes restoring the visibility set when we leave a submodule more difficult. llvm-svn: 236300
2015-05-01 09:53:09 +08:00
void ASTReader::InitializeContext() {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
// If there's a listener, notify them that we "read" the translation unit.
if (DeserializationListener)
DeserializationListener->DeclRead(PREDEF_DECL_TRANSLATION_UNIT_ID,
Context.getTranslationUnitDecl());
// FIXME: Find a better way to deal with collisions between these
// built-in types. Right now, we just ignore the problem.
// Load the special types.
if (SpecialTypes.size() >= NumSpecialTypeIDs) {
if (unsigned String = SpecialTypes[SPECIAL_TYPE_CF_CONSTANT_STRING]) {
if (!Context.CFConstantStringTypeDecl)
Context.setCFConstantStringType(GetType(String));
}
if (unsigned File = SpecialTypes[SPECIAL_TYPE_FILE]) {
QualType FileType = GetType(File);
if (FileType.isNull()) {
Error("FILE type is NULL");
return;
}
if (!Context.FILEDecl) {
if (const TypedefType *Typedef = FileType->getAs<TypedefType>())
Context.setFILEDecl(Typedef->getDecl());
else {
const TagType *Tag = FileType->getAs<TagType>();
if (!Tag) {
Error("Invalid FILE type in AST file");
return;
}
Context.setFILEDecl(Tag->getDecl());
}
}
}
if (unsigned Jmp_buf = SpecialTypes[SPECIAL_TYPE_JMP_BUF]) {
QualType Jmp_bufType = GetType(Jmp_buf);
if (Jmp_bufType.isNull()) {
Error("jmp_buf type is NULL");
return;
}
if (!Context.jmp_bufDecl) {
if (const TypedefType *Typedef = Jmp_bufType->getAs<TypedefType>())
Context.setjmp_bufDecl(Typedef->getDecl());
else {
const TagType *Tag = Jmp_bufType->getAs<TagType>();
if (!Tag) {
Error("Invalid jmp_buf type in AST file");
return;
}
Context.setjmp_bufDecl(Tag->getDecl());
}
}
}
if (unsigned Sigjmp_buf = SpecialTypes[SPECIAL_TYPE_SIGJMP_BUF]) {
QualType Sigjmp_bufType = GetType(Sigjmp_buf);
if (Sigjmp_bufType.isNull()) {
Error("sigjmp_buf type is NULL");
return;
}
if (!Context.sigjmp_bufDecl) {
if (const TypedefType *Typedef = Sigjmp_bufType->getAs<TypedefType>())
Context.setsigjmp_bufDecl(Typedef->getDecl());
else {
const TagType *Tag = Sigjmp_bufType->getAs<TagType>();
assert(Tag && "Invalid sigjmp_buf type in AST file");
Context.setsigjmp_bufDecl(Tag->getDecl());
}
}
}
if (unsigned ObjCIdRedef
= SpecialTypes[SPECIAL_TYPE_OBJC_ID_REDEFINITION]) {
if (Context.ObjCIdRedefinitionType.isNull())
Context.ObjCIdRedefinitionType = GetType(ObjCIdRedef);
}
if (unsigned ObjCClassRedef
= SpecialTypes[SPECIAL_TYPE_OBJC_CLASS_REDEFINITION]) {
if (Context.ObjCClassRedefinitionType.isNull())
Context.ObjCClassRedefinitionType = GetType(ObjCClassRedef);
}
if (unsigned ObjCSelRedef
= SpecialTypes[SPECIAL_TYPE_OBJC_SEL_REDEFINITION]) {
if (Context.ObjCSelRedefinitionType.isNull())
Context.ObjCSelRedefinitionType = GetType(ObjCSelRedef);
}
if (unsigned Ucontext_t = SpecialTypes[SPECIAL_TYPE_UCONTEXT_T]) {
QualType Ucontext_tType = GetType(Ucontext_t);
if (Ucontext_tType.isNull()) {
Error("ucontext_t type is NULL");
return;
}
if (!Context.ucontext_tDecl) {
if (const TypedefType *Typedef = Ucontext_tType->getAs<TypedefType>())
Context.setucontext_tDecl(Typedef->getDecl());
else {
const TagType *Tag = Ucontext_tType->getAs<TagType>();
assert(Tag && "Invalid ucontext_t type in AST file");
Context.setucontext_tDecl(Tag->getDecl());
}
}
}
}
ReadPragmaDiagnosticMappings(Context.getDiagnostics());
// If there were any CUDA special declarations, deserialize them.
if (!CUDASpecialDeclRefs.empty()) {
assert(CUDASpecialDeclRefs.size() == 1 && "More decl refs than expected!");
Context.setcudaConfigureCallDecl(
cast<FunctionDecl>(GetDecl(CUDASpecialDeclRefs[0])));
}
PR19215: When writing/reading a PCH that imported a module, store the location at which that PCH imported each visible submodule of the module. Such locations are needed when synthesizing macro directives resulting from the import. llvm-svn: 204417
2014-03-21 08:33:59 +08:00
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
// Re-export any modules that were imported by a non-module AST file.
[modules] Start moving the module visibility information off the Module itself. It has no place there; it's not a property of the Module, and it makes restoring the visibility set when we leave a submodule more difficult. llvm-svn: 236300
2015-05-01 09:53:09 +08:00
// FIXME: This does not make macro-only imports visible again.
PR19215: When writing/reading a PCH that imported a module, store the location at which that PCH imported each visible submodule of the module. Such locations are needed when synthesizing macro directives resulting from the import. llvm-svn: 204417
2014-03-21 08:33:59 +08:00
for (auto &Import : ImportedModules) {
[modules] Start moving the module visibility information off the Module itself. It has no place there; it's not a property of the Module, and it makes restoring the visibility set when we leave a submodule more difficult. llvm-svn: 236300
2015-05-01 09:53:09 +08:00
if (Module *Imported = getSubmodule(Import.ID)) {
For ModuleLoader::makeModuleVisible() also pass the source location where the module import occurred. llvm-svn: 174191
2013-02-02 00:36:12 +08:00
makeModuleVisible(Imported, Module::AllVisible,
[modules] Start moving the module visibility information off the Module itself. It has no place there; it's not a property of the Module, and it makes restoring the visibility set when we leave a submodule more difficult. llvm-svn: 236300
2015-05-01 09:53:09 +08:00
/*ImportLoc=*/Import.ImportLoc);
PP.makeModuleVisible(Imported, Import.ImportLoc);
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
ImportedModules.clear();
}
void ASTReader::finalizeForWriting() {
[modules] Remove the now-redundant import of all pending macros at the end of building a module. Since we now track module macros separately from their visibility state, this is no longer necessary. llvm-svn: 235648
2015-04-24 05:20:19 +08:00
// Nothing to do for now.
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
A couple of readASTFileSignature improvements (NFC) * Strength reduce a std::function to a function pointer, * Factor out checking the AST file magic number, * Add a brief doc comment to readAStFileSignature Thanks to Chandler for spotting these oddities. llvm-svn: 233050
2015-03-24 12:43:52 +08:00
/// \brief Reads and return the signature record from \p StreamFile's control
/// block, or else returns 0.
Add a "signature" to AST files to verify that they haven't changed Since the order of the IDs in the AST file (e.g. DeclIDs, SelectorIDs) is not stable, it is not safe to load an AST file that depends on another AST file that has been rebuilt since the importer was built, even if "nothing changed". We previously used size and modtime to check this, but I've seen cases where a module rebuilt quickly enough to foil this check and caused very hard to debug build errors. To save cycles when we're loading the AST, we just generate a random nonce value and check that it hasn't changed when we load an imported module, rather than actually hash the whole file. This is slightly complicated by the fact that we need to verify the signature inside addModule, since we might otherwise consider that a mdoule is "OutOfDate" when really it is the importer that is out of date. I didn't see any regressions in module load time after this change. llvm-svn: 220493
2014-10-24 02:05:36 +08:00
static ASTFileSignature readASTFileSignature(llvm::BitstreamReader &StreamFile){
BitstreamCursor Stream(StreamFile);
A couple of readASTFileSignature improvements (NFC) * Strength reduce a std::function to a function pointer, * Factor out checking the AST file magic number, * Add a brief doc comment to readAStFileSignature Thanks to Chandler for spotting these oddities. llvm-svn: 233050
2015-03-24 12:43:52 +08:00
if (!startsWithASTFileMagic(Stream))
Add a "signature" to AST files to verify that they haven't changed Since the order of the IDs in the AST file (e.g. DeclIDs, SelectorIDs) is not stable, it is not safe to load an AST file that depends on another AST file that has been rebuilt since the importer was built, even if "nothing changed". We previously used size and modtime to check this, but I've seen cases where a module rebuilt quickly enough to foil this check and caused very hard to debug build errors. To save cycles when we're loading the AST, we just generate a random nonce value and check that it hasn't changed when we load an imported module, rather than actually hash the whole file. This is slightly complicated by the fact that we need to verify the signature inside addModule, since we might otherwise consider that a mdoule is "OutOfDate" when really it is the importer that is out of date. I didn't see any regressions in module load time after this change. llvm-svn: 220493
2014-10-24 02:05:36 +08:00
return 0;
// Scan for the CONTROL_BLOCK_ID block.
if (SkipCursorToBlock(Stream, CONTROL_BLOCK_ID))
return 0;
// Scan for SIGNATURE inside the control block.
ASTReader::RecordData Record;
while (1) {
llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
if (Entry.Kind == llvm::BitstreamEntry::EndBlock ||
Entry.Kind != llvm::BitstreamEntry::Record)
return 0;
Record.clear();
StringRef Blob;
if (SIGNATURE == Stream.readRecord(Entry.ID, Record, &Blob))
return Record[0];
}
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
/// \brief Retrieve the name of the original source file name
/// directly from the AST file, without actually loading the AST
/// file.
Introduce a PCHContainerOperations interface (NFC). A PCHContainerOperations abstract interface provides operations for creating and unwrapping containers for serialized ASTs (precompiled headers and clang modules). The default implementation is RawPCHContainerOperations, which uses a flat file for the output. The main application for this interface will be an ObjectFilePCHContainerOperations implementation that uses LLVM to wrap the module in an ELF/Mach-O/COFF container to store debug info alongside the AST. rdar://problem/20091852 llvm-svn: 240225
2015-06-21 02:53:08 +08:00
std::string ASTReader::getOriginalSourceFile(
const std::string &ASTFileName, FileManager &FileMgr,
Make the clang module container format selectable from the command line. - introduces a new cc1 option -fmodule-format=[raw,obj] with 'raw' being the default - supports arbitrary module container formats that libclang is agnostic to - adds the format to the module hash to avoid collisions - splits the old PCHContainerOperations into PCHContainerWriter and a PCHContainerReader. Thanks to Richard Smith for reviewing this patch! llvm-svn: 242499
2015-07-17 09:19:54 +08:00
const PCHContainerReader &PCHContainerRdr, DiagnosticsEngine &Diags) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
// Open the AST file.
Make VFS and FileManager match the current MemoryBuffer API. This eliminates converting back and forth between the 3 formats and gives us a more homogeneous interface. llvm-svn: 220657
2014-10-27 06:44:13 +08:00
auto Buffer = FileMgr.getBufferForFile(ASTFileName);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
if (!Buffer) {
Make VFS and FileManager match the current MemoryBuffer API. This eliminates converting back and forth between the 3 formats and gives us a more homogeneous interface. llvm-svn: 220657
2014-10-27 06:44:13 +08:00
Diags.Report(diag::err_fe_unable_to_read_pch_file)
<< ASTFileName << Buffer.getError().message();
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
return std::string();
}
// Initialize the stream
llvm::BitstreamReader StreamFile;
Make the clang module container format selectable from the command line. - introduces a new cc1 option -fmodule-format=[raw,obj] with 'raw' being the default - supports arbitrary module container formats that libclang is agnostic to - adds the format to the module hash to avoid collisions - splits the old PCHContainerOperations into PCHContainerWriter and a PCHContainerReader. Thanks to Richard Smith for reviewing this patch! llvm-svn: 242499
2015-07-17 09:19:54 +08:00
PCHContainerRdr.ExtractPCH((*Buffer)->getMemBufferRef(), StreamFile);
Simplify code a bit by passing StreamFile to the BitstreamCursor constructor. llvm-svn: 221784
2014-11-12 22:42:25 +08:00
BitstreamCursor Stream(StreamFile);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
// Sniff for the signature.
A couple of readASTFileSignature improvements (NFC) * Strength reduce a std::function to a function pointer, * Factor out checking the AST file magic number, * Add a brief doc comment to readAStFileSignature Thanks to Chandler for spotting these oddities. llvm-svn: 233050
2015-03-24 12:43:52 +08:00
if (!startsWithASTFileMagic(Stream)) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
Diags.Report(diag::err_fe_not_a_pch_file) << ASTFileName;
return std::string();
}
finish converting the normal cases in ASTReader to use the new BitstreamCursor APIs. llvm-svn: 172937
2013-01-20 08:56:42 +08:00
switch a bunch of ASTReader to use the new BitstreamCursor::advance* methods, which hide a bunch of private details of the cursor from clients and simplify their code. More to come. llvm-svn: 172922
2013-01-20 05:39:22 +08:00
// Scan for the CONTROL_BLOCK_ID block.
Modify ASTReaderListener to allow visiting the input files of an AST file. We can pass such an input-file-visiting ASTReaderListener to ASTReader::readASTFileControlBlock. llvm-svn: 181238
2013-05-07 03:23:40 +08:00
if (SkipCursorToBlock(Stream, CONTROL_BLOCK_ID)) {
finish converting the normal cases in ASTReader to use the new BitstreamCursor APIs. llvm-svn: 172937
2013-01-20 08:56:42 +08:00
Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
return std::string();
switch a bunch of ASTReader to use the new BitstreamCursor::advance* methods, which hide a bunch of private details of the cursor from clients and simplify their code. More to come. llvm-svn: 172922
2013-01-20 05:39:22 +08:00
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
finish converting the normal cases in ASTReader to use the new BitstreamCursor APIs. llvm-svn: 172937
2013-01-20 08:56:42 +08:00
// Scan for ORIGINAL_FILE inside the control block.
RecordData Record;
switch a bunch of ASTReader to use the new BitstreamCursor::advance* methods, which hide a bunch of private details of the cursor from clients and simplify their code. More to come. llvm-svn: 172922
2013-01-20 05:39:22 +08:00
while (1) {
finish converting the normal cases in ASTReader to use the new BitstreamCursor APIs. llvm-svn: 172937
2013-01-20 08:56:42 +08:00
llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
switch a bunch of ASTReader to use the new BitstreamCursor::advance* methods, which hide a bunch of private details of the cursor from clients and simplify their code. More to come. llvm-svn: 172922
2013-01-20 05:39:22 +08:00
if (Entry.Kind == llvm::BitstreamEntry::EndBlock)
return std::string();
if (Entry.Kind != llvm::BitstreamEntry::Record) {
Diags.Report(diag::err_fe_pch_malformed_block) << ASTFileName;
return std::string();
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
switch a bunch of ASTReader to use the new BitstreamCursor::advance* methods, which hide a bunch of private details of the cursor from clients and simplify their code. More to come. llvm-svn: 172922
2013-01-20 05:39:22 +08:00
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
Record.clear();
update to use the new BitcodeCursor readRecord that takes a StringRef blob parameter, and adopt "advance" in more places. llvm-svn: 172951
2013-01-20 10:38:54 +08:00
StringRef Blob;
if (Stream.readRecord(Entry.ID, Record, &Blob) == ORIGINAL_FILE)
return Blob.str();
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
}
namespace {
class SimplePCHValidator : public ASTReaderListener {
const LangOptions &ExistingLangOpts;
const TargetOptions &ExistingTargetOpts;
const PreprocessorOptions &ExistingPPOpts;
[PCH/Modules] Check that the specific module cache path the PCH was built with, is the same as the one in the current compiler invocation. If they differ reject the PCH. This protects against the badness occurring from getting modules loaded from different module caches (see crashes). rdar://19889860 llvm-svn: 229909
2015-02-20 04:12:20 +08:00
std::string ExistingModuleCachePath;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
FileManager &FileMgr;
[PCH/Modules] Check that the specific module cache path the PCH was built with, is the same as the one in the current compiler invocation. If they differ reject the PCH. This protects against the badness occurring from getting modules loaded from different module caches (see crashes). rdar://19889860 llvm-svn: 229909
2015-02-20 04:12:20 +08:00
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
public:
SimplePCHValidator(const LangOptions &ExistingLangOpts,
const TargetOptions &ExistingTargetOpts,
const PreprocessorOptions &ExistingPPOpts,
[PCH/Modules] Check that the specific module cache path the PCH was built with, is the same as the one in the current compiler invocation. If they differ reject the PCH. This protects against the badness occurring from getting modules loaded from different module caches (see crashes). rdar://19889860 llvm-svn: 229909
2015-02-20 04:12:20 +08:00
StringRef ExistingModuleCachePath,
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
FileManager &FileMgr)
: ExistingLangOpts(ExistingLangOpts),
ExistingTargetOpts(ExistingTargetOpts),
ExistingPPOpts(ExistingPPOpts),
[PCH/Modules] Check that the specific module cache path the PCH was built with, is the same as the one in the current compiler invocation. If they differ reject the PCH. This protects against the badness occurring from getting modules loaded from different module caches (see crashes). rdar://19889860 llvm-svn: 229909
2015-02-20 04:12:20 +08:00
ExistingModuleCachePath(ExistingModuleCachePath),
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
FileMgr(FileMgr)
{
}
[modules] When a .pcm file is explicitly built separately from the translation unit, allow the -O settings of the two compilations to differ. llvm-svn: 220943
2014-10-31 10:28:58 +08:00
bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain,
bool AllowCompatibleDifferences) override {
return checkLanguageOptions(ExistingLangOpts, LangOpts, nullptr,
AllowCompatibleDifferences);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
[modules] Teach the AST reader to handle the case of importing a module with a subset of the existing target CPU features or mismatched CPU names. While we can't check that the CPU name used to build the module will end up being able to codegen correctly for the translation unit, we actually check that the imported features are a subset of the existing features. While here, rewrite the code to use std::set_difference and have it diagnose all of the differences found. Test case added which walks the set relationships and ensures we diagnose all the right cases and accept the others. No functional change for implicit modules here, just better diagnostics. llvm-svn: 232248
2015-03-14 12:47:43 +08:00
bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain,
bool AllowCompatibleDifferences) override {
return checkTargetOptions(ExistingTargetOpts, TargetOpts, nullptr,
AllowCompatibleDifferences);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
[PCH/Modules] Check that the specific module cache path the PCH was built with, is the same as the one in the current compiler invocation. If they differ reject the PCH. This protects against the badness occurring from getting modules loaded from different module caches (see crashes). rdar://19889860 llvm-svn: 229909
2015-02-20 04:12:20 +08:00
bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
StringRef SpecificModuleCachePath,
bool Complain) override {
return checkHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
ExistingModuleCachePath,
nullptr, ExistingLangOpts);
}
[C++11] Add 'override' keyword to virtual methods that override their base class. llvm-svn: 203746
2014-03-13 10:13:41 +08:00
bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
bool Complain,
std::string &SuggestedPredefines) override {
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
return checkPreprocessorOptions(ExistingPPOpts, PPOpts, nullptr, FileMgr,
[PCH/modules] Require the preprocessing record option to match the used PCH, if modules are enabled. The preprocessing record becomes important when modules are enabled, since it is used to calculate the module cache hash. llvm-svn: 180635
2013-04-27 05:33:40 +08:00
SuggestedPredefines, ExistingLangOpts);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
};
Revert r240270 ("Fixed/added namespace ending comments using clang-tidy"). llvm-svn: 240353
2015-06-23 07:07:51 +08:00
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
Introduce a PCHContainerOperations interface (NFC). A PCHContainerOperations abstract interface provides operations for creating and unwrapping containers for serialized ASTs (precompiled headers and clang modules). The default implementation is RawPCHContainerOperations, which uses a flat file for the output. The main application for this interface will be an ObjectFilePCHContainerOperations implementation that uses LLVM to wrap the module in an ELF/Mach-O/COFF container to store debug info alongside the AST. rdar://problem/20091852 llvm-svn: 240225
2015-06-21 02:53:08 +08:00
bool ASTReader::readASTFileControlBlock(
StringRef Filename, FileManager &FileMgr,
Make the clang module container format selectable from the command line. - introduces a new cc1 option -fmodule-format=[raw,obj] with 'raw' being the default - supports arbitrary module container formats that libclang is agnostic to - adds the format to the module hash to avoid collisions - splits the old PCHContainerOperations into PCHContainerWriter and a PCHContainerReader. Thanks to Richard Smith for reviewing this patch! llvm-svn: 242499
2015-07-17 09:19:54 +08:00
const PCHContainerReader &PCHContainerRdr,
Introduce module file extensions to piggy-back data onto module files. Introduce the notion of a module file extension, which introduces additional information into a module file at the time it is built that can then be queried when the module file is read. Module file extensions are identified by a block name (which must be unique to the extension) and can write any bitstream records into their own extension block within the module file. When a module file is loaded, any extension blocks are matched up with module file extension readers, that are per-module-file and are given access to the input bitstream. Note that module file extensions can only be introduced by programmatic clients that have access to the CompilerInvocation. There is only one such extension at the moment, which is used for testing the module file extension harness. As a future direction, one could imagine allowing the plugin mechanism to introduce new module file extensions. llvm-svn: 251955
2015-11-04 02:33:07 +08:00
bool FindModuleFileExtensions,
Introduce a PCHContainerOperations interface (NFC). A PCHContainerOperations abstract interface provides operations for creating and unwrapping containers for serialized ASTs (precompiled headers and clang modules). The default implementation is RawPCHContainerOperations, which uses a flat file for the output. The main application for this interface will be an ObjectFilePCHContainerOperations implementation that uses LLVM to wrap the module in an ELF/Mach-O/COFF container to store debug info alongside the AST. rdar://problem/20091852 llvm-svn: 240225
2015-06-21 02:53:08 +08:00
ASTReaderListener &Listener) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
// Open the AST file.
Make module files passed to a module build via -fmodule-file= available to consumers of that module. Previously, such a file would only be available if the module happened to actually import something from that module. llvm-svn: 232583
2015-03-18 09:42:29 +08:00
// FIXME: This allows use of the VFS; we do not allow use of the
// VFS when actually loading a module.
Make VFS and FileManager match the current MemoryBuffer API. This eliminates converting back and forth between the 3 formats and gives us a more homogeneous interface. llvm-svn: 220657
2014-10-27 06:44:13 +08:00
auto Buffer = FileMgr.getBufferForFile(Filename);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
if (!Buffer) {
return true;
}
// Initialize the stream
llvm::BitstreamReader StreamFile;
Make the clang module container format selectable from the command line. - introduces a new cc1 option -fmodule-format=[raw,obj] with 'raw' being the default - supports arbitrary module container formats that libclang is agnostic to - adds the format to the module hash to avoid collisions - splits the old PCHContainerOperations into PCHContainerWriter and a PCHContainerReader. Thanks to Richard Smith for reviewing this patch! llvm-svn: 242499
2015-07-17 09:19:54 +08:00
PCHContainerRdr.ExtractPCH((*Buffer)->getMemBufferRef(), StreamFile);
Simplify code a bit by passing StreamFile to the BitstreamCursor constructor. llvm-svn: 221784
2014-11-12 22:42:25 +08:00
BitstreamCursor Stream(StreamFile);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
// Sniff for the signature.
A couple of readASTFileSignature improvements (NFC) * Strength reduce a std::function to a function pointer, * Factor out checking the AST file magic number, * Add a brief doc comment to readAStFileSignature Thanks to Chandler for spotting these oddities. llvm-svn: 233050
2015-03-24 12:43:52 +08:00
if (!startsWithASTFileMagic(Stream))
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
return true;
finish converting the normal cases in ASTReader to use the new BitstreamCursor APIs. llvm-svn: 172937
2013-01-20 08:56:42 +08:00
// Scan for the CONTROL_BLOCK_ID block.
Modify ASTReaderListener to allow visiting the input files of an AST file. We can pass such an input-file-visiting ASTReaderListener to ASTReader::readASTFileControlBlock. llvm-svn: 181238
2013-05-07 03:23:40 +08:00
if (SkipCursorToBlock(Stream, CONTROL_BLOCK_ID))
finish converting the normal cases in ASTReader to use the new BitstreamCursor APIs. llvm-svn: 172937
2013-01-20 08:56:42 +08:00
return true;
Modify ASTReaderListener to allow visiting the input files of an AST file. We can pass such an input-file-visiting ASTReaderListener to ASTReader::readASTFileControlBlock. llvm-svn: 181238
2013-05-07 03:23:40 +08:00
bool NeedsInputFiles = Listener.needsInputFileVisitation();
Add dependencies from imported modules with -MD Add module dependencies to the dependency files created by -MD/-MMD/etc. by attaching an ASTReaderListener that will call into the dependency file generator when a module input file is seen in the serialized AST. llvm-svn: 203208
2014-03-07 14:40:32 +08:00
bool NeedsSystemInputFiles = Listener.needsSystemInputFileVisitation();
[modules] Load .pcm files specified by -fmodule-file lazily. llvm-svn: 220731
2014-10-28 07:01:16 +08:00
bool NeedsImports = Listener.needsImportVisitation();
Modify ASTReaderListener to allow visiting the input files of an AST file. We can pass such an input-file-visiting ASTReaderListener to ASTReader::readASTFileControlBlock. llvm-svn: 181238
2013-05-07 03:23:40 +08:00
BitstreamCursor InputFilesCursor;
[modules] Write the options records to a separate subblock rather than writing them directly to the control block. These are fairly large, and in a build with lots of modules / chained PCH, we don't need to read most of them. No functionality change intended. llvm-svn: 247055
2015-09-09 03:40:14 +08:00
RecordData Record;
std::string ModuleDir;
Introduce module file extensions to piggy-back data onto module files. Introduce the notion of a module file extension, which introduces additional information into a module file at the time it is built that can then be queried when the module file is read. Module file extensions are identified by a block name (which must be unique to the extension) and can write any bitstream records into their own extension block within the module file. When a module file is loaded, any extension blocks are matched up with module file extension readers, that are per-module-file and are given access to the input bitstream. Note that module file extensions can only be introduced by programmatic clients that have access to the CompilerInvocation. There is only one such extension at the moment, which is used for testing the module file extension harness. As a future direction, one could imagine allowing the plugin mechanism to introduce new module file extensions. llvm-svn: 251955
2015-11-04 02:33:07 +08:00
bool DoneWithControlBlock = false;
while (!DoneWithControlBlock) {
[modules] Write the options records to a separate subblock rather than writing them directly to the control block. These are fairly large, and in a build with lots of modules / chained PCH, we don't need to read most of them. No functionality change intended. llvm-svn: 247055
2015-09-09 03:40:14 +08:00
llvm::BitstreamEntry Entry = Stream.advance();
switch (Entry.Kind) {
case llvm::BitstreamEntry::SubBlock: {
switch (Entry.ID) {
case OPTIONS_BLOCK_ID: {
std::string IgnoredSuggestedPredefines;
if (ReadOptionsBlock(Stream, ARR_ConfigurationMismatch | ARR_OutOfDate,
/*AllowCompatibleConfigurationMismatch*/ false,
Listener, IgnoredSuggestedPredefines) != Success)
return true;
break;
}
case INPUT_FILES_BLOCK_ID:
InputFilesCursor = Stream;
if (Stream.SkipBlock() ||
(NeedsInputFiles &&
ReadBlockAbbrevs(InputFilesCursor, INPUT_FILES_BLOCK_ID)))
return true;
break;
Modify ASTReaderListener to allow visiting the input files of an AST file. We can pass such an input-file-visiting ASTReaderListener to ASTReader::readASTFileControlBlock. llvm-svn: 181238
2013-05-07 03:23:40 +08:00
[modules] Write the options records to a separate subblock rather than writing them directly to the control block. These are fairly large, and in a build with lots of modules / chained PCH, we don't need to read most of them. No functionality change intended. llvm-svn: 247055
2015-09-09 03:40:14 +08:00
default:
if (Stream.SkipBlock())
return true;
Modify ASTReaderListener to allow visiting the input files of an AST file. We can pass such an input-file-visiting ASTReaderListener to ASTReader::readASTFileControlBlock. llvm-svn: 181238
2013-05-07 03:23:40 +08:00
break;
}
[modules] Write the options records to a separate subblock rather than writing them directly to the control block. These are fairly large, and in a build with lots of modules / chained PCH, we don't need to read most of them. No functionality change intended. llvm-svn: 247055
2015-09-09 03:40:14 +08:00
continue;
Modify ASTReaderListener to allow visiting the input files of an AST file. We can pass such an input-file-visiting ASTReaderListener to ASTReader::readASTFileControlBlock. llvm-svn: 181238
2013-05-07 03:23:40 +08:00
}
[modules] Write the options records to a separate subblock rather than writing them directly to the control block. These are fairly large, and in a build with lots of modules / chained PCH, we don't need to read most of them. No functionality change intended. llvm-svn: 247055
2015-09-09 03:40:14 +08:00
case llvm::BitstreamEntry::EndBlock:
Introduce module file extensions to piggy-back data onto module files. Introduce the notion of a module file extension, which introduces additional information into a module file at the time it is built that can then be queried when the module file is read. Module file extensions are identified by a block name (which must be unique to the extension) and can write any bitstream records into their own extension block within the module file. When a module file is loaded, any extension blocks are matched up with module file extension readers, that are per-module-file and are given access to the input bitstream. Note that module file extensions can only be introduced by programmatic clients that have access to the CompilerInvocation. There is only one such extension at the moment, which is used for testing the module file extension harness. As a future direction, one could imagine allowing the plugin mechanism to introduce new module file extensions. llvm-svn: 251955
2015-11-04 02:33:07 +08:00
DoneWithControlBlock = true;
break;
[modules] Write the options records to a separate subblock rather than writing them directly to the control block. These are fairly large, and in a build with lots of modules / chained PCH, we don't need to read most of them. No functionality change intended. llvm-svn: 247055
2015-09-09 03:40:14 +08:00
case llvm::BitstreamEntry::Error:
finish converting the normal cases in ASTReader to use the new BitstreamCursor APIs. llvm-svn: 172937
2013-01-20 08:56:42 +08:00
return true;
[modules] Write the options records to a separate subblock rather than writing them directly to the control block. These are fairly large, and in a build with lots of modules / chained PCH, we don't need to read most of them. No functionality change intended. llvm-svn: 247055
2015-09-09 03:40:14 +08:00
case llvm::BitstreamEntry::Record:
break;
}
Introduce module file extensions to piggy-back data onto module files. Introduce the notion of a module file extension, which introduces additional information into a module file at the time it is built that can then be queried when the module file is read. Module file extensions are identified by a block name (which must be unique to the extension) and can write any bitstream records into their own extension block within the module file. When a module file is loaded, any extension blocks are matched up with module file extension readers, that are per-module-file and are given access to the input bitstream. Note that module file extensions can only be introduced by programmatic clients that have access to the CompilerInvocation. There is only one such extension at the moment, which is used for testing the module file extension harness. As a future direction, one could imagine allowing the plugin mechanism to introduce new module file extensions. llvm-svn: 251955
2015-11-04 02:33:07 +08:00
if (DoneWithControlBlock) break;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
Record.clear();
update to use the new BitcodeCursor readRecord that takes a StringRef blob parameter, and adopt "advance" in more places. llvm-svn: 172951
2013-01-20 10:38:54 +08:00
StringRef Blob;
unsigned RecCode = Stream.readRecord(Entry.ID, Record, &Blob);
finish converting the normal cases in ASTReader to use the new BitstreamCursor APIs. llvm-svn: 172937
2013-01-20 08:56:42 +08:00
switch ((ControlRecordTypes)RecCode) {
case METADATA: {
if (Record[0] != VERSION_MAJOR)
return true;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
<rdar://problem/13509689> Introduce -module-file-info option that provides information about a particular module file. This option can be useful for end users who want to know why they ended up with a ton of different variants of the "std" module in their module cache. This problem should go away over time, as we reduce the need for module variants, but it will never go away entirely. llvm-svn: 178148
2013-03-28 00:47:18 +08:00
if (Listener.ReadFullVersionInformation(Blob))
finish converting the normal cases in ASTReader to use the new BitstreamCursor APIs. llvm-svn: 172937
2013-01-20 08:56:42 +08:00
return true;
<rdar://problem/13509689> Introduce -module-file-info option that provides information about a particular module file. This option can be useful for end users who want to know why they ended up with a ton of different variants of the "std" module in their module cache. This problem should go away over time, as we reduce the need for module variants, but it will never go away entirely. llvm-svn: 178148
2013-03-28 00:47:18 +08:00
finish converting the normal cases in ASTReader to use the new BitstreamCursor APIs. llvm-svn: 172937
2013-01-20 08:56:42 +08:00
break;
}
Add module name and module map file to -module-file-info llvm-svn: 206217
2014-04-15 06:12:44 +08:00
case MODULE_NAME:
Listener.ReadModuleName(Blob);
break;
[modules] Instead of storing absolute paths in a .pcm file, store the path to the root of the module and use paths relative to that directory wherever possible. This is a step towards allowing explicit modules to be relocated without being rebuilt, which is important for some kinds of distributed builds, for good paths in diagnostics, and for appropriate .d output. This is a recommit of r223443, reverted in r223465; when joining together imported file paths, we now use the system's separator rather than always using '/'. This avoids path mismatches between the original module build and the module user on Windows (at least, in some cases). A more comprehensive fix will follow. llvm-svn: 223539
2014-12-06 06:42:13 +08:00
case MODULE_DIRECTORY:
ModuleDir = Blob;
break;
Verify all the module map files for a pcm are the same on load We already verified the primary module map file (either the one that defines the top-level module, or the one that allows inferring it if it is an inferred framework module). Now we also verify any other module map files that define submodules, such as when there is a module.private.modulemap file. llvm-svn: 215455
2014-08-13 00:42:33 +08:00
case MODULE_MAP_FILE: {
unsigned Idx = 0;
[modules] Instead of storing absolute paths in a .pcm file, store the path to the root of the module and use paths relative to that directory wherever possible. This is a step towards allowing explicit modules to be relocated without being rebuilt, which is important for some kinds of distributed builds, for good paths in diagnostics, and for appropriate .d output. This is a recommit of r223443, reverted in r223465; when joining together imported file paths, we now use the system's separator rather than always using '/'. This avoids path mismatches between the original module build and the module user on Windows (at least, in some cases). A more comprehensive fix will follow. llvm-svn: 223539
2014-12-06 06:42:13 +08:00
auto Path = ReadString(Record, Idx);
ResolveImportedPath(Path, ModuleDir);
Listener.ReadModuleMapFile(Path);
Add module name and module map file to -module-file-info llvm-svn: 206217
2014-04-15 06:12:44 +08:00
break;
Verify all the module map files for a pcm are the same on load We already verified the primary module map file (either the one that defines the top-level module, or the one that allows inferring it if it is an inferred framework module). Now we also verify any other module map files that define submodules, such as when there is a module.private.modulemap file. llvm-svn: 215455
2014-08-13 00:42:33 +08:00
}
Modify ASTReaderListener to allow visiting the input files of an AST file. We can pass such an input-file-visiting ASTReaderListener to ASTReader::readASTFileControlBlock. llvm-svn: 181238
2013-05-07 03:23:40 +08:00
case INPUT_FILE_OFFSETS: {
if (!NeedsInputFiles)
break;
unsigned NumInputFiles = Record[0];
unsigned NumUserFiles = Record[1];
[modules] Improve llvm-bcanalyzer output on AST files a little. No functionality change. llvm-svn: 229145
2015-02-14 03:48:37 +08:00
const uint64_t *InputFileOffs = (const uint64_t *)Blob.data();
Modify ASTReaderListener to allow visiting the input files of an AST file. We can pass such an input-file-visiting ASTReaderListener to ASTReader::readASTFileControlBlock. llvm-svn: 181238
2013-05-07 03:23:40 +08:00
for (unsigned I = 0; I != NumInputFiles; ++I) {
// Go find this input file.
bool isSystemFile = I >= NumUserFiles;
Add dependencies from imported modules with -MD Add module dependencies to the dependency files created by -MD/-MMD/etc. by attaching an ASTReaderListener that will call into the dependency file generator when a module input file is seen in the serialized AST. llvm-svn: 203208
2014-03-07 14:40:32 +08:00
if (isSystemFile && !NeedsSystemInputFiles)
break; // the rest are system input files
Modify ASTReaderListener to allow visiting the input files of an AST file. We can pass such an input-file-visiting ASTReaderListener to ASTReader::readASTFileControlBlock. llvm-svn: 181238
2013-05-07 03:23:40 +08:00
BitstreamCursor &Cursor = InputFilesCursor;
SavedStreamPosition SavedPosition(Cursor);
Cursor.JumpToBit(InputFileOffs[I]);
unsigned Code = Cursor.ReadCode();
RecordData Record;
StringRef Blob;
bool shouldContinue = false;
switch ((InputFileRecordTypes)Cursor.readRecord(Code, Record, &Blob)) {
case INPUT_FILE:
[Modules] Make sure that the synthesized file "__inferred_module.map" doesn't show up as dependency of a module file. Follow-up for rdar://15459210 llvm-svn: 203882
2014-03-14 10:26:31 +08:00
bool Overridden = static_cast<bool>(Record[3]);
[modules] Instead of storing absolute paths in a .pcm file, store the path to the root of the module and use paths relative to that directory wherever possible. This is a step towards allowing explicit modules to be relocated without being rebuilt, which is important for some kinds of distributed builds, for good paths in diagnostics, and for appropriate .d output. This is a recommit of r223443, reverted in r223465; when joining together imported file paths, we now use the system's separator rather than always using '/'. This avoids path mismatches between the original module build and the module user on Windows (at least, in some cases). A more comprehensive fix will follow. llvm-svn: 223539
2014-12-06 06:42:13 +08:00
std::string Filename = Blob;
ResolveImportedPath(Filename, ModuleDir);
[modules] Change the way we deal with .d output for explicitly-specified module files: include the .pcm file itself in the .d output, rather than including its own input files. Other forms of module file continue to be transparent for .d output. Arguably, the input files for the .pcm file are still inputs to the compilation, but that's unnecessary for make-like build systems (where the mtime of the .pcm file is sufficient) and harmful for smarter build systems that know about module files and want to track only the local dependencies. llvm-svn: 244923
2015-08-14 01:57:10 +08:00
shouldContinue = Listener.visitInputFile(
Filename, isSystemFile, Overridden, /*IsExplicitModule*/false);
Modify ASTReaderListener to allow visiting the input files of an AST file. We can pass such an input-file-visiting ASTReaderListener to ASTReader::readASTFileControlBlock. llvm-svn: 181238
2013-05-07 03:23:40 +08:00
break;
}
if (!shouldContinue)
break;
}
break;
}
[modules] Load .pcm files specified by -fmodule-file lazily. llvm-svn: 220731
2014-10-28 07:01:16 +08:00
case IMPORTS: {
if (!NeedsImports)
break;
unsigned Idx = 0, N = Record.size();
while (Idx < N) {
// Read information about the AST file.
Remove unused variable. llvm-svn: 220738
2014-10-28 07:25:15 +08:00
Idx += 5; // ImportLoc, Size, ModTime, Signature
[modules] Instead of storing absolute paths in a .pcm file, store the path to the root of the module and use paths relative to that directory wherever possible. This is a step towards allowing explicit modules to be relocated without being rebuilt, which is important for some kinds of distributed builds, for good paths in diagnostics, and for appropriate .d output. This is a recommit of r223443, reverted in r223465; when joining together imported file paths, we now use the system's separator rather than always using '/'. This avoids path mismatches between the original module build and the module user on Windows (at least, in some cases). A more comprehensive fix will follow. llvm-svn: 223539
2014-12-06 06:42:13 +08:00
std::string Filename = ReadString(Record, Idx);
ResolveImportedPath(Filename, ModuleDir);
Listener.visitImport(Filename);
Make module files passed to a module build via -fmodule-file= available to consumers of that module. Previously, such a file would only be available if the module happened to actually import something from that module. llvm-svn: 232583
2015-03-18 09:42:29 +08:00
}
break;
}
finish converting the normal cases in ASTReader to use the new BitstreamCursor APIs. llvm-svn: 172937
2013-01-20 08:56:42 +08:00
default:
// No other validation to perform.
break;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
}
Introduce module file extensions to piggy-back data onto module files. Introduce the notion of a module file extension, which introduces additional information into a module file at the time it is built that can then be queried when the module file is read. Module file extensions are identified by a block name (which must be unique to the extension) and can write any bitstream records into their own extension block within the module file. When a module file is loaded, any extension blocks are matched up with module file extension readers, that are per-module-file and are given access to the input bitstream. Note that module file extensions can only be introduced by programmatic clients that have access to the CompilerInvocation. There is only one such extension at the moment, which is used for testing the module file extension harness. As a future direction, one could imagine allowing the plugin mechanism to introduce new module file extensions. llvm-svn: 251955
2015-11-04 02:33:07 +08:00
// Look for module file extension blocks, if requested.
if (FindModuleFileExtensions) {
while (!SkipCursorToBlock(Stream, EXTENSION_BLOCK_ID)) {
bool DoneWithExtensionBlock = false;
while (!DoneWithExtensionBlock) {
llvm::BitstreamEntry Entry = Stream.advance();
switch (Entry.Kind) {
case llvm::BitstreamEntry::SubBlock:
if (Stream.SkipBlock())
return true;
continue;
case llvm::BitstreamEntry::EndBlock:
DoneWithExtensionBlock = true;
continue;
case llvm::BitstreamEntry::Error:
return true;
case llvm::BitstreamEntry::Record:
break;
}
Record.clear();
StringRef Blob;
unsigned RecCode = Stream.readRecord(Entry.ID, Record, &Blob);
switch (RecCode) {
case EXTENSION_METADATA: {
ModuleFileExtensionMetadata Metadata;
if (parseModuleFileExtensionMetadata(Record, Blob, Metadata))
return true;
Listener.readModuleFileExtension(Metadata);
break;
}
}
}
}
}
return false;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
Introduce a PCHContainerOperations interface (NFC). A PCHContainerOperations abstract interface provides operations for creating and unwrapping containers for serialized ASTs (precompiled headers and clang modules). The default implementation is RawPCHContainerOperations, which uses a flat file for the output. The main application for this interface will be an ObjectFilePCHContainerOperations implementation that uses LLVM to wrap the module in an ELF/Mach-O/COFF container to store debug info alongside the AST. rdar://problem/20091852 llvm-svn: 240225
2015-06-21 02:53:08 +08:00
bool ASTReader::isAcceptableASTFile(
StringRef Filename, FileManager &FileMgr,
Make the clang module container format selectable from the command line. - introduces a new cc1 option -fmodule-format=[raw,obj] with 'raw' being the default - supports arbitrary module container formats that libclang is agnostic to - adds the format to the module hash to avoid collisions - splits the old PCHContainerOperations into PCHContainerWriter and a PCHContainerReader. Thanks to Richard Smith for reviewing this patch! llvm-svn: 242499
2015-07-17 09:19:54 +08:00
const PCHContainerReader &PCHContainerRdr, const LangOptions &LangOpts,
Introduce a PCHContainerOperations interface (NFC). A PCHContainerOperations abstract interface provides operations for creating and unwrapping containers for serialized ASTs (precompiled headers and clang modules). The default implementation is RawPCHContainerOperations, which uses a flat file for the output. The main application for this interface will be an ObjectFilePCHContainerOperations implementation that uses LLVM to wrap the module in an ELF/Mach-O/COFF container to store debug info alongside the AST. rdar://problem/20091852 llvm-svn: 240225
2015-06-21 02:53:08 +08:00
const TargetOptions &TargetOpts, const PreprocessorOptions &PPOpts,
std::string ExistingModuleCachePath) {
[PCH/Modules] Check that the specific module cache path the PCH was built with, is the same as the one in the current compiler invocation. If they differ reject the PCH. This protects against the badness occurring from getting modules loaded from different module caches (see crashes). rdar://19889860 llvm-svn: 229909
2015-02-20 04:12:20 +08:00
SimplePCHValidator validator(LangOpts, TargetOpts, PPOpts,
ExistingModuleCachePath, FileMgr);
Make the clang module container format selectable from the command line. - introduces a new cc1 option -fmodule-format=[raw,obj] with 'raw' being the default - supports arbitrary module container formats that libclang is agnostic to - adds the format to the module hash to avoid collisions - splits the old PCHContainerOperations into PCHContainerWriter and a PCHContainerReader. Thanks to Richard Smith for reviewing this patch! llvm-svn: 242499
2015-07-17 09:19:54 +08:00
return !readASTFileControlBlock(Filename, FileMgr, PCHContainerRdr,
Introduce module file extensions to piggy-back data onto module files. Introduce the notion of a module file extension, which introduces additional information into a module file at the time it is built that can then be queried when the module file is read. Module file extensions are identified by a block name (which must be unique to the extension) and can write any bitstream records into their own extension block within the module file. When a module file is loaded, any extension blocks are matched up with module file extension readers, that are per-module-file and are given access to the input bitstream. Note that module file extensions can only be introduced by programmatic clients that have access to the CompilerInvocation. There is only one such extension at the moment, which is used for testing the module file extension harness. As a future direction, one could imagine allowing the plugin mechanism to introduce new module file extensions. llvm-svn: 251955
2015-11-04 02:33:07 +08:00
/*FindModuleFileExtensions=*/false,
Introduce a PCHContainerOperations interface (NFC). A PCHContainerOperations abstract interface provides operations for creating and unwrapping containers for serialized ASTs (precompiled headers and clang modules). The default implementation is RawPCHContainerOperations, which uses a flat file for the output. The main application for this interface will be an ObjectFilePCHContainerOperations implementation that uses LLVM to wrap the module in an ELF/Mach-O/COFF container to store debug info alongside the AST. rdar://problem/20091852 llvm-svn: 240225
2015-06-21 02:53:08 +08:00
validator);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
When module umbrellas change, rebuild them With the VFS, it is easy to hit modified umbrellas by overriding the umbrella header, and what we want is to rebuild, not to fail. llvm-svn: 205975
2014-04-11 01:57:43 +08:00
ASTReader::ASTReadResult
ASTReader::ReadSubmoduleBlock(ModuleFile &F, unsigned ClientLoadCapabilities) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
// Enter the submodule block.
if (F.Stream.EnterSubBlock(SUBMODULE_BLOCK_ID)) {
Error("malformed submodule block record in AST file");
When module umbrellas change, rebuild them With the VFS, it is easy to hit modified umbrellas by overriding the umbrella header, and what we want is to rebuild, not to fail. llvm-svn: 205975
2014-04-11 01:57:43 +08:00
return Failure;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap();
bool First = true;
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
Module *CurrentModule = nullptr;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
RecordData Record;
while (true) {
finish converting the normal cases in ASTReader to use the new BitstreamCursor APIs. llvm-svn: 172937
2013-01-20 08:56:42 +08:00
llvm::BitstreamEntry Entry = F.Stream.advanceSkippingSubblocks();
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
finish converting the normal cases in ASTReader to use the new BitstreamCursor APIs. llvm-svn: 172937
2013-01-20 08:56:42 +08:00
switch (Entry.Kind) {
case llvm::BitstreamEntry::SubBlock: // Handled for us already.
case llvm::BitstreamEntry::Error:
Error("malformed block record in AST file");
When module umbrellas change, rebuild them With the VFS, it is easy to hit modified umbrellas by overriding the umbrella header, and what we want is to rebuild, not to fail. llvm-svn: 205975
2014-04-11 01:57:43 +08:00
return Failure;
finish converting the normal cases in ASTReader to use the new BitstreamCursor APIs. llvm-svn: 172937
2013-01-20 08:56:42 +08:00
case llvm::BitstreamEntry::EndBlock:
When module umbrellas change, rebuild them With the VFS, it is easy to hit modified umbrellas by overriding the umbrella header, and what we want is to rebuild, not to fail. llvm-svn: 205975
2014-04-11 01:57:43 +08:00
return Success;
finish converting the normal cases in ASTReader to use the new BitstreamCursor APIs. llvm-svn: 172937
2013-01-20 08:56:42 +08:00
case llvm::BitstreamEntry::Record:
// The interesting case.
break;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
finish converting the normal cases in ASTReader to use the new BitstreamCursor APIs. llvm-svn: 172937
2013-01-20 08:56:42 +08:00
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
// Read a record.
update to use the new BitcodeCursor readRecord that takes a StringRef blob parameter, and adopt "advance" in more places. llvm-svn: 172951
2013-01-20 10:38:54 +08:00
StringRef Blob;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
Record.clear();
Factor out common checks from module map deserialization. No functionality change. llvm-svn: 220521
2014-10-24 06:12:14 +08:00
auto Kind = F.Stream.readRecord(Entry.ID, Record, &Blob);
if ((Kind == SUBMODULE_METADATA) != First) {
Error("submodule metadata record should be at beginning of block");
return Failure;
}
First = false;
// Submodule information is only valid if we have a current module.
// FIXME: Should we error on these cases?
if (!CurrentModule && Kind != SUBMODULE_METADATA &&
Kind != SUBMODULE_DEFINITION)
continue;
switch (Kind) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
default: // Default behavior: ignore.
break;
Factor out common checks from module map deserialization. No functionality change. llvm-svn: 220521
2014-10-24 06:12:14 +08:00
case SUBMODULE_DEFINITION: {
Make sure that Module::ConfigMacrosExhaustive gets initialized and deserialized correctly. This fixes regressions introduced in r177466 that caused several module tests to fail sporadically. llvm-svn: 177481
2013-03-20 11:59:18 +08:00
if (Record.size() < 8) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
Error("malformed module definition");
When module umbrellas change, rebuild them With the VFS, it is easy to hit modified umbrellas by overriding the umbrella header, and what we want is to rebuild, not to fail. llvm-svn: 205975
2014-04-11 01:57:43 +08:00
return Failure;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
Factor out common checks from module map deserialization. No functionality change. llvm-svn: 220521
2014-10-24 06:12:14 +08:00
update to use the new BitcodeCursor readRecord that takes a StringRef blob parameter, and adopt "advance" in more places. llvm-svn: 172951
2013-01-20 10:38:54 +08:00
StringRef Name = Blob;
Module [extern_c] attribute: inherit to submodules, don't write 'extern "C"' blocks when building in C mode, and serialize and deserialize the attribute. llvm-svn: 203317
2014-03-08 08:03:56 +08:00
unsigned Idx = 0;
SubmoduleID GlobalID = getGlobalSubmoduleID(F, Record[Idx++]);
SubmoduleID Parent = getGlobalSubmoduleID(F, Record[Idx++]);
bool IsFramework = Record[Idx++];
bool IsExplicit = Record[Idx++];
bool IsSystem = Record[Idx++];
bool IsExternC = Record[Idx++];
bool InferSubmodules = Record[Idx++];
bool InferExplicitSubmodules = Record[Idx++];
bool InferExportWildcard = Record[Idx++];
bool ConfigMacrosExhaustive = Record[Idx++];
Make sure that Module::ConfigMacrosExhaustive gets initialized and deserialized correctly. This fixes regressions introduced in r177466 that caused several module tests to fail sporadically. llvm-svn: 177481
2013-03-20 11:59:18 +08:00
Allow multiple modules with the same name to coexist in the module cache To differentiate between two modules with the same name, we will consider the path the module map file that they are defined by* part of the ‘key’ for looking up the precompiled module (pcm file). Specifically, this patch renames the precompiled module (pcm) files from cache-path/<module hash>/Foo.pcm to cache-path/<module hash>/Foo-<hash of module map path>.pcm In addition, I’ve taught the ASTReader to re-resolve the names of imported modules during module loading so that if the header search context changes between when a module was originally built and when it is loaded we can rebuild it if necessary. For example, if module A imports module B first time: clang -I /path/to/A -I /path/to/B ... second time: clang -I /path/to/A -I /different/path/to/B ... will now rebuild A as expected. * in the case of inferred modules, we use the module map file that allowed the inference, not the __inferred_module.map file, since the inferred file path is the same for every inferred module. llvm-svn: 206201
2014-04-15 02:00:01 +08:00
Module *ParentModule = nullptr;
Refactor the module map file used for uniquing a module name out of class Module. It's almost always going to be the same as getContainingModule() for top-level modules, so just add a map to cover the remaining cases. This lets us do less bookkeeping to keep the ModuleMap fields up to date. llvm-svn: 215268
2014-08-09 08:57:23 +08:00
if (Parent)
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
ParentModule = getSubmodule(Parent);
Allow multiple modules with the same name to coexist in the module cache To differentiate between two modules with the same name, we will consider the path the module map file that they are defined by* part of the ‘key’ for looking up the precompiled module (pcm file). Specifically, this patch renames the precompiled module (pcm) files from cache-path/<module hash>/Foo.pcm to cache-path/<module hash>/Foo-<hash of module map path>.pcm In addition, I’ve taught the ASTReader to re-resolve the names of imported modules during module loading so that if the header search context changes between when a module was originally built and when it is loaded we can rebuild it if necessary. For example, if module A imports module B first time: clang -I /path/to/A -I /path/to/B ... second time: clang -I /path/to/A -I /different/path/to/B ... will now rebuild A as expected. * in the case of inferred modules, we use the module map file that allowed the inference, not the __inferred_module.map file, since the inferred file path is the same for every inferred module. llvm-svn: 206201
2014-04-15 02:00:01 +08:00
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
// Retrieve this (sub)module from the module map, creating it if
// necessary.
Refactor the module map file used for uniquing a module name out of class Module. It's almost always going to be the same as getContainingModule() for top-level modules, so just add a map to cover the remaining cases. This lets us do less bookkeeping to keep the ModuleMap fields up to date. llvm-svn: 215268
2014-08-09 08:57:23 +08:00
CurrentModule = ModMap.findOrCreateModule(Name, ParentModule, IsFramework,
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
IsExplicit).first;
Refactor the module map file used for uniquing a module name out of class Module. It's almost always going to be the same as getContainingModule() for top-level modules, so just add a map to cover the remaining cases. This lets us do less bookkeeping to keep the ModuleMap fields up to date. llvm-svn: 215268
2014-08-09 08:57:23 +08:00
// FIXME: set the definition loc for CurrentModule, or call
// ModMap.setInferredModuleAllowedBy()
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
SubmoduleID GlobalIndex = GlobalID - NUM_PREDEF_SUBMODULE_IDS;
if (GlobalIndex >= SubmodulesLoaded.size() ||
SubmodulesLoaded[GlobalIndex]) {
Error("too many submodules");
When module umbrellas change, rebuild them With the VFS, it is easy to hit modified umbrellas by overriding the umbrella header, and what we want is to rebuild, not to fail. llvm-svn: 205975
2014-04-11 01:57:43 +08:00
return Failure;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
Detect when we end up trying to load conflicting module files. This can happen when one abuses precompiled headers by passing more -D options when using a precompiled hedaer than when it was built. This is intentionally permitted by precompiled headers (and is exploited by some build environments), but causes problems for modules. First part of <rdar://problem/13165109>, detecting when something when horribly wrong. llvm-svn: 174554
2013-02-07 06:40:31 +08:00
<rdar://problem/13363214> Eliminate race condition between module rebuild and the global module index. The global module index was querying the file manager for each of the module files it knows about at load time, to prune out any out-of-date information. The file manager would then cache the results of the stat() falls used to find that module file. Later, the same translation unit could end up trying to import one of the module files that had previously been ignored by the module cache, but after some other Clang instance rebuilt the module file to bring it up-to-date. The stale stat() results in the file manager would trigger a second rebuild of the already-up-to-date module, causing failures down the line. The global module index now lazily resolves its module file references to actual AST reader module files only after the module file has been loaded, eliminating the stat-caching race. Moreover, the AST reader can communicate to its caller that a module file is missing (rather than simply being out-of-date), allowing us to simplify the module-loading logic and allowing the compiler to recover if a dependent module file ends up getting deleted. llvm-svn: 177367
2013-03-19 08:28:20 +08:00
if (!ParentModule) {
if (const FileEntry *CurFile = CurrentModule->getASTFile()) {
if (CurFile != F.File) {
if (!Diags.isDiagnosticInFlight()) {
Diag(diag::err_module_file_conflict)
<< CurrentModule->getTopLevelModuleName()
<< CurFile->getName()
<< F.File->getName();
}
When module umbrellas change, rebuild them With the VFS, it is easy to hit modified umbrellas by overriding the umbrella header, and what we want is to rebuild, not to fail. llvm-svn: 205975
2014-04-11 01:57:43 +08:00
return Failure;
Detect when we end up trying to load conflicting module files. This can happen when one abuses precompiled headers by passing more -D options when using a precompiled hedaer than when it was built. This is intentionally permitted by precompiled headers (and is exploited by some build environments), but causes problems for modules. First part of <rdar://problem/13165109>, detecting when something when horribly wrong. llvm-svn: 174554
2013-02-07 06:40:31 +08:00
}
}
<rdar://problem/13363214> Eliminate race condition between module rebuild and the global module index. The global module index was querying the file manager for each of the module files it knows about at load time, to prune out any out-of-date information. The file manager would then cache the results of the stat() falls used to find that module file. Later, the same translation unit could end up trying to import one of the module files that had previously been ignored by the module cache, but after some other Clang instance rebuilt the module file to bring it up-to-date. The stale stat() results in the file manager would trigger a second rebuild of the already-up-to-date module, causing failures down the line. The global module index now lazily resolves its module file references to actual AST reader module files only after the module file has been loaded, eliminating the stat-caching race. Moreover, the AST reader can communicate to its caller that a module file is missing (rather than simply being out-of-date), allowing us to simplify the module-loading logic and allowing the compiler to recover if a dependent module file ends up getting deleted. llvm-svn: 177367
2013-03-19 08:28:20 +08:00
CurrentModule->setASTFile(F.File);
Detect when we end up trying to load conflicting module files. This can happen when one abuses precompiled headers by passing more -D options when using a precompiled hedaer than when it was built. This is intentionally permitted by precompiled headers (and is exploited by some build environments), but causes problems for modules. First part of <rdar://problem/13165109>, detecting when something when horribly wrong. llvm-svn: 174554
2013-02-07 06:40:31 +08:00
}
Allow multiple modules with the same name to coexist in the module cache To differentiate between two modules with the same name, we will consider the path the module map file that they are defined by* part of the ‘key’ for looking up the precompiled module (pcm file). Specifically, this patch renames the precompiled module (pcm) files from cache-path/<module hash>/Foo.pcm to cache-path/<module hash>/Foo-<hash of module map path>.pcm In addition, I’ve taught the ASTReader to re-resolve the names of imported modules during module loading so that if the header search context changes between when a module was originally built and when it is loaded we can rebuild it if necessary. For example, if module A imports module B first time: clang -I /path/to/A -I /path/to/B ... second time: clang -I /path/to/A -I /different/path/to/B ... will now rebuild A as expected. * in the case of inferred modules, we use the module map file that allowed the inference, not the __inferred_module.map file, since the inferred file path is the same for every inferred module. llvm-svn: 206201
2014-04-15 02:00:01 +08:00
Add a function to ExternalASTSource that returns a descriptor that abstracts the commonalities between modules and PCH files that are needed to emit debug info for a module or precompiled header. llvm-svn: 241083
2015-07-01 01:39:43 +08:00
CurrentModule->Signature = F.Signature;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
CurrentModule->IsFromModuleFile = true;
CurrentModule->IsSystem = IsSystem || CurrentModule->IsSystem;
Module [extern_c] attribute: inherit to submodules, don't write 'extern "C"' blocks when building in C mode, and serialize and deserialize the attribute. llvm-svn: 203317
2014-03-08 08:03:56 +08:00
CurrentModule->IsExternC = IsExternC;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
CurrentModule->InferSubmodules = InferSubmodules;
CurrentModule->InferExplicitSubmodules = InferExplicitSubmodules;
CurrentModule->InferExportWildcard = InferExportWildcard;
Make sure that Module::ConfigMacrosExhaustive gets initialized and deserialized correctly. This fixes regressions introduced in r177466 that caused several module tests to fail sporadically. llvm-svn: 177481
2013-03-20 11:59:18 +08:00
CurrentModule->ConfigMacrosExhaustive = ConfigMacrosExhaustive;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
if (DeserializationListener)
DeserializationListener->ModuleRead(GlobalID, CurrentModule);
SubmodulesLoaded[GlobalIndex] = CurrentModule;
Implement parsing, AST, (de-)serialization, and placeholder global metadata for linking against the libraries/frameworks for imported modules. The module map language is extended with a new "link" directive that specifies what library or framework to link against when a module is imported, e.g., link "clangAST" or link framework "MyFramework" Importing the corresponding module (or any of its submodules) will eventually link against the named library/framework. For now, I've added some placeholder global metadata that encodes the imported libraries/frameworks, so that we can test that this information gets through to the IR. The format of the data is still under discussion. llvm-svn: 172437
2013-01-15 01:21:00 +08:00
<rdar://problem/12368093> Extend module maps with a 'conflict' declaration, and warn when a newly-imported module conflicts with an already-imported module. llvm-svn: 177577
2013-03-21 05:10:35 +08:00
// Clear out data that will be replaced by what is the module file.
Implement parsing, AST, (de-)serialization, and placeholder global metadata for linking against the libraries/frameworks for imported modules. The module map language is extended with a new "link" directive that specifies what library or framework to link against when a module is imported, e.g., link "clangAST" or link framework "MyFramework" Importing the corresponding module (or any of its submodules) will eventually link against the named library/framework. For now, I've added some placeholder global metadata that encodes the imported libraries/frameworks, so that we can test that this information gets through to the IR. The format of the data is still under discussion. llvm-svn: 172437
2013-01-15 01:21:00 +08:00
CurrentModule->LinkLibraries.clear();
Make sure that Module::ConfigMacrosExhaustive gets initialized and deserialized correctly. This fixes regressions introduced in r177466 that caused several module tests to fail sporadically. llvm-svn: 177481
2013-03-20 11:59:18 +08:00
CurrentModule->ConfigMacros.clear();
<rdar://problem/12368093> Extend module maps with a 'conflict' declaration, and warn when a newly-imported module conflicts with an already-imported module. llvm-svn: 177577
2013-03-21 05:10:35 +08:00
CurrentModule->UnresolvedConflicts.clear();
CurrentModule->Conflicts.clear();
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
break;
}
case SUBMODULE_UMBRELLA_HEADER: {
[modules] Retain the name as written for umbrella headers and directories, rather than converting to an absolute path. No observable change expected, but this allows us to correctly compute the module for an umbrella header, which later changes will require. llvm-svn: 237508
2015-05-16 10:28:53 +08:00
std::string Filename = Blob;
ResolveImportedPath(F, Filename);
if (auto *Umbrella = PP.getFileManager().getFile(Filename)) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
if (!CurrentModule->getUmbrellaHeader())
[modules] Retain the name as written for umbrella headers and directories, rather than converting to an absolute path. No observable change expected, but this allows us to correctly compute the module for an umbrella header, which later changes will require. llvm-svn: 237508
2015-05-16 10:28:53 +08:00
ModMap.setUmbrellaHeader(CurrentModule, Umbrella, Blob);
else if (CurrentModule->getUmbrellaHeader().Entry != Umbrella) {
Don't try to rebuild modules on umbrella header mismatch There are two issues here: 1) It's too late to rebuild at this point, because we won't go through removeModules and when we try to reload the new .pcm we'll get the old one instead. We might be able to call removeModules after an OutOfDate here, but I'm not yet confident that it is always safe to do so. 2) In practice, this check fails spuriously when the umbrella header appears to change because of a VFS change that means it maps to a different copy of the same file. Because of this, we just skip the check for now. llvm-svn: 230064
2015-02-21 05:46:39 +08:00
// This can be a spurious difference caused by changing the VFS to
// point to a different copy of the file, and it is too late to
// to rebuild safely.
// FIXME: If we wrote the virtual paths instead of the 'real' paths,
// after input file validation only real problems would remain and we
// could just error. For now, assume it's okay.
break;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
}
break;
}
[modules] Support combining 'textual' with 'private'. llvm-svn: 220589
2014-10-25 04:23:01 +08:00
case SUBMODULE_HEADER:
case SUBMODULE_EXCLUDED_HEADER:
case SUBMODULE_PRIVATE_HEADER:
// We lazily associate headers with their modules via the HeaderInfo table.
[Modules] Don't eagerly load and associate all the module header files. In a module-enabled Cocoa PCH file, we spend a lot of time stat'ing the headers in order to associate the FileEntries with their modules and support implicit module import. Use a more lazy scheme by enhancing HeaderInfoTable to store extra info about the module that a header belongs to, and associate it with its module only when there is a request for loading the header info for a particular file. Part of rdar://13391765 llvm-svn: 176976
2013-03-14 05:13:51 +08:00
// FIXME: Re-evaluate this section; maybe only store InputFile IDs instead
// of complete filenames or remove it entirely.
[modules] Support combining 'textual' with 'private'. llvm-svn: 220589
2014-10-25 04:23:01 +08:00
break;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
[modules] Support combining 'textual' with 'private'. llvm-svn: 220589
2014-10-25 04:23:01 +08:00
case SUBMODULE_TEXTUAL_HEADER:
case SUBMODULE_PRIVATE_TEXTUAL_HEADER:
// FIXME: Textual headers are not marked in the HeaderInfo table. Load
// them here.
break;
This patch adds new private headers to the module map. Private headers may be included from within the module, but not from outside the module. llvm-svn: 184471
2013-06-21 05:14:14 +08:00
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
case SUBMODULE_TOPHEADER: {
[Modules] Resolve top-headers of modules lazily. This allows resolving top-header filenames of modules to FileEntries when we need them, not eagerly. Note that that this breaks ABI for libclang functions clang_Module_getTopLevelHeader / clang_Module_getNumTopLevelHeaders but this is fine because they are experimental and not widely used yet. llvm-svn: 176975
2013-03-14 05:13:43 +08:00
CurrentModule->addTopHeaderFilename(Blob);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
break;
}
case SUBMODULE_UMBRELLA_DIR: {
[modules] Retain the name as written for umbrella headers and directories, rather than converting to an absolute path. No observable change expected, but this allows us to correctly compute the module for an umbrella header, which later changes will require. llvm-svn: 237508
2015-05-16 10:28:53 +08:00
std::string Dirname = Blob;
ResolveImportedPath(F, Dirname);
if (auto *Umbrella = PP.getFileManager().getDirectory(Dirname)) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
if (!CurrentModule->getUmbrellaDir())
[modules] Retain the name as written for umbrella headers and directories, rather than converting to an absolute path. No observable change expected, but this allows us to correctly compute the module for an umbrella header, which later changes will require. llvm-svn: 237508
2015-05-16 10:28:53 +08:00
ModMap.setUmbrellaDir(CurrentModule, Umbrella, Blob);
else if (CurrentModule->getUmbrellaDir().Entry != Umbrella) {
When module umbrellas change, rebuild them With the VFS, it is easy to hit modified umbrellas by overriding the umbrella header, and what we want is to rebuild, not to fail. llvm-svn: 205975
2014-04-11 01:57:43 +08:00
if ((ClientLoadCapabilities & ARR_OutOfDate) == 0)
Error("mismatched umbrella directories in submodule");
return OutOfDate;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
}
break;
}
case SUBMODULE_METADATA: {
F.BaseSubmoduleID = getTotalNumSubmodules();
F.LocalNumSubmodules = Record[0];
unsigned LocalBaseSubmoduleID = Record[1];
if (F.LocalNumSubmodules > 0) {
// Introduce the global -> local mapping for submodules within this
// module.
GlobalSubmoduleMap.insert(std::make_pair(getTotalNumSubmodules()+1,&F));
// Introduce the local -> global mapping for submodules within this
// module.
F.SubmoduleRemap.insertOrReplace(
std::make_pair(LocalBaseSubmoduleID,
F.BaseSubmoduleID - LocalBaseSubmoduleID));
When loading a module with no local entities, still bump the size of the tables that correspond to ContinuousRangeMaps, since the keys to those maps need to be unique, or we may map to the wrong offset. This fixes a crash + malformed AST file seen when loading some modules that import Cocoa on Darwin, which is a module with no contents except imports of other modules. Unfortunately I have not been able to find a reduced test case that reproduces this problem. Also add an assert that we aren't mapping one key to multiple values in CRM. We ought to be able to say there are no duplicate keys at all, but there are a bunch of 0 -> 0 mappings that are showing up, probably coming from the source location table. llvm-svn: 215810
2014-08-16 12:54:18 +08:00
Revert most of r215810, which is no longer needed Now that we no longer add mappings when there are no local entities, there is no need to always bump the size of the tables that correspond to ContinuousRangeMaps. llvm-svn: 220208
2014-10-21 00:27:32 +08:00
SubmodulesLoaded.resize(SubmodulesLoaded.size() + F.LocalNumSubmodules);
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
break;
}
case SUBMODULE_IMPORTS: {
for (unsigned Idx = 0; Idx != Record.size(); ++Idx) {
<rdar://problem/12368093> Extend module maps with a 'conflict' declaration, and warn when a newly-imported module conflicts with an already-imported module. llvm-svn: 177577
2013-03-21 05:10:35 +08:00
UnresolvedModuleRef Unresolved;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
Unresolved.File = &F;
Unresolved.Mod = CurrentModule;
Unresolved.ID = Record[Idx];
<rdar://problem/12368093> Extend module maps with a 'conflict' declaration, and warn when a newly-imported module conflicts with an already-imported module. llvm-svn: 177577
2013-03-21 05:10:35 +08:00
Unresolved.Kind = UnresolvedModuleRef::Import;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
Unresolved.IsWildcard = false;
<rdar://problem/12368093> Extend module maps with a 'conflict' declaration, and warn when a newly-imported module conflicts with an already-imported module. llvm-svn: 177577
2013-03-21 05:10:35 +08:00
UnresolvedModuleRefs.push_back(Unresolved);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
break;
}
case SUBMODULE_EXPORTS: {
for (unsigned Idx = 0; Idx + 1 < Record.size(); Idx += 2) {
<rdar://problem/12368093> Extend module maps with a 'conflict' declaration, and warn when a newly-imported module conflicts with an already-imported module. llvm-svn: 177577
2013-03-21 05:10:35 +08:00
UnresolvedModuleRef Unresolved;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
Unresolved.File = &F;
Unresolved.Mod = CurrentModule;
Unresolved.ID = Record[Idx];
<rdar://problem/12368093> Extend module maps with a 'conflict' declaration, and warn when a newly-imported module conflicts with an already-imported module. llvm-svn: 177577
2013-03-21 05:10:35 +08:00
Unresolved.Kind = UnresolvedModuleRef::Export;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
Unresolved.IsWildcard = Record[Idx + 1];
<rdar://problem/12368093> Extend module maps with a 'conflict' declaration, and warn when a newly-imported module conflicts with an already-imported module. llvm-svn: 177577
2013-03-21 05:10:35 +08:00
UnresolvedModuleRefs.push_back(Unresolved);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
// Once we've loaded the set of exports, there's no reason to keep
// the parsed, unresolved exports around.
CurrentModule->UnresolvedExports.clear();
break;
}
case SUBMODULE_REQUIRES: {
Allow a new syntax in a module requires-declaration: requires ! feature The purpose of this is to allow (for instance) the module map for /usr/include to exclude <tgmath.h> and <complex.h> when building in C++ (these headers are instead provided by the C++ standard library in this case, and the glibc C <tgmath.h> header would otherwise try to include <complex.h>, resulting in a module cycle). llvm-svn: 193549
2013-10-29 06:18:19 +08:00
CurrentModule->addRequirement(Blob, Record[0], Context.getLangOpts(),
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
Context.getTargetInfo());
break;
}
Implement parsing, AST, (de-)serialization, and placeholder global metadata for linking against the libraries/frameworks for imported modules. The module map language is extended with a new "link" directive that specifies what library or framework to link against when a module is imported, e.g., link "clangAST" or link framework "MyFramework" Importing the corresponding module (or any of its submodules) will eventually link against the named library/framework. For now, I've added some placeholder global metadata that encodes the imported libraries/frameworks, so that we can test that this information gets through to the IR. The format of the data is still under discussion. llvm-svn: 172437
2013-01-15 01:21:00 +08:00
case SUBMODULE_LINK_LIBRARY:
CurrentModule->LinkLibraries.push_back(
update to use the new BitcodeCursor readRecord that takes a StringRef blob parameter, and adopt "advance" in more places. llvm-svn: 172951
2013-01-20 10:38:54 +08:00
Module::LinkLibrary(Blob, Record[0]));
Implement parsing, AST, (de-)serialization, and placeholder global metadata for linking against the libraries/frameworks for imported modules. The module map language is extended with a new "link" directive that specifies what library or framework to link against when a module is imported, e.g., link "clangAST" or link framework "MyFramework" Importing the corresponding module (or any of its submodules) will eventually link against the named library/framework. For now, I've added some placeholder global metadata that encodes the imported libraries/frameworks, so that we can test that this information gets through to the IR. The format of the data is still under discussion. llvm-svn: 172437
2013-01-15 01:21:00 +08:00
break;
<rdar://problem/10796651> Introduce configuration macros into module maps. Configuration macros are macros that are intended to alter how a module works, such that we need to build different module variants for different values of these macros. A module can declare its configuration macros, in which case we will complain if the definition of a configation macro on the command line (or lack thereof) differs from the current preprocessor state at the point where the module is imported. This should eliminate some surprises when enabling modules, because "#define CONFIG_MACRO ..." followed by "#include <module/header.h>" would silently ignore the CONFIG_MACRO setting. At least it will no longer be silent about it. Configuration macros are eventually intended to help reduce the number of module variants that need to be built. When the list of configuration macros for a module is exhaustive, we only need to consider the settings for those macros when building/finding the module, which can help isolate modules for various project-specific -D flags that should never affect how modules are build (but currently do). llvm-svn: 177466
2013-03-20 08:22:05 +08:00
case SUBMODULE_CONFIG_MACRO:
CurrentModule->ConfigMacros.push_back(Blob.str());
break;
<rdar://problem/12368093> Extend module maps with a 'conflict' declaration, and warn when a newly-imported module conflicts with an already-imported module. llvm-svn: 177577
2013-03-21 05:10:35 +08:00
case SUBMODULE_CONFLICT: {
UnresolvedModuleRef Unresolved;
Unresolved.File = &F;
Unresolved.Mod = CurrentModule;
Unresolved.ID = Record[0];
Unresolved.Kind = UnresolvedModuleRef::Conflict;
Unresolved.IsWildcard = false;
Unresolved.String = Blob;
UnresolvedModuleRefs.push_back(Unresolved);
break;
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
}
}
/// \brief Parse the record that corresponds to a LangOptions data
/// structure.
///
/// This routine parses the language options from the AST file and then gives
/// them to the AST listener if one is set.
///
/// \returns true if the listener deems the file unacceptable, false otherwise.
bool ASTReader::ParseLanguageOptions(const RecordData &Record,
bool Complain,
[modules] When a .pcm file is explicitly built separately from the translation unit, allow the -O settings of the two compilations to differ. llvm-svn: 220943
2014-10-31 10:28:58 +08:00
ASTReaderListener &Listener,
bool AllowCompatibleDifferences) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
LangOptions LangOpts;
unsigned Idx = 0;
#define LANGOPT(Name, Bits, Default, Description) \
LangOpts.Name = Record[Idx++];
#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
LangOpts.set##Name(static_cast<LangOptions::Type>(Record[Idx++]));
#include "clang/Basic/LangOptions.def"
Introduce a SanitizerKind enum to LangOptions. Use the bitmask to store the set of enabled sanitizers instead of a bitfield. On the negative side, it makes syntax for querying the set of enabled sanitizers a bit more clunky. On the positive side, we will be able to use SanitizerKind to eventually implement the new semantics for -fsanitize-recover= flag, that would allow us to make some sanitizers recoverable, and some non-recoverable. No functionality change. llvm-svn: 221558
2014-11-08 06:29:38 +08:00
#define SANITIZER(NAME, ID) \
LangOpts.Sanitize.set(SanitizerKind::ID, Record[Idx++]);
[ubsan] Add support for -fsanitize-blacklist llvm-svn: 172808
2013-01-18 19:30:38 +08:00
#include "clang/Basic/Sanitizers.def"
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
[Modules] Consider -fmodule-feature in module hash and when loading Any extra features from -fmodule-feature are part of the module hash and need to get validated on load. Also print them with -module-file-info. llvm-svn: 240433
2015-06-24 02:20:18 +08:00
for (unsigned N = Record[Idx++]; N; --N)
LangOpts.ModuleFeatures.push_back(ReadString(Record, Idx));
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
ObjCRuntime::Kind runtimeKind = (ObjCRuntime::Kind) Record[Idx++];
VersionTuple runtimeVersion = ReadVersionTuple(Record, Idx);
LangOpts.ObjCRuntime = ObjCRuntime(runtimeKind, runtimeVersion);
Comment parsing: add CommentOptions to allow specifying custom comment block commands Add an ability to specify custom documentation block comment commands via a new class CommentOptions. The intention is that this class will hold future customizations for comment parsing, including defining documentation comments with specific numbers of parameters, etc. CommentOptions instance is a member of LangOptions. CommentOptions is controlled by a new command-line parameter -fcomment-block-commands=Foo,Bar,Baz. llvm-svn: 175892
2013-02-22 22:21:27 +08:00
Use AddString/ReadString instead of doing it manually NFC llvm-svn: 240434
2015-06-24 02:20:23 +08:00
LangOpts.CurrentModule = ReadString(Record, Idx);
Comment parsing: add CommentOptions to allow specifying custom comment block commands Add an ability to specify custom documentation block comment commands via a new class CommentOptions. The intention is that this class will hold future customizations for comment parsing, including defining documentation comments with specific numbers of parameters, etc. CommentOptions instance is a member of LangOptions. CommentOptions is controlled by a new command-line parameter -fcomment-block-commands=Foo,Bar,Baz. llvm-svn: 175892
2013-02-22 22:21:27 +08:00
// Comment options.
for (unsigned N = Record[Idx++]; N; --N) {
LangOpts.CommentOpts.BlockCommandNames.push_back(
ReadString(Record, Idx));
}
Add an option to parse all comments as documentation comments Patch by Amin Shali. llvm-svn: 179180
2013-04-10 23:35:17 +08:00
LangOpts.CommentOpts.ParseAllComments = Record[Idx++];
Comment parsing: add CommentOptions to allow specifying custom comment block commands Add an ability to specify custom documentation block comment commands via a new class CommentOptions. The intention is that this class will hold future customizations for comment parsing, including defining documentation comments with specific numbers of parameters, etc. CommentOptions instance is a member of LangOptions. CommentOptions is controlled by a new command-line parameter -fcomment-block-commands=Foo,Bar,Baz. llvm-svn: 175892
2013-02-22 22:21:27 +08:00
[OpenMP] Reapply rL256842: [OpenMP] Offloading descriptor registration and device codegen. This patch attempts to fix the regressions identified when the patch was committed initially. Thanks to Michael Liao for identifying the fix in the offloading metadata generation related with side effects in evaluation of function arguments. llvm-svn: 256933
2016-01-06 21:42:12 +08:00
// OpenMP offloading options.
for (unsigned N = Record[Idx++]; N; --N) {
LangOpts.OMPTargetTriples.push_back(llvm::Triple(ReadString(Record, Idx)));
}
LangOpts.OMPHostIRFile = ReadString(Record, Idx);
[modules] When a .pcm file is explicitly built separately from the translation unit, allow the -O settings of the two compilations to differ. llvm-svn: 220943
2014-10-31 10:28:58 +08:00
return Listener.ReadLanguageOptions(LangOpts, Complain,
AllowCompatibleDifferences);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
[modules] Teach the AST reader to handle the case of importing a module with a subset of the existing target CPU features or mismatched CPU names. While we can't check that the CPU name used to build the module will end up being able to codegen correctly for the translation unit, we actually check that the imported features are a subset of the existing features. While here, rewrite the code to use std::set_difference and have it diagnose all of the differences found. Test case added which walks the set relationships and ensures we diagnose all the right cases and accept the others. No functional change for implicit modules here, just better diagnostics. llvm-svn: 232248
2015-03-14 12:47:43 +08:00
bool ASTReader::ParseTargetOptions(const RecordData &Record, bool Complain,
ASTReaderListener &Listener,
bool AllowCompatibleDifferences) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
unsigned Idx = 0;
TargetOptions TargetOpts;
TargetOpts.Triple = ReadString(Record, Idx);
TargetOpts.CPU = ReadString(Record, Idx);
TargetOpts.ABI = ReadString(Record, Idx);
for (unsigned N = Record[Idx++]; N; --N) {
TargetOpts.FeaturesAsWritten.push_back(ReadString(Record, Idx));
}
for (unsigned N = Record[Idx++]; N; --N) {
TargetOpts.Features.push_back(ReadString(Record, Idx));
}
[modules] Teach the AST reader to handle the case of importing a module with a subset of the existing target CPU features or mismatched CPU names. While we can't check that the CPU name used to build the module will end up being able to codegen correctly for the translation unit, we actually check that the imported features are a subset of the existing features. While here, rewrite the code to use std::set_difference and have it diagnose all of the differences found. Test case added which walks the set relationships and ensures we diagnose all the right cases and accept the others. No functional change for implicit modules here, just better diagnostics. llvm-svn: 232248
2015-03-14 12:47:43 +08:00
return Listener.ReadTargetOptions(TargetOpts, Complain,
AllowCompatibleDifferences);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
bool ASTReader::ParseDiagnosticOptions(const RecordData &Record, bool Complain,
ASTReaderListener &Listener) {
Reapply r207477 and r207479 without cyclic dependency Fixed by moving ProcessWarningOptions from Frontend into Basic. All of the dependencies for ProcessWarningOptions were already in Basic, so this was a small change. llvm-svn: 207549
2014-04-30 00:25:26 +08:00
IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts(new DiagnosticOptions);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
unsigned Idx = 0;
Reapply r207477 and r207479 without cyclic dependency Fixed by moving ProcessWarningOptions from Frontend into Basic. All of the dependencies for ProcessWarningOptions were already in Basic, so this was a small change. llvm-svn: 207549
2014-04-30 00:25:26 +08:00
#define DIAGOPT(Name, Bits, Default) DiagOpts->Name = Record[Idx++];
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
#define ENUM_DIAGOPT(Name, Type, Bits, Default) \
Reapply r207477 and r207479 without cyclic dependency Fixed by moving ProcessWarningOptions from Frontend into Basic. All of the dependencies for ProcessWarningOptions were already in Basic, so this was a small change. llvm-svn: 207549
2014-04-30 00:25:26 +08:00
DiagOpts->set##Name(static_cast<Type>(Record[Idx++]));
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
#include "clang/Basic/DiagnosticOptions.def"
Use -Rblah, not -Wblah, to control remark diagnostics. This was always the intent when we added remark support, but was never implemented in the general case, because the first -R flags didn't need it. (-Rpass= had special handling to accomodate its argument.) -Rno-foo, -Reverything, and -Rno-everything can be used to turn off a remark, or to turn on or off all remarks. Per discussion on cfe-commits, -Weverything does not affect remarks, and -Reverything does not affect warnings or errors. The only "real" -R flag we have right now is -Rmodule-build; that flag is effectively renamed from -Wmodule-build to -Rmodule-build by this change. -Wpass and -Wno-pass (and their friends) are also renamed to -Rpass and -Rno-pass by this change; it's not completely clear whether we intended to have a -Rpass (with no =pattern), but that is unchanged by this commit, other than the flag name. The default pattern is effectively one which matches no passes. In future, we may want to make the default pattern be .*, so that -Reverything works for -Rpass properly. llvm-svn: 215046
2014-08-07 08:24:21 +08:00
for (unsigned N = Record[Idx++]; N; --N)
Reapply r207477 and r207479 without cyclic dependency Fixed by moving ProcessWarningOptions from Frontend into Basic. All of the dependencies for ProcessWarningOptions were already in Basic, so this was a small change. llvm-svn: 207549
2014-04-30 00:25:26 +08:00
DiagOpts->Warnings.push_back(ReadString(Record, Idx));
Use -Rblah, not -Wblah, to control remark diagnostics. This was always the intent when we added remark support, but was never implemented in the general case, because the first -R flags didn't need it. (-Rpass= had special handling to accomodate its argument.) -Rno-foo, -Reverything, and -Rno-everything can be used to turn off a remark, or to turn on or off all remarks. Per discussion on cfe-commits, -Weverything does not affect remarks, and -Reverything does not affect warnings or errors. The only "real" -R flag we have right now is -Rmodule-build; that flag is effectively renamed from -Wmodule-build to -Rmodule-build by this change. -Wpass and -Wno-pass (and their friends) are also renamed to -Rpass and -Rno-pass by this change; it's not completely clear whether we intended to have a -Rpass (with no =pattern), but that is unchanged by this commit, other than the flag name. The default pattern is effectively one which matches no passes. In future, we may want to make the default pattern be .*, so that -Reverything works for -Rpass properly. llvm-svn: 215046
2014-08-07 08:24:21 +08:00
for (unsigned N = Record[Idx++]; N; --N)
DiagOpts->Remarks.push_back(ReadString(Record, Idx));
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
return Listener.ReadDiagnosticOptions(DiagOpts, Complain);
}
bool ASTReader::ParseFileSystemOptions(const RecordData &Record, bool Complain,
ASTReaderListener &Listener) {
FileSystemOptions FSOpts;
unsigned Idx = 0;
FSOpts.WorkingDir = ReadString(Record, Idx);
return Listener.ReadFileSystemOptions(FSOpts, Complain);
}
bool ASTReader::ParseHeaderSearchOptions(const RecordData &Record,
bool Complain,
ASTReaderListener &Listener) {
HeaderSearchOptions HSOpts;
unsigned Idx = 0;
HSOpts.Sysroot = ReadString(Record, Idx);
// Include entries.
for (unsigned N = Record[Idx++]; N; --N) {
std::string Path = ReadString(Record, Idx);
frontend::IncludeDirGroup Group
= static_cast<frontend::IncludeDirGroup>(Record[Idx++]);
bool IsFramework = Record[Idx++];
bool IgnoreSysRoot = Record[Idx++];
Replace push_back(Constructor(foo)) with emplace_back(foo) for non-trivial types If the type isn't trivially moveable emplace can skip a potentially expensive move. It also saves a couple of characters. Call sites were found with the ASTMatcher + some semi-automated cleanup. memberCallExpr( argumentCountIs(1), callee(methodDecl(hasName("push_back"))), on(hasType(recordDecl(has(namedDecl(hasName("emplace_back")))))), hasArgument(0, bindTemporaryExpr( hasType(recordDecl(hasNonTrivialDestructor())), has(constructExpr()))), unless(isInTemplateInstantiation())) No functional change intended. llvm-svn: 238601
2015-05-30 03:42:19 +08:00
HSOpts.UserEntries.emplace_back(std::move(Path), Group, IsFramework,
IgnoreSysRoot);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
// System header prefixes.
for (unsigned N = Record[Idx++]; N; --N) {
std::string Prefix = ReadString(Record, Idx);
bool IsSystemHeader = Record[Idx++];
Replace push_back(Constructor(foo)) with emplace_back(foo) for non-trivial types If the type isn't trivially moveable emplace can skip a potentially expensive move. It also saves a couple of characters. Call sites were found with the ASTMatcher + some semi-automated cleanup. memberCallExpr( argumentCountIs(1), callee(methodDecl(hasName("push_back"))), on(hasType(recordDecl(has(namedDecl(hasName("emplace_back")))))), hasArgument(0, bindTemporaryExpr( hasType(recordDecl(hasNonTrivialDestructor())), has(constructExpr()))), unless(isInTemplateInstantiation())) No functional change intended. llvm-svn: 238601
2015-05-30 03:42:19 +08:00
HSOpts.SystemHeaderPrefixes.emplace_back(std::move(Prefix), IsSystemHeader);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
HSOpts.ResourceDir = ReadString(Record, Idx);
HSOpts.ModuleCachePath = ReadString(Record, Idx);
Introduce '-fmodules-user-build-path' which accepts the "canonical" path to a user workspace build. This is used to avoid conflicts with user modules with the same name from different workspaces. rdar://16042513 llvm-svn: 202683
2014-03-03 16:12:05 +08:00
HSOpts.ModuleUserBuildPath = ReadString(Record, Idx);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
HSOpts.DisableModuleHash = Record[Idx++];
HSOpts.UseBuiltinIncludes = Record[Idx++];
HSOpts.UseStandardSystemIncludes = Record[Idx++];
HSOpts.UseStandardCXXIncludes = Record[Idx++];
HSOpts.UseLibcxx = Record[Idx++];
[PCH/Modules] Check that the specific module cache path the PCH was built with, is the same as the one in the current compiler invocation. If they differ reject the PCH. This protects against the badness occurring from getting modules loaded from different module caches (see crashes). rdar://19889860 llvm-svn: 229909
2015-02-20 04:12:20 +08:00
std::string SpecificModuleCachePath = ReadString(Record, Idx);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
[PCH/Modules] Check that the specific module cache path the PCH was built with, is the same as the one in the current compiler invocation. If they differ reject the PCH. This protects against the badness occurring from getting modules loaded from different module caches (see crashes). rdar://19889860 llvm-svn: 229909
2015-02-20 04:12:20 +08:00
return Listener.ReadHeaderSearchOptions(HSOpts, SpecificModuleCachePath,
Complain);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
bool ASTReader::ParsePreprocessorOptions(const RecordData &Record,
bool Complain,
ASTReaderListener &Listener,
std::string &SuggestedPredefines) {
PreprocessorOptions PPOpts;
unsigned Idx = 0;
// Macro definitions/undefs
for (unsigned N = Record[Idx++]; N; --N) {
std::string Macro = ReadString(Record, Idx);
bool IsUndef = Record[Idx++];
PPOpts.Macros.push_back(std::make_pair(Macro, IsUndef));
}
// Includes
for (unsigned N = Record[Idx++]; N; --N) {
PPOpts.Includes.push_back(ReadString(Record, Idx));
}
// Macro Includes
for (unsigned N = Record[Idx++]; N; --N) {
PPOpts.MacroIncludes.push_back(ReadString(Record, Idx));
}
PPOpts.UsePredefines = Record[Idx++];
[PCH/modules] Require the preprocessing record option to match the used PCH, if modules are enabled. The preprocessing record becomes important when modules are enabled, since it is used to calculate the module cache hash. llvm-svn: 180635
2013-04-27 05:33:40 +08:00
PPOpts.DetailedRecord = Record[Idx++];
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
PPOpts.ImplicitPCHInclude = ReadString(Record, Idx);
PPOpts.ImplicitPTHInclude = ReadString(Record, Idx);
PPOpts.ObjCXXARCStandardLibrary =
static_cast<ObjCXXARCStandardLibraryKind>(Record[Idx++]);
SuggestedPredefines.clear();
return Listener.ReadPreprocessorOptions(PPOpts, Complain,
SuggestedPredefines);
}
std::pair<ModuleFile *, unsigned>
ASTReader::getModulePreprocessedEntity(unsigned GlobalIndex) {
GlobalPreprocessedEntityMapType::iterator
I = GlobalPreprocessedEntityMap.find(GlobalIndex);
assert(I != GlobalPreprocessedEntityMap.end() &&
"Corrupted global preprocessed entity map");
ModuleFile *M = I->second;
unsigned LocalIndex = GlobalIndex - M->BasePreprocessedEntityID;
return std::make_pair(M, LocalIndex);
}
Update APIs that return a pair of iterators to return an iterator_range instead. Convert uses of those APIs into ranged for loops. NFC. llvm-svn: 228404
2015-02-07 01:25:10 +08:00
llvm::iterator_range<PreprocessingRecord::iterator>
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
ASTReader::getModulePreprocessedEntities(ModuleFile &Mod) const {
if (PreprocessingRecord *PPRec = PP.getPreprocessingRecord())
return PPRec->getIteratorsForLoadedRange(Mod.BasePreprocessedEntityID,
Mod.NumPreprocessedEntities);
Update APIs that return a pair of iterators to return an iterator_range instead. Convert uses of those APIs into ranged for loops. NFC. llvm-svn: 228404
2015-02-07 01:25:10 +08:00
return llvm::make_range(PreprocessingRecord::iterator(),
PreprocessingRecord::iterator());
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
Update APIs that return a pair of iterators to return an iterator_range instead. Convert uses of those APIs into ranged for loops. NFC. llvm-svn: 228404
2015-02-07 01:25:10 +08:00
llvm::iterator_range<ASTReader::ModuleDeclIterator>
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
ASTReader::getModuleFileLevelDecls(ModuleFile &Mod) {
Update APIs that return a pair of iterators to return an iterator_range instead. Convert uses of those APIs into ranged for loops. NFC. llvm-svn: 228404
2015-02-07 01:25:10 +08:00
return llvm::make_range(
ModuleDeclIterator(this, &Mod, Mod.FileSortedDecls),
ModuleDeclIterator(this, &Mod,
Mod.FileSortedDecls + Mod.NumFileSortedDecls));
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
PreprocessedEntity *ASTReader::ReadPreprocessedEntity(unsigned Index) {
PreprocessedEntityID PPID = Index+1;
std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index);
ModuleFile &M = *PPInfo.first;
unsigned LocalIndex = PPInfo.second;
const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex];
if (!PP.getPreprocessingRecord()) {
Error("no preprocessing record");
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
return nullptr;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
finish converting the normal cases in ASTReader to use the new BitstreamCursor APIs. llvm-svn: 172937
2013-01-20 08:56:42 +08:00
SavedStreamPosition SavedPosition(M.PreprocessorDetailCursor);
M.PreprocessorDetailCursor.JumpToBit(PPOffs.BitOffset);
llvm::BitstreamEntry Entry =
M.PreprocessorDetailCursor.advance(BitstreamCursor::AF_DontPopBlockAtEnd);
if (Entry.Kind != llvm::BitstreamEntry::Record)
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
return nullptr;
finish converting the normal cases in ASTReader to use the new BitstreamCursor APIs. llvm-svn: 172937
2013-01-20 08:56:42 +08:00
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
// Read the record.
SourceRange Range(ReadSourceLocation(M, PPOffs.Begin),
ReadSourceLocation(M, PPOffs.End));
PreprocessingRecord &PPRec = *PP.getPreprocessingRecord();
update to use the new BitcodeCursor readRecord that takes a StringRef blob parameter, and adopt "advance" in more places. llvm-svn: 172951
2013-01-20 10:38:54 +08:00
StringRef Blob;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
RecordData Record;
PreprocessorDetailRecordTypes RecType =
update to use the new BitcodeCursor readRecord that takes a StringRef blob parameter, and adopt "advance" in more places. llvm-svn: 172951
2013-01-20 10:38:54 +08:00
(PreprocessorDetailRecordTypes)M.PreprocessorDetailCursor.readRecord(
Entry.ID, Record, &Blob);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
switch (RecType) {
case PPD_MACRO_EXPANSION: {
bool isBuiltin = Record[0];
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
IdentifierInfo *Name = nullptr;
Rename MacroDefinition -> MacroDefinitionRecord, Preprocessor::MacroDefinition -> MacroDefinition. clang::MacroDefinition now models the currently-defined value of a macro. The previous MacroDefinition type, which represented a record of a macro definition directive for a detailed preprocessing record, is now called MacroDefinitionRecord. llvm-svn: 236400
2015-05-04 10:25:31 +08:00
MacroDefinitionRecord *Def = nullptr;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
if (isBuiltin)
Name = getLocalIdentifier(M, Record[1]);
else {
Rename MacroDefinition -> MacroDefinitionRecord, Preprocessor::MacroDefinition -> MacroDefinition. clang::MacroDefinition now models the currently-defined value of a macro. The previous MacroDefinition type, which represented a record of a macro definition directive for a detailed preprocessing record, is now called MacroDefinitionRecord. llvm-svn: 236400
2015-05-04 10:25:31 +08:00
PreprocessedEntityID GlobalID =
getGlobalPreprocessedEntityID(M, Record[1]);
Def = cast<MacroDefinitionRecord>(
PPRec.getLoadedPreprocessedEntity(GlobalID - 1));
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
MacroExpansion *ME;
if (isBuiltin)
ME = new (PPRec) MacroExpansion(Name, Range);
else
ME = new (PPRec) MacroExpansion(Def, Range);
return ME;
}
case PPD_MACRO_DEFINITION: {
// Decode the identifier info and then check again; if the macro is
// still defined and associated with the identifier,
IdentifierInfo *II = getLocalIdentifier(M, Record[0]);
Rename MacroDefinition -> MacroDefinitionRecord, Preprocessor::MacroDefinition -> MacroDefinition. clang::MacroDefinition now models the currently-defined value of a macro. The previous MacroDefinition type, which represented a record of a macro definition directive for a detailed preprocessing record, is now called MacroDefinitionRecord. llvm-svn: 236400
2015-05-04 10:25:31 +08:00
MacroDefinitionRecord *MD = new (PPRec) MacroDefinitionRecord(II, Range);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
if (DeserializationListener)
DeserializationListener->MacroDefinitionRead(PPID, MD);
return MD;
}
case PPD_INCLUSION_DIRECTIVE: {
update to use the new BitcodeCursor readRecord that takes a StringRef blob parameter, and adopt "advance" in more places. llvm-svn: 172951
2013-01-20 10:38:54 +08:00
const char *FullFileNameStart = Blob.data() + Record[0];
StringRef FullFileName(FullFileNameStart, Blob.size() - Record[0]);
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
const FileEntry *File = nullptr;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
if (!FullFileName.empty())
File = PP.getFileManager().getFile(FullFileName);
// FIXME: Stable encoding
InclusionDirective::InclusionKind Kind
= static_cast<InclusionDirective::InclusionKind>(Record[2]);
InclusionDirective *ID
= new (PPRec) InclusionDirective(PPRec, Kind,
update to use the new BitcodeCursor readRecord that takes a StringRef blob parameter, and adopt "advance" in more places. llvm-svn: 172951
2013-01-20 10:38:54 +08:00
StringRef(Blob.data(), Record[0]),
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
Record[1], Record[3],
File,
Range);
return ID;
}
}
llvm_unreachable("Invalid PreprocessorDetailRecordTypes");
}
/// \brief \arg SLocMapI points at a chunk of a module that contains no
/// preprocessed entities or the entities it contains are not the ones we are
/// looking for. Find the next module that contains entities and return the ID
/// of the first entry.
PreprocessedEntityID ASTReader::findNextPreprocessedEntity(
GlobalSLocOffsetMapType::const_iterator SLocMapI) const {
++SLocMapI;
for (GlobalSLocOffsetMapType::const_iterator
EndI = GlobalSLocOffsetMap.end(); SLocMapI != EndI; ++SLocMapI) {
ModuleFile &M = *SLocMapI->second;
if (M.NumPreprocessedEntities)
return M.BasePreprocessedEntityID;
}
return getTotalNumPreprocessedEntities();
}
namespace {
template <unsigned PPEntityOffset::*PPLoc>
struct PPEntityComp {
const ASTReader &Reader;
ModuleFile &M;
PPEntityComp(const ASTReader &Reader, ModuleFile &M) : Reader(Reader), M(M) { }
bool operator()(const PPEntityOffset &L, const PPEntityOffset &R) const {
SourceLocation LHS = getLoc(L);
SourceLocation RHS = getLoc(R);
return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
}
bool operator()(const PPEntityOffset &L, SourceLocation RHS) const {
SourceLocation LHS = getLoc(L);
return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
}
bool operator()(SourceLocation LHS, const PPEntityOffset &R) const {
SourceLocation RHS = getLoc(R);
return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
}
SourceLocation getLoc(const PPEntityOffset &PPE) const {
return Reader.ReadSourceLocation(M, PPE.*PPLoc);
}
};
Revert r240270 ("Fixed/added namespace ending comments using clang-tidy"). llvm-svn: 240353
2015-06-23 07:07:51 +08:00
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
Merge a couple of copy-and-pasted functions No change in functionality. llvm-svn: 209005
2014-05-17 02:59:21 +08:00
PreprocessedEntityID ASTReader::findPreprocessedEntity(SourceLocation Loc,
bool EndsAfter) const {
if (SourceMgr.isLocalSourceLocation(Loc))
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
return getTotalNumPreprocessedEntities();
Merge a couple of copy-and-pasted functions No change in functionality. llvm-svn: 209005
2014-05-17 02:59:21 +08:00
GlobalSLocOffsetMapType::const_iterator SLocMapI = GlobalSLocOffsetMap.find(
SourceManager::MaxLoadedOffset - Loc.getOffset() - 1);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
assert(SLocMapI != GlobalSLocOffsetMap.end() &&
"Corrupted global sloc offset map");
if (SLocMapI->second->NumPreprocessedEntities == 0)
return findNextPreprocessedEntity(SLocMapI);
ModuleFile &M = *SLocMapI->second;
typedef const PPEntityOffset *pp_iterator;
pp_iterator pp_begin = M.PreprocessedEntityOffsets;
pp_iterator pp_end = pp_begin + M.NumPreprocessedEntities;
size_t Count = M.NumPreprocessedEntities;
size_t Half;
pp_iterator First = pp_begin;
pp_iterator PPI;
Merge a couple of copy-and-pasted functions No change in functionality. llvm-svn: 209005
2014-05-17 02:59:21 +08:00
if (EndsAfter) {
PPI = std::upper_bound(pp_begin, pp_end, Loc,
PPEntityComp<&PPEntityOffset::Begin>(*this, M));
} else {
// Do a binary search manually instead of using std::lower_bound because
// The end locations of entities may be unordered (when a macro expansion
// is inside another macro argument), but for this case it is not important
// whether we get the first macro expansion or its containing macro.
while (Count > 0) {
Half = Count / 2;
PPI = First;
std::advance(PPI, Half);
if (SourceMgr.isBeforeInTranslationUnit(ReadSourceLocation(M, PPI->End),
Loc)) {
First = PPI;
++First;
Count = Count - Half - 1;
} else
Count = Half;
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
if (PPI == pp_end)
return findNextPreprocessedEntity(SLocMapI);
return M.BasePreprocessedEntityID + (PPI - pp_begin);
}
/// \brief Returns a pair of [Begin, End) indices of preallocated
/// preprocessed entities that \arg Range encompasses.
std::pair<unsigned, unsigned>
ASTReader::findPreprocessedEntitiesInRange(SourceRange Range) {
if (Range.isInvalid())
return std::make_pair(0,0);
assert(!SourceMgr.isBeforeInTranslationUnit(Range.getEnd(),Range.getBegin()));
Merge a couple of copy-and-pasted functions No change in functionality. llvm-svn: 209005
2014-05-17 02:59:21 +08:00
PreprocessedEntityID BeginID =
findPreprocessedEntity(Range.getBegin(), false);
PreprocessedEntityID EndID = findPreprocessedEntity(Range.getEnd(), true);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
return std::make_pair(BeginID, EndID);
}
/// \brief Optionally returns true or false if the preallocated preprocessed
/// entity with index \arg Index came from file \arg FID.
Include llvm::Optional in clang/Basic/LLVM.h Post-commit CR feedback from Jordan Rose regarding r175594. llvm-svn: 175679
2013-02-21 06:23:23 +08:00
Optional<bool> ASTReader::isPreprocessedEntityInFileID(unsigned Index,
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
FileID FID) {
if (FID.isInvalid())
return false;
std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index);
ModuleFile &M = *PPInfo.first;
unsigned LocalIndex = PPInfo.second;
const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex];
SourceLocation Loc = ReadSourceLocation(M, PPOffs.Begin);
if (Loc.isInvalid())
return false;
if (SourceMgr.isInFileID(SourceMgr.getFileLoc(Loc), FID))
return true;
else
return false;
}
namespace {
/// \brief Visitor used to search for information about a header file.
class HeaderFileInfoVisitor {
const FileEntry *FE;
Include llvm::Optional in clang/Basic/LLVM.h Post-commit CR feedback from Jordan Rose regarding r175594. llvm-svn: 175679
2013-02-21 06:23:23 +08:00
Optional<HeaderFileInfo> HFI;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
public:
[PCH] We don't need to instantiate HeaderFileInfoTrait in ASTReader more than once. We can just re-use the one from HeaderFileInfoLookupTable. llvm-svn: 176565
2013-03-07 02:12:44 +08:00
explicit HeaderFileInfoVisitor(const FileEntry *FE)
: FE(FE) { }
[Modules] Wrap the main ModuleManager visitor in a function_ref. Avoids the awkward passing of an opaque void *UserData argument. No functional change intended. llvm-svn: 243213
2015-07-25 20:14:04 +08:00
bool operator()(ModuleFile &M) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
HeaderFileInfoLookupTable *Table
= static_cast<HeaderFileInfoLookupTable *>(M.HeaderFileInfoTable);
if (!Table)
return false;
// Look in the on-disk hash table for an entry for this file name.
Remove some noise "this->"s left behind by r243213. llvm-svn: 243614
2015-07-30 11:37:16 +08:00
HeaderFileInfoLookupTable::iterator Pos = Table->find(FE);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
if (Pos == Table->end())
return false;
Remove some noise "this->"s left behind by r243213. llvm-svn: 243614
2015-07-30 11:37:16 +08:00
HFI = *Pos;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
return true;
}
Include llvm::Optional in clang/Basic/LLVM.h Post-commit CR feedback from Jordan Rose regarding r175594. llvm-svn: 175679
2013-02-21 06:23:23 +08:00
Optional<HeaderFileInfo> getHeaderFileInfo() const { return HFI; }
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
};
Revert r240270 ("Fixed/added namespace ending comments using clang-tidy"). llvm-svn: 240353
2015-06-23 07:07:51 +08:00
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
HeaderFileInfo ASTReader::GetHeaderFileInfo(const FileEntry *FE) {
[PCH] We don't need to instantiate HeaderFileInfoTrait in ASTReader more than once. We can just re-use the one from HeaderFileInfoLookupTable. llvm-svn: 176565
2013-03-07 02:12:44 +08:00
HeaderFileInfoVisitor Visitor(FE);
[Modules] Wrap the main ModuleManager visitor in a function_ref. Avoids the awkward passing of an opaque void *UserData argument. No functional change intended. llvm-svn: 243213
2015-07-25 20:14:04 +08:00
ModuleMgr.visit(Visitor);
[PCH] Remove the ASTReaderListener::ReadHeaderFileInfo callback. This made sense in pre-module era, before merging of HeaderFileInfos was introduced. Final part of rdar://13840148. llvm-svn: 181490
2013-05-09 07:46:55 +08:00
if (Optional<HeaderFileInfo> HFI = Visitor.getHeaderFileInfo())
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
return *HFI;
return HeaderFileInfo();
}
void ASTReader::ReadPragmaDiagnosticMappings(DiagnosticsEngine &Diag) {
// FIXME: Make it work properly with modules.
Remove useless 'llvm::' qualifier from names like StringRef and others that are brought into 'clang' namespace by clang/Basic/LLVM.h llvm-svn: 172323
2013-01-13 03:30:44 +08:00
SmallVector<DiagnosticsEngine::DiagState *, 32> DiagStates;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
for (ModuleIterator I = ModuleMgr.begin(), E = ModuleMgr.end(); I != E; ++I) {
ModuleFile &F = *(*I);
unsigned Idx = 0;
DiagStates.clear();
assert(!Diag.DiagStates.empty());
DiagStates.push_back(&Diag.DiagStates.front()); // the command-line one.
while (Idx < F.PragmaDiagMappings.size()) {
SourceLocation Loc = ReadSourceLocation(F, F.PragmaDiagMappings[Idx++]);
unsigned DiagStateID = F.PragmaDiagMappings[Idx++];
if (DiagStateID != 0) {
Diag.DiagStatePoints.push_back(
DiagnosticsEngine::DiagStatePoint(DiagStates[DiagStateID-1],
FullSourceLoc(Loc, SourceMgr)));
continue;
}
assert(DiagStateID == 0);
// A new DiagState was created here.
Diag.DiagStates.push_back(*Diag.GetCurDiagState());
DiagnosticsEngine::DiagState *NewState = &Diag.DiagStates.back();
DiagStates.push_back(NewState);
Diag.DiagStatePoints.push_back(
DiagnosticsEngine::DiagStatePoint(NewState,
FullSourceLoc(Loc, SourceMgr)));
while (1) {
assert(Idx < F.PragmaDiagMappings.size() &&
"Invalid data, didn't find '-1' marking end of diag/map pairs");
if (Idx >= F.PragmaDiagMappings.size()) {
break; // Something is messed up but at least avoid infinite loop in
// release build.
}
unsigned DiagID = F.PragmaDiagMappings[Idx++];
if (DiagID == (unsigned)-1) {
break; // no more diag/map pairs for this location.
}
Improve diagnostic mapping terminology Diagnostic mappings are used to calculate the final severity of diagnostic instances. Detangle the implementation to reflect the terminology used in documentation and bindings. No change in functionality. llvm-svn: 210518
2014-06-10 17:31:37 +08:00
diag::Severity Map = (diag::Severity)F.PragmaDiagMappings[Idx++];
DiagnosticMapping Mapping = Diag.makeUserMapping(Map, Loc);
Diag.GetCurDiagState()->setMapping(DiagID, Mapping);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
}
}
}
/// \brief Get the correct cursor and offset for loading a type.
ASTReader::RecordLocation ASTReader::TypeCursorForIndex(unsigned Index) {
GlobalTypeMapType::iterator I = GlobalTypeMap.find(Index);
assert(I != GlobalTypeMap.end() && "Corrupted global type map");
ModuleFile *M = I->second;
return RecordLocation(M, M->TypeOffsets[Index - M->BaseTypeIndex]);
}
/// \brief Read and return the type with the given index..
///
/// The index is the type ID, shifted and minus the number of predefs. This
/// routine actually reads the record corresponding to the type at the given
/// location. It is a helper routine for GetType, which deals with reading type
/// IDs.
QualType ASTReader::readTypeRecord(unsigned Index) {
RecordLocation Loc = TypeCursorForIndex(Index);
finish converting the normal cases in ASTReader to use the new BitstreamCursor APIs. llvm-svn: 172937
2013-01-20 08:56:42 +08:00
BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
// Keep track of where we are in the stream, then jump back there
// after reading this type.
SavedStreamPosition SavedPosition(DeclsCursor);
ReadingKindTracker ReadingKind(Read_Type, *this);
// Note that we are loading a type record.
Deserializing AType(this);
unsigned Idx = 0;
DeclsCursor.JumpToBit(Loc.Offset);
RecordData Record;
unsigned Code = DeclsCursor.ReadCode();
update to use the new BitcodeCursor readRecord that takes a StringRef blob parameter, and adopt "advance" in more places. llvm-svn: 172951
2013-01-20 10:38:54 +08:00
switch ((TypeCode)DeclsCursor.readRecord(Code, Record)) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
case TYPE_EXT_QUAL: {
if (Record.size() != 2) {
Error("Incorrect encoding of extended qualifier type");
return QualType();
}
QualType Base = readType(*Loc.F, Record, Idx);
Qualifiers Quals = Qualifiers::fromOpaqueValue(Record[Idx++]);
return Context.getQualifiedType(Base, Quals);
}
case TYPE_COMPLEX: {
if (Record.size() != 1) {
Error("Incorrect encoding of complex type");
return QualType();
}
QualType ElemType = readType(*Loc.F, Record, Idx);
return Context.getComplexType(ElemType);
}
case TYPE_POINTER: {
if (Record.size() != 1) {
Error("Incorrect encoding of pointer type");
return QualType();
}
QualType PointeeType = readType(*Loc.F, Record, Idx);
return Context.getPointerType(PointeeType);
}
[AST] Introduce a new DecayedType sugar node The goal of this sugar node is to be able to look at an arbitrary FunctionType and tell if any of the parameters were decayed from an array or function type. Ultimately this is necessary to implement Microsoft's C++ name mangling scheme, which mangles decayed arrays differently from normal pointers. Reviewers: rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D1014 llvm-svn: 184763
2013-06-25 01:51:48 +08:00
case TYPE_DECAYED: {
if (Record.size() != 1) {
Error("Incorrect encoding of decayed type");
return QualType();
}
QualType OriginalType = readType(*Loc.F, Record, Idx);
QualType DT = Context.getAdjustedParameterType(OriginalType);
if (!isa<DecayedType>(DT))
Error("Decayed type does not decay");
return DT;
}
Add an AdjustedType sugar node for adjusting calling conventions Summary: In general, this type node can be used to represent any type adjustment that occurs implicitly without losing type sugar. The immediate use of this is to adjust the calling conventions of member function pointer types without breaking template instantiation. Fixes PR17996. Reviewers: rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D2332 llvm-svn: 196451
2013-12-05 09:23:43 +08:00
case TYPE_ADJUSTED: {
if (Record.size() != 2) {
Error("Incorrect encoding of adjusted type");
return QualType();
}
QualType OriginalTy = readType(*Loc.F, Record, Idx);
QualType AdjustedTy = readType(*Loc.F, Record, Idx);
return Context.getAdjustedType(OriginalTy, AdjustedTy);
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
case TYPE_BLOCK_POINTER: {
if (Record.size() != 1) {
Error("Incorrect encoding of block pointer type");
return QualType();
}
QualType PointeeType = readType(*Loc.F, Record, Idx);
return Context.getBlockPointerType(PointeeType);
}
case TYPE_LVALUE_REFERENCE: {
if (Record.size() != 2) {
Error("Incorrect encoding of lvalue reference type");
return QualType();
}
QualType PointeeType = readType(*Loc.F, Record, Idx);
return Context.getLValueReferenceType(PointeeType, Record[1]);
}
case TYPE_RVALUE_REFERENCE: {
if (Record.size() != 1) {
Error("Incorrect encoding of rvalue reference type");
return QualType();
}
QualType PointeeType = readType(*Loc.F, Record, Idx);
return Context.getRValueReferenceType(PointeeType);
}
case TYPE_MEMBER_POINTER: {
if (Record.size() != 2) {
Error("Incorrect encoding of member pointer type");
return QualType();
}
QualType PointeeType = readType(*Loc.F, Record, Idx);
QualType ClassType = readType(*Loc.F, Record, Idx);
if (PointeeType.isNull() || ClassType.isNull())
return QualType();
return Context.getMemberPointerType(PointeeType, ClassType.getTypePtr());
}
case TYPE_CONSTANT_ARRAY: {
QualType ElementType = readType(*Loc.F, Record, Idx);
ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
unsigned IndexTypeQuals = Record[2];
unsigned Idx = 3;
llvm::APInt Size = ReadAPInt(Record, Idx);
return Context.getConstantArrayType(ElementType, Size,
ASM, IndexTypeQuals);
}
case TYPE_INCOMPLETE_ARRAY: {
QualType ElementType = readType(*Loc.F, Record, Idx);
ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
unsigned IndexTypeQuals = Record[2];
return Context.getIncompleteArrayType(ElementType, ASM, IndexTypeQuals);
}
case TYPE_VARIABLE_ARRAY: {
QualType ElementType = readType(*Loc.F, Record, Idx);
ArrayType::ArraySizeModifier ASM = (ArrayType::ArraySizeModifier)Record[1];
unsigned IndexTypeQuals = Record[2];
SourceLocation LBLoc = ReadSourceLocation(*Loc.F, Record[3]);
SourceLocation RBLoc = ReadSourceLocation(*Loc.F, Record[4]);
return Context.getVariableArrayType(ElementType, ReadExpr(*Loc.F),
ASM, IndexTypeQuals,
SourceRange(LBLoc, RBLoc));
}
case TYPE_VECTOR: {
if (Record.size() != 3) {
Error("incorrect encoding of vector type in AST file");
return QualType();
}
QualType ElementType = readType(*Loc.F, Record, Idx);
unsigned NumElements = Record[1];
unsigned VecKind = Record[2];
return Context.getVectorType(ElementType, NumElements,
(VectorType::VectorKind)VecKind);
}
case TYPE_EXT_VECTOR: {
if (Record.size() != 3) {
Error("incorrect encoding of extended vector type in AST file");
return QualType();
}
QualType ElementType = readType(*Loc.F, Record, Idx);
unsigned NumElements = Record[1];
return Context.getExtVectorType(ElementType, NumElements);
}
case TYPE_FUNCTION_NO_PROTO: {
if (Record.size() != 6) {
Error("incorrect encoding of no-proto function type");
return QualType();
}
QualType ResultType = readType(*Loc.F, Record, Idx);
FunctionType::ExtInfo Info(Record[1], Record[2], Record[3],
(CallingConv)Record[4], Record[5]);
return Context.getFunctionNoProtoType(ResultType, Info);
}
case TYPE_FUNCTION_PROTO: {
QualType ResultType = readType(*Loc.F, Record, Idx);
FunctionProtoType::ExtProtoInfo EPI;
EPI.ExtInfo = FunctionType::ExtInfo(/*noreturn*/ Record[1],
/*hasregparm*/ Record[2],
/*regparm*/ Record[3],
static_cast<CallingConv>(Record[4]),
/*produces*/ Record[5]);
unsigned Idx = 6;
EPI.Variadic = Record[Idx++];
EPI.HasTrailingReturn = Record[Idx++];
EPI.TypeQuals = Record[Idx++];
EPI.RefQualifier = static_cast<RefQualifierKind>(Record[Idx++]);
When the exception specification for a function in an imported PCH or module is resolved, emit an update record. llvm-svn: 204403
2014-03-21 05:47:22 +08:00
SmallVector<QualType, 8> ExceptionStorage;
Factor out exception specification information from FunctionProtoType::ExtProtoInfo. Most of the users of these fields don't care about the other ExtProtoInfo bits and just want to talk about the exception specification. llvm-svn: 214450
2014-08-01 05:57:55 +08:00
readExceptionSpec(*Loc.F, ExceptionStorage, EPI.ExceptionSpec, Record, Idx);
[modules] Improve abbreviations for C++: * Add abbreviation for CXXMethodDecl and for FunctionProtoType. These come up a *lot* in C++ modules. * Allow typedef declarations to use the abbreviation if they're class members, or if they're used. In passing, add more record name records for Clang AST node kinds. The downside is that we had already used up our allotment of 12 abbreviations, so this pushes us to an extra bit on each record to support the extra abbrev kinds, which increases file size by ~1%. This patch *barely* pays for that through the other improvements, but we've got room for another 18 abbrevs, so we should be able to make it much more profitable with future changes. llvm-svn: 214024
2014-07-26 14:37:51 +08:00
unsigned NumParams = Record[Idx++];
SmallVector<QualType, 16> ParamTypes;
for (unsigned I = 0; I != NumParams; ++I)
ParamTypes.push_back(readType(*Loc.F, Record, Idx));
ArrayRef-ize ASTContext::getFunctionType and Sema::BuildFunctionType. No (intended) functionality change. llvm-svn: 176726
2013-03-09 05:51:21 +08:00
return Context.getFunctionType(ResultType, ParamTypes, EPI);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
case TYPE_UNRESOLVED_USING: {
unsigned Idx = 0;
return Context.getTypeDeclType(
ReadDeclAs<UnresolvedUsingTypenameDecl>(*Loc.F, Record, Idx));
}
case TYPE_TYPEDEF: {
if (Record.size() != 2) {
Error("incorrect encoding of typedef type");
return QualType();
}
unsigned Idx = 0;
TypedefNameDecl *Decl = ReadDeclAs<TypedefNameDecl>(*Loc.F, Record, Idx);
QualType Canonical = readType(*Loc.F, Record, Idx);
if (!Canonical.isNull())
Canonical = Context.getCanonicalType(Canonical);
return Context.getTypedefType(Decl, Canonical);
}
case TYPE_TYPEOF_EXPR:
return Context.getTypeOfExprType(ReadExpr(*Loc.F));
case TYPE_TYPEOF: {
if (Record.size() != 1) {
Error("incorrect encoding of typeof(type) in AST file");
return QualType();
}
QualType UnderlyingType = readType(*Loc.F, Record, Idx);
return Context.getTypeOfType(UnderlyingType);
}
case TYPE_DECLTYPE: {
QualType UnderlyingType = readType(*Loc.F, Record, Idx);
return Context.getDecltypeType(ReadExpr(*Loc.F), UnderlyingType);
}
case TYPE_UNARY_TRANSFORM: {
QualType BaseType = readType(*Loc.F, Record, Idx);
QualType UnderlyingType = readType(*Loc.F, Record, Idx);
UnaryTransformType::UTTKind UKind = (UnaryTransformType::UTTKind)Record[2];
return Context.getUnaryTransformType(BaseType, UnderlyingType, UKind);
}
Implement C++1y decltype(auto). llvm-svn: 180610
2013-04-27 00:15:35 +08:00
case TYPE_AUTO: {
QualType Deduced = readType(*Loc.F, Record, Idx);
Add support for GCC's '__auto_type' extension, per the GCC manual: https://gcc.gnu.org/onlinedocs/gcc/Typeof.html Differences from the GCC extension: * __auto_type is also permitted in C++ (but only in places where it could appear in C), allowing its use in headers that might be shared across C and C++, or used from C++98 * __auto_type can be combined with a declarator, as with C++ auto (for instance, "__auto_type *p") * multiple variables can be declared in a single __auto_type declaration, with the C++ semantics (the deduced type must be the same in each case) This patch also adds a missing restriction on applying typeof to a bit-field, which GCC has historically rejected in C (due to lack of clarity as to whether the operand should be promoted). The same restriction also applies to __auto_type in C (in both GCC and Clang). This also fixes PR25449. Patch by Nicholas Allegra! llvm-svn: 252690
2015-11-11 10:02:15 +08:00
AutoTypeKeyword Keyword = (AutoTypeKeyword)Record[Idx++];
Don't treat a non-deduced 'auto' type as being type-dependent. Instead, there are now two distinct canonical 'AutoType's: one is the undeduced 'auto' placeholder type, and the other is a deduced-but-dependent type. All deduced-to-a-non-dependent-type cases are still non-canonical. llvm-svn: 180789
2013-04-30 21:56:41 +08:00
bool IsDependent = Deduced.isNull() ? Record[Idx++] : false;
Add support for GCC's '__auto_type' extension, per the GCC manual: https://gcc.gnu.org/onlinedocs/gcc/Typeof.html Differences from the GCC extension: * __auto_type is also permitted in C++ (but only in places where it could appear in C), allowing its use in headers that might be shared across C and C++, or used from C++98 * __auto_type can be combined with a declarator, as with C++ auto (for instance, "__auto_type *p") * multiple variables can be declared in a single __auto_type declaration, with the C++ semantics (the deduced type must be the same in each case) This patch also adds a missing restriction on applying typeof to a bit-field, which GCC has historically rejected in C (due to lack of clarity as to whether the operand should be promoted). The same restriction also applies to __auto_type in C (in both GCC and Clang). This also fixes PR25449. Patch by Nicholas Allegra! llvm-svn: 252690
2015-11-11 10:02:15 +08:00
return Context.getAutoType(Deduced, Keyword, IsDependent);
Implement C++1y decltype(auto). llvm-svn: 180610
2013-04-27 00:15:35 +08:00
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
case TYPE_RECORD: {
if (Record.size() != 2) {
Error("incorrect encoding of record type");
return QualType();
}
unsigned Idx = 0;
bool IsDependent = Record[Idx++];
RecordDecl *RD = ReadDeclAs<RecordDecl>(*Loc.F, Record, Idx);
RD = cast_or_null<RecordDecl>(RD->getCanonicalDecl());
QualType T = Context.getRecordType(RD);
const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
return T;
}
case TYPE_ENUM: {
if (Record.size() != 2) {
Error("incorrect encoding of enum type");
return QualType();
}
unsigned Idx = 0;
bool IsDependent = Record[Idx++];
QualType T
= Context.getEnumType(ReadDeclAs<EnumDecl>(*Loc.F, Record, Idx));
const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
return T;
}
case TYPE_ATTRIBUTED: {
if (Record.size() != 3) {
Error("incorrect encoding of attributed type");
return QualType();
}
QualType modifiedType = readType(*Loc.F, Record, Idx);
QualType equivalentType = readType(*Loc.F, Record, Idx);
AttributedType::Kind kind = static_cast<AttributedType::Kind>(Record[2]);
return Context.getAttributedType(kind, modifiedType, equivalentType);
}
case TYPE_PAREN: {
if (Record.size() != 1) {
Error("incorrect encoding of paren type");
return QualType();
}
QualType InnerType = readType(*Loc.F, Record, Idx);
return Context.getParenType(InnerType);
}
case TYPE_PACK_EXPANSION: {
if (Record.size() != 2) {
Error("incorrect encoding of pack expansion type");
return QualType();
}
QualType Pattern = readType(*Loc.F, Record, Idx);
if (Pattern.isNull())
return QualType();
Include llvm::Optional in clang/Basic/LLVM.h Post-commit CR feedback from Jordan Rose regarding r175594. llvm-svn: 175679
2013-02-21 06:23:23 +08:00
Optional<unsigned> NumExpansions;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
if (Record[1])
NumExpansions = Record[1] - 1;
return Context.getPackExpansionType(Pattern, NumExpansions);
}
case TYPE_ELABORATED: {
unsigned Idx = 0;
ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
QualType NamedType = readType(*Loc.F, Record, Idx);
return Context.getElaboratedType(Keyword, NNS, NamedType);
}
case TYPE_OBJC_INTERFACE: {
unsigned Idx = 0;
ObjCInterfaceDecl *ItfD
= ReadDeclAs<ObjCInterfaceDecl>(*Loc.F, Record, Idx);
return Context.getObjCInterfaceType(ItfD->getCanonicalDecl());
}
case TYPE_OBJC_OBJECT: {
unsigned Idx = 0;
QualType Base = readType(*Loc.F, Record, Idx);
Handle Objective-C type arguments. Objective-C type arguments can be provided in angle brackets following an Objective-C interface type. Syntactically, this is the same position as one would provide protocol qualifiers (e.g., id<NSCopying>), so parse both together and let Sema sort out the ambiguous cases. This applies both when parsing types and when parsing the superclass of an Objective-C class, which can now be a specialized type (e.g., NSMutableArray<T> inherits from NSArray<T>). Check Objective-C type arguments against the type parameters of the corresponding class. Verify the length of the type argument list and that each type argument satisfies the corresponding bound. Specializations of parameterized Objective-C classes are represented in the type system as distinct types. Both specialized types (e.g., NSArray<NSString *> *) and unspecialized types (NSArray *) are represented, separately. llvm-svn: 241542
2015-07-07 11:57:35 +08:00
unsigned NumTypeArgs = Record[Idx++];
SmallVector<QualType, 4> TypeArgs;
for (unsigned I = 0; I != NumTypeArgs; ++I)
TypeArgs.push_back(readType(*Loc.F, Record, Idx));
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
unsigned NumProtos = Record[Idx++];
SmallVector<ObjCProtocolDecl*, 4> Protos;
for (unsigned I = 0; I != NumProtos; ++I)
Protos.push_back(ReadDeclAs<ObjCProtocolDecl>(*Loc.F, Record, Idx));
Implement the Objective-C __kindof type qualifier. The __kindof type qualifier can be applied to Objective-C object (pointer) types to indicate id-like behavior, which includes implicit "downcasting" of __kindof types to subclasses and id-like message-send behavior. __kindof types provide better type bounds for substitutions into unspecified generic types, which preserves more type information. llvm-svn: 241548
2015-07-07 11:58:42 +08:00
bool IsKindOf = Record[Idx++];
return Context.getObjCObjectType(Base, TypeArgs, Protos, IsKindOf);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
case TYPE_OBJC_OBJECT_POINTER: {
unsigned Idx = 0;
QualType Pointee = readType(*Loc.F, Record, Idx);
return Context.getObjCObjectPointerType(Pointee);
}
case TYPE_SUBST_TEMPLATE_TYPE_PARM: {
unsigned Idx = 0;
QualType Parm = readType(*Loc.F, Record, Idx);
QualType Replacement = readType(*Loc.F, Record, Idx);
Fix PR18806: Canonicalize the replacement type when deserializing a SubstTemplateTypeParmType What's going on in the test case (without the patch applied) is this: When the header is parsed, decltype(B()) is canonicalized to decltype(Y()), because that was the first parsed equivalent decltype expression. Hence, the TemplateSpecializationType for Id<decltype(B())> ends up with SubstTemplateTypeParmType(T, decltype(Y())) as the AliasedType member. When the PCH file is included and the AST reader reads Id<decltype(B())>, it sees decltype(B()) before decltype(Y()). So, this time decltype(B()) ends up being the canonical type for both decltypes, which leads to an assert violation when the reader calls getSubstTemplateTypeParmType with the non-canonical decltype(Y()) as the replacement type. Reviewers: rsmith Reviewed By: rsmith CC: cfe-commits, aemerson Differential Revision: http://llvm-reviews.chandlerc.com/D3073 llvm-svn: 204005
2014-03-15 18:23:27 +08:00
return Context.getSubstTemplateTypeParmType(
cast<TemplateTypeParmType>(Parm),
Context.getCanonicalType(Replacement));
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
case TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK: {
unsigned Idx = 0;
QualType Parm = readType(*Loc.F, Record, Idx);
TemplateArgument ArgPack = ReadTemplateArgument(*Loc.F, Record, Idx);
return Context.getSubstTemplateTypeParmPackType(
cast<TemplateTypeParmType>(Parm),
ArgPack);
}
case TYPE_INJECTED_CLASS_NAME: {
CXXRecordDecl *D = ReadDeclAs<CXXRecordDecl>(*Loc.F, Record, Idx);
QualType TST = readType(*Loc.F, Record, Idx); // probably derivable
// FIXME: ASTContext::getInjectedClassNameType is not currently suitable
// for AST reading, too much interdependencies.
[modules] When building an injected-class-name type, we may have to insert it into multiple merged classes' TypeForDecl slots. llvm-svn: 220331
2014-10-22 05:15:18 +08:00
const Type *T = nullptr;
for (auto *DI = D; DI; DI = DI->getPreviousDecl()) {
if (const Type *Existing = DI->getTypeForDecl()) {
T = Existing;
break;
}
}
if (!T) {
When two templates get merged together, also merge their pattern declarations together. This is extremely hairy, because in general we need to have loaded both the template and the pattern before we can determine whether either should be merged, so we temporarily violate the rule that all merging happens before reading a decl ends, but *only* in the case where a template's pattern is being loaded while loading the template itself. In order to accomodate this for class templates, delay loading the injected class name type for the pattern of the template until after we've loaded the template itself, if we happen to load the template first. llvm-svn: 207063
2014-04-24 10:25:27 +08:00
T = new (Context, TypeAlignment) InjectedClassNameType(D, TST);
[modules] When building an injected-class-name type, we may have to insert it into multiple merged classes' TypeForDecl slots. llvm-svn: 220331
2014-10-22 05:15:18 +08:00
for (auto *DI = D; DI; DI = DI->getPreviousDecl())
DI->setTypeForDecl(T);
}
When two templates get merged together, also merge their pattern declarations together. This is extremely hairy, because in general we need to have loaded both the template and the pattern before we can determine whether either should be merged, so we temporarily violate the rule that all merging happens before reading a decl ends, but *only* in the case where a template's pattern is being loaded while loading the template itself. In order to accomodate this for class templates, delay loading the injected class name type for the pattern of the template until after we've loaded the template itself, if we happen to load the template first. llvm-svn: 207063
2014-04-24 10:25:27 +08:00
return QualType(T, 0);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
case TYPE_TEMPLATE_TYPE_PARM: {
unsigned Idx = 0;
unsigned Depth = Record[Idx++];
unsigned Index = Record[Idx++];
bool Pack = Record[Idx++];
TemplateTypeParmDecl *D
= ReadDeclAs<TemplateTypeParmDecl>(*Loc.F, Record, Idx);
return Context.getTemplateTypeParmType(Depth, Index, Pack, D);
}
case TYPE_DEPENDENT_NAME: {
unsigned Idx = 0;
ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
Remove some noise "this->"s left behind by r243213. llvm-svn: 243614
2015-07-30 11:37:16 +08:00
const IdentifierInfo *Name = GetIdentifierInfo(*Loc.F, Record, Idx);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
QualType Canon = readType(*Loc.F, Record, Idx);
if (!Canon.isNull())
Canon = Context.getCanonicalType(Canon);
return Context.getDependentNameType(Keyword, NNS, Name, Canon);
}
case TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION: {
unsigned Idx = 0;
ElaboratedTypeKeyword Keyword = (ElaboratedTypeKeyword)Record[Idx++];
NestedNameSpecifier *NNS = ReadNestedNameSpecifier(*Loc.F, Record, Idx);
Remove some noise "this->"s left behind by r243213. llvm-svn: 243614
2015-07-30 11:37:16 +08:00
const IdentifierInfo *Name = GetIdentifierInfo(*Loc.F, Record, Idx);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
unsigned NumArgs = Record[Idx++];
SmallVector<TemplateArgument, 8> Args;
Args.reserve(NumArgs);
while (NumArgs--)
Args.push_back(ReadTemplateArgument(*Loc.F, Record, Idx));
return Context.getDependentTemplateSpecializationType(Keyword, NNS, Name,
Args.size(), Args.data());
}
case TYPE_DEPENDENT_SIZED_ARRAY: {
unsigned Idx = 0;
// ArrayType
QualType ElementType = readType(*Loc.F, Record, Idx);
ArrayType::ArraySizeModifier ASM
= (ArrayType::ArraySizeModifier)Record[Idx++];
unsigned IndexTypeQuals = Record[Idx++];
// DependentSizedArrayType
Expr *NumElts = ReadExpr(*Loc.F);
SourceRange Brackets = ReadSourceRange(*Loc.F, Record, Idx);
return Context.getDependentSizedArrayType(ElementType, NumElts, ASM,
IndexTypeQuals, Brackets);
}
case TYPE_TEMPLATE_SPECIALIZATION: {
unsigned Idx = 0;
bool IsDependent = Record[Idx++];
TemplateName Name = ReadTemplateName(*Loc.F, Record, Idx);
SmallVector<TemplateArgument, 8> Args;
ReadTemplateArgumentList(Args, *Loc.F, Record, Idx);
QualType Underlying = readType(*Loc.F, Record, Idx);
QualType T;
if (Underlying.isNull())
T = Context.getCanonicalTemplateSpecializationType(Name, Args.data(),
Args.size());
else
T = Context.getTemplateSpecializationType(Name, Args.data(),
Args.size(), Underlying);
const_cast<Type*>(T.getTypePtr())->setDependent(IsDependent);
return T;
}
case TYPE_ATOMIC: {
if (Record.size() != 1) {
Error("Incorrect encoding of atomic type");
return QualType();
}
QualType ValueType = readType(*Loc.F, Record, Idx);
return Context.getAtomicType(ValueType);
}
[OpenCL] Pipe type support Summary: Support for OpenCL 2.0 pipe type. This is a bug-fix version for bader's patch reviews.llvm.org/D14441 Reviewers: pekka.jaaskelainen, Anastasia Subscribers: bader, Anastasia, cfe-commits Differential Revision: http://reviews.llvm.org/D15603 llvm-svn: 257254
2016-01-09 20:53:17 +08:00
case TYPE_PIPE: {
if (Record.size() != 1) {
Error("Incorrect encoding of pipe type");
return QualType();
}
// Reading the pipe element type.
QualType ElementType = readType(*Loc.F, Record, Idx);
return Context.getPipeType(ElementType);
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
llvm_unreachable("Invalid TypeCode!");
}
When the exception specification for a function in an imported PCH or module is resolved, emit an update record. llvm-svn: 204403
2014-03-21 05:47:22 +08:00
void ASTReader::readExceptionSpec(ModuleFile &ModuleFile,
SmallVectorImpl<QualType> &Exceptions,
Factor out exception specification information from FunctionProtoType::ExtProtoInfo. Most of the users of these fields don't care about the other ExtProtoInfo bits and just want to talk about the exception specification. llvm-svn: 214450
2014-08-01 05:57:55 +08:00
FunctionProtoType::ExceptionSpecInfo &ESI,
When the exception specification for a function in an imported PCH or module is resolved, emit an update record. llvm-svn: 204403
2014-03-21 05:47:22 +08:00
const RecordData &Record, unsigned &Idx) {
ExceptionSpecificationType EST =
static_cast<ExceptionSpecificationType>(Record[Idx++]);
Factor out exception specification information from FunctionProtoType::ExtProtoInfo. Most of the users of these fields don't care about the other ExtProtoInfo bits and just want to talk about the exception specification. llvm-svn: 214450
2014-08-01 05:57:55 +08:00
ESI.Type = EST;
When the exception specification for a function in an imported PCH or module is resolved, emit an update record. llvm-svn: 204403
2014-03-21 05:47:22 +08:00
if (EST == EST_Dynamic) {
Factor out exception specification information from FunctionProtoType::ExtProtoInfo. Most of the users of these fields don't care about the other ExtProtoInfo bits and just want to talk about the exception specification. llvm-svn: 214450
2014-08-01 05:57:55 +08:00
for (unsigned I = 0, N = Record[Idx++]; I != N; ++I)
When the exception specification for a function in an imported PCH or module is resolved, emit an update record. llvm-svn: 204403
2014-03-21 05:47:22 +08:00
Exceptions.push_back(readType(ModuleFile, Record, Idx));
Factor out exception specification information from FunctionProtoType::ExtProtoInfo. Most of the users of these fields don't care about the other ExtProtoInfo bits and just want to talk about the exception specification. llvm-svn: 214450
2014-08-01 05:57:55 +08:00
ESI.Exceptions = Exceptions;
When the exception specification for a function in an imported PCH or module is resolved, emit an update record. llvm-svn: 204403
2014-03-21 05:47:22 +08:00
} else if (EST == EST_ComputedNoexcept) {
Factor out exception specification information from FunctionProtoType::ExtProtoInfo. Most of the users of these fields don't care about the other ExtProtoInfo bits and just want to talk about the exception specification. llvm-svn: 214450
2014-08-01 05:57:55 +08:00
ESI.NoexceptExpr = ReadExpr(ModuleFile);
When the exception specification for a function in an imported PCH or module is resolved, emit an update record. llvm-svn: 204403
2014-03-21 05:47:22 +08:00
} else if (EST == EST_Uninstantiated) {
Factor out exception specification information from FunctionProtoType::ExtProtoInfo. Most of the users of these fields don't care about the other ExtProtoInfo bits and just want to talk about the exception specification. llvm-svn: 214450
2014-08-01 05:57:55 +08:00
ESI.SourceDecl = ReadDeclAs<FunctionDecl>(ModuleFile, Record, Idx);
ESI.SourceTemplate = ReadDeclAs<FunctionDecl>(ModuleFile, Record, Idx);
When the exception specification for a function in an imported PCH or module is resolved, emit an update record. llvm-svn: 204403
2014-03-21 05:47:22 +08:00
} else if (EST == EST_Unevaluated) {
Factor out exception specification information from FunctionProtoType::ExtProtoInfo. Most of the users of these fields don't care about the other ExtProtoInfo bits and just want to talk about the exception specification. llvm-svn: 214450
2014-08-01 05:57:55 +08:00
ESI.SourceDecl = ReadDeclAs<FunctionDecl>(ModuleFile, Record, Idx);
When the exception specification for a function in an imported PCH or module is resolved, emit an update record. llvm-svn: 204403
2014-03-21 05:47:22 +08:00
}
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
class clang::TypeLocReader : public TypeLocVisitor<TypeLocReader> {
ASTReader &Reader;
ModuleFile &F;
const ASTReader::RecordData &Record;
unsigned &Idx;
SourceLocation ReadSourceLocation(const ASTReader::RecordData &R,
unsigned &I) {
return Reader.ReadSourceLocation(F, R, I);
}
template<typename T>
T *ReadDeclAs(const ASTReader::RecordData &Record, unsigned &Idx) {
return Reader.ReadDeclAs<T>(F, Record, Idx);
}
public:
TypeLocReader(ASTReader &Reader, ModuleFile &F,
const ASTReader::RecordData &Record, unsigned &Idx)
: Reader(Reader), F(F), Record(Record), Idx(Idx)
{ }
// 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)
#define TYPELOC(CLASS, PARENT) \
void Visit##CLASS##TypeLoc(CLASS##TypeLoc TyLoc);
#include "clang/AST/TypeLocNodes.def"
void VisitFunctionTypeLoc(FunctionTypeLoc);
void VisitArrayTypeLoc(ArrayTypeLoc);
};
void TypeLocReader::VisitQualifiedTypeLoc(QualifiedTypeLoc TL) {
// nothing to do
}
void TypeLocReader::VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
TL.setBuiltinLoc(ReadSourceLocation(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++]);
}
}
void TypeLocReader::VisitComplexTypeLoc(ComplexTypeLoc TL) {
TL.setNameLoc(ReadSourceLocation(Record, Idx));
}
void TypeLocReader::VisitPointerTypeLoc(PointerTypeLoc TL) {
TL.setStarLoc(ReadSourceLocation(Record, Idx));
}
[AST] Introduce a new DecayedType sugar node The goal of this sugar node is to be able to look at an arbitrary FunctionType and tell if any of the parameters were decayed from an array or function type. Ultimately this is necessary to implement Microsoft's C++ name mangling scheme, which mangles decayed arrays differently from normal pointers. Reviewers: rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D1014 llvm-svn: 184763
2013-06-25 01:51:48 +08:00
void TypeLocReader::VisitDecayedTypeLoc(DecayedTypeLoc TL) {
// nothing to do
}
Add an AdjustedType sugar node for adjusting calling conventions Summary: In general, this type node can be used to represent any type adjustment that occurs implicitly without losing type sugar. The immediate use of this is to adjust the calling conventions of member function pointer types without breaking template instantiation. Fixes PR17996. Reviewers: rsmith Differential Revision: http://llvm-reviews.chandlerc.com/D2332 llvm-svn: 196451
2013-12-05 09:23:43 +08:00
void TypeLocReader::VisitAdjustedTypeLoc(AdjustedTypeLoc TL) {
// nothing to do
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
void TypeLocReader::VisitBlockPointerTypeLoc(BlockPointerTypeLoc TL) {
TL.setCaretLoc(ReadSourceLocation(Record, Idx));
}
void TypeLocReader::VisitLValueReferenceTypeLoc(LValueReferenceTypeLoc TL) {
TL.setAmpLoc(ReadSourceLocation(Record, Idx));
}
void TypeLocReader::VisitRValueReferenceTypeLoc(RValueReferenceTypeLoc TL) {
TL.setAmpAmpLoc(ReadSourceLocation(Record, Idx));
}
void TypeLocReader::VisitMemberPointerTypeLoc(MemberPointerTypeLoc TL) {
TL.setStarLoc(ReadSourceLocation(Record, Idx));
TL.setClassTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
}
void TypeLocReader::VisitArrayTypeLoc(ArrayTypeLoc TL) {
TL.setLBracketLoc(ReadSourceLocation(Record, Idx));
TL.setRBracketLoc(ReadSourceLocation(Record, Idx));
if (Record[Idx++])
TL.setSizeExpr(Reader.ReadExpr(F));
else
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
TL.setSizeExpr(nullptr);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
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(ReadSourceLocation(Record, Idx));
}
void TypeLocReader::VisitVectorTypeLoc(VectorTypeLoc TL) {
TL.setNameLoc(ReadSourceLocation(Record, Idx));
}
void TypeLocReader::VisitExtVectorTypeLoc(ExtVectorTypeLoc TL) {
TL.setNameLoc(ReadSourceLocation(Record, Idx));
}
void TypeLocReader::VisitFunctionTypeLoc(FunctionTypeLoc TL) {
TL.setLocalRangeBegin(ReadSourceLocation(Record, Idx));
TL.setLParenLoc(ReadSourceLocation(Record, Idx));
TL.setRParenLoc(ReadSourceLocation(Record, Idx));
TL.setLocalRangeEnd(ReadSourceLocation(Record, Idx));
Update FunctionTypeLoc and related names to match r199686 llvm-svn: 199699
2014-01-21 08:32:38 +08:00
for (unsigned i = 0, e = TL.getNumParams(); i != e; ++i) {
TL.setParam(i, ReadDeclAs<ParmVarDecl>(Record, Idx));
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
}
void TypeLocReader::VisitFunctionProtoTypeLoc(FunctionProtoTypeLoc TL) {
VisitFunctionTypeLoc(TL);
}
void TypeLocReader::VisitFunctionNoProtoTypeLoc(FunctionNoProtoTypeLoc TL) {
VisitFunctionTypeLoc(TL);
}
void TypeLocReader::VisitUnresolvedUsingTypeLoc(UnresolvedUsingTypeLoc TL) {
TL.setNameLoc(ReadSourceLocation(Record, Idx));
}
void TypeLocReader::VisitTypedefTypeLoc(TypedefTypeLoc TL) {
TL.setNameLoc(ReadSourceLocation(Record, Idx));
}
void TypeLocReader::VisitTypeOfExprTypeLoc(TypeOfExprTypeLoc TL) {
TL.setTypeofLoc(ReadSourceLocation(Record, Idx));
TL.setLParenLoc(ReadSourceLocation(Record, Idx));
TL.setRParenLoc(ReadSourceLocation(Record, Idx));
}
void TypeLocReader::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
TL.setTypeofLoc(ReadSourceLocation(Record, Idx));
TL.setLParenLoc(ReadSourceLocation(Record, Idx));
TL.setRParenLoc(ReadSourceLocation(Record, Idx));
TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
}
void TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
TL.setNameLoc(ReadSourceLocation(Record, Idx));
}
void TypeLocReader::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
TL.setKWLoc(ReadSourceLocation(Record, Idx));
TL.setLParenLoc(ReadSourceLocation(Record, Idx));
TL.setRParenLoc(ReadSourceLocation(Record, Idx));
TL.setUnderlyingTInfo(Reader.GetTypeSourceInfo(F, Record, Idx));
}
void TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) {
TL.setNameLoc(ReadSourceLocation(Record, Idx));
}
void TypeLocReader::VisitRecordTypeLoc(RecordTypeLoc TL) {
TL.setNameLoc(ReadSourceLocation(Record, Idx));
}
void TypeLocReader::VisitEnumTypeLoc(EnumTypeLoc TL) {
TL.setNameLoc(ReadSourceLocation(Record, Idx));
}
void TypeLocReader::VisitAttributedTypeLoc(AttributedTypeLoc TL) {
TL.setAttrNameLoc(ReadSourceLocation(Record, Idx));
if (TL.hasAttrOperand()) {
SourceRange range;
range.setBegin(ReadSourceLocation(Record, Idx));
range.setEnd(ReadSourceLocation(Record, Idx));
TL.setAttrOperandParensRange(range);
}
if (TL.hasAttrExprOperand()) {
if (Record[Idx++])
TL.setAttrExprOperand(Reader.ReadExpr(F));
else
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
TL.setAttrExprOperand(nullptr);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
} else if (TL.hasAttrEnumOperand())
TL.setAttrEnumOperandLoc(ReadSourceLocation(Record, Idx));
}
void TypeLocReader::VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TL) {
TL.setNameLoc(ReadSourceLocation(Record, Idx));
}
void TypeLocReader::VisitSubstTemplateTypeParmTypeLoc(
SubstTemplateTypeParmTypeLoc TL) {
TL.setNameLoc(ReadSourceLocation(Record, Idx));
}
void TypeLocReader::VisitSubstTemplateTypeParmPackTypeLoc(
SubstTemplateTypeParmPackTypeLoc TL) {
TL.setNameLoc(ReadSourceLocation(Record, Idx));
}
void TypeLocReader::VisitTemplateSpecializationTypeLoc(
TemplateSpecializationTypeLoc TL) {
TL.setTemplateKeywordLoc(ReadSourceLocation(Record, Idx));
TL.setTemplateNameLoc(ReadSourceLocation(Record, Idx));
TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
for (unsigned i = 0, e = TL.getNumArgs(); i != e; ++i)
TL.setArgLocInfo(i,
Reader.GetTemplateArgumentLocInfo(F,
TL.getTypePtr()->getArg(i).getKind(),
Record, Idx));
}
void TypeLocReader::VisitParenTypeLoc(ParenTypeLoc TL) {
TL.setLParenLoc(ReadSourceLocation(Record, Idx));
TL.setRParenLoc(ReadSourceLocation(Record, Idx));
}
void TypeLocReader::VisitElaboratedTypeLoc(ElaboratedTypeLoc TL) {
TL.setElaboratedKeywordLoc(ReadSourceLocation(Record, Idx));
TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
}
void TypeLocReader::VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) {
TL.setNameLoc(ReadSourceLocation(Record, Idx));
}
void TypeLocReader::VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
TL.setElaboratedKeywordLoc(ReadSourceLocation(Record, Idx));
TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
TL.setNameLoc(ReadSourceLocation(Record, Idx));
}
void TypeLocReader::VisitDependentTemplateSpecializationTypeLoc(
DependentTemplateSpecializationTypeLoc TL) {
TL.setElaboratedKeywordLoc(ReadSourceLocation(Record, Idx));
TL.setQualifierLoc(Reader.ReadNestedNameSpecifierLoc(F, Record, Idx));
TL.setTemplateKeywordLoc(ReadSourceLocation(Record, Idx));
TL.setTemplateNameLoc(ReadSourceLocation(Record, Idx));
TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
for (unsigned I = 0, E = TL.getNumArgs(); I != E; ++I)
TL.setArgLocInfo(I,
Reader.GetTemplateArgumentLocInfo(F,
TL.getTypePtr()->getArg(I).getKind(),
Record, Idx));
}
void TypeLocReader::VisitPackExpansionTypeLoc(PackExpansionTypeLoc TL) {
TL.setEllipsisLoc(ReadSourceLocation(Record, Idx));
}
void TypeLocReader::VisitObjCInterfaceTypeLoc(ObjCInterfaceTypeLoc TL) {
TL.setNameLoc(ReadSourceLocation(Record, Idx));
}
void TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
TL.setHasBaseTypeAsWritten(Record[Idx++]);
Handle Objective-C type arguments. Objective-C type arguments can be provided in angle brackets following an Objective-C interface type. Syntactically, this is the same position as one would provide protocol qualifiers (e.g., id<NSCopying>), so parse both together and let Sema sort out the ambiguous cases. This applies both when parsing types and when parsing the superclass of an Objective-C class, which can now be a specialized type (e.g., NSMutableArray<T> inherits from NSArray<T>). Check Objective-C type arguments against the type parameters of the corresponding class. Verify the length of the type argument list and that each type argument satisfies the corresponding bound. Specializations of parameterized Objective-C classes are represented in the type system as distinct types. Both specialized types (e.g., NSArray<NSString *> *) and unspecialized types (NSArray *) are represented, separately. llvm-svn: 241542
2015-07-07 11:57:35 +08:00
TL.setTypeArgsLAngleLoc(ReadSourceLocation(Record, Idx));
TL.setTypeArgsRAngleLoc(ReadSourceLocation(Record, Idx));
for (unsigned i = 0, e = TL.getNumTypeArgs(); i != e; ++i)
TL.setTypeArgTInfo(i, Reader.GetTypeSourceInfo(F, Record, Idx));
TL.setProtocolLAngleLoc(ReadSourceLocation(Record, Idx));
TL.setProtocolRAngleLoc(ReadSourceLocation(Record, Idx));
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
TL.setProtocolLoc(i, ReadSourceLocation(Record, Idx));
}
void TypeLocReader::VisitObjCObjectPointerTypeLoc(ObjCObjectPointerTypeLoc TL) {
TL.setStarLoc(ReadSourceLocation(Record, Idx));
}
void TypeLocReader::VisitAtomicTypeLoc(AtomicTypeLoc TL) {
TL.setKWLoc(ReadSourceLocation(Record, Idx));
TL.setLParenLoc(ReadSourceLocation(Record, Idx));
TL.setRParenLoc(ReadSourceLocation(Record, Idx));
}
[OpenCL] Pipe type support Summary: Support for OpenCL 2.0 pipe type. This is a bug-fix version for bader's patch reviews.llvm.org/D14441 Reviewers: pekka.jaaskelainen, Anastasia Subscribers: bader, Anastasia, cfe-commits Differential Revision: http://reviews.llvm.org/D15603 llvm-svn: 257254
2016-01-09 20:53:17 +08:00
void TypeLocReader::VisitPipeTypeLoc(PipeTypeLoc TL) {
TL.setKWLoc(ReadSourceLocation(Record, Idx));
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
TypeSourceInfo *ASTReader::GetTypeSourceInfo(ModuleFile &F,
const RecordData &Record,
unsigned &Idx) {
QualType InfoTy = readType(F, Record, Idx);
if (InfoTy.isNull())
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
return nullptr;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
TypeSourceInfo *TInfo = getContext().CreateTypeSourceInfo(InfoTy);
TypeLocReader TLR(*this, F, Record, Idx);
for (TypeLoc TL = TInfo->getTypeLoc(); !TL.isNull(); TL = TL.getNextTypeLoc())
TLR.Visit(TL);
return TInfo;
}
QualType ASTReader::GetType(TypeID ID) {
unsigned FastQuals = ID & Qualifiers::FastMask;
unsigned Index = ID >> Qualifiers::FastWidth;
if (Index < NUM_PREDEF_TYPE_IDS) {
QualType T;
switch ((PredefinedTypeIDs)Index) {
Run clang-format to unify the switch statement style as suggest here: http://reviews.llvm.org/D12855#246073. NFC. llvm-svn: 247678
2015-09-15 20:18:29 +08:00
case PREDEF_TYPE_NULL_ID:
return QualType();
case PREDEF_TYPE_VOID_ID:
T = Context.VoidTy;
break;
case PREDEF_TYPE_BOOL_ID:
T = Context.BoolTy;
break;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
case PREDEF_TYPE_CHAR_U_ID:
case PREDEF_TYPE_CHAR_S_ID:
// FIXME: Check that the signedness of CharTy is correct!
T = Context.CharTy;
break;
Run clang-format to unify the switch statement style as suggest here: http://reviews.llvm.org/D12855#246073. NFC. llvm-svn: 247678
2015-09-15 20:18:29 +08:00
case PREDEF_TYPE_UCHAR_ID:
T = Context.UnsignedCharTy;
break;
case PREDEF_TYPE_USHORT_ID:
T = Context.UnsignedShortTy;
break;
case PREDEF_TYPE_UINT_ID:
T = Context.UnsignedIntTy;
break;
case PREDEF_TYPE_ULONG_ID:
T = Context.UnsignedLongTy;
break;
case PREDEF_TYPE_ULONGLONG_ID:
T = Context.UnsignedLongLongTy;
break;
case PREDEF_TYPE_UINT128_ID:
T = Context.UnsignedInt128Ty;
break;
case PREDEF_TYPE_SCHAR_ID:
T = Context.SignedCharTy;
break;
case PREDEF_TYPE_WCHAR_ID:
T = Context.WCharTy;
break;
case PREDEF_TYPE_SHORT_ID:
T = Context.ShortTy;
break;
case PREDEF_TYPE_INT_ID:
T = Context.IntTy;
break;
case PREDEF_TYPE_LONG_ID:
T = Context.LongTy;
break;
case PREDEF_TYPE_LONGLONG_ID:
T = Context.LongLongTy;
break;
case PREDEF_TYPE_INT128_ID:
T = Context.Int128Ty;
break;
case PREDEF_TYPE_HALF_ID:
T = Context.HalfTy;
break;
case PREDEF_TYPE_FLOAT_ID:
T = Context.FloatTy;
break;
case PREDEF_TYPE_DOUBLE_ID:
T = Context.DoubleTy;
break;
case PREDEF_TYPE_LONGDOUBLE_ID:
T = Context.LongDoubleTy;
break;
case PREDEF_TYPE_OVERLOAD_ID:
T = Context.OverloadTy;
break;
case PREDEF_TYPE_BOUND_MEMBER:
T = Context.BoundMemberTy;
break;
case PREDEF_TYPE_PSEUDO_OBJECT:
T = Context.PseudoObjectTy;
break;
case PREDEF_TYPE_DEPENDENT_ID:
T = Context.DependentTy;
break;
case PREDEF_TYPE_UNKNOWN_ANY:
T = Context.UnknownAnyTy;
break;
case PREDEF_TYPE_NULLPTR_ID:
T = Context.NullPtrTy;
break;
case PREDEF_TYPE_CHAR16_ID:
T = Context.Char16Ty;
break;
case PREDEF_TYPE_CHAR32_ID:
T = Context.Char32Ty;
break;
case PREDEF_TYPE_OBJC_ID:
T = Context.ObjCBuiltinIdTy;
break;
case PREDEF_TYPE_OBJC_CLASS:
T = Context.ObjCBuiltinClassTy;
break;
case PREDEF_TYPE_OBJC_SEL:
T = Context.ObjCBuiltinSelTy;
break;
case PREDEF_TYPE_IMAGE1D_ID:
T = Context.OCLImage1dTy;
break;
case PREDEF_TYPE_IMAGE1D_ARR_ID:
T = Context.OCLImage1dArrayTy;
break;
case PREDEF_TYPE_IMAGE1D_BUFF_ID:
T = Context.OCLImage1dBufferTy;
break;
case PREDEF_TYPE_IMAGE2D_ID:
T = Context.OCLImage2dTy;
break;
case PREDEF_TYPE_IMAGE2D_ARR_ID:
T = Context.OCLImage2dArrayTy;
break;
[OpenCL] Add new types for OpenCL 2.0. Patch by Pedro Ferreira. Reviewers: pekka.jaaskelainen Differential Revision: http://reviews.llvm.org/D12855 llvm-svn: 247676
2015-09-15 19:18:52 +08:00
case PREDEF_TYPE_IMAGE2D_DEP_ID:
T = Context.OCLImage2dDepthTy;
break;
case PREDEF_TYPE_IMAGE2D_ARR_DEP_ID:
T = Context.OCLImage2dArrayDepthTy;
break;
case PREDEF_TYPE_IMAGE2D_MSAA_ID:
T = Context.OCLImage2dMSAATy;
break;
case PREDEF_TYPE_IMAGE2D_ARR_MSAA_ID:
T = Context.OCLImage2dArrayMSAATy;
break;
case PREDEF_TYPE_IMAGE2D_MSAA_DEP_ID:
T = Context.OCLImage2dMSAADepthTy;
break;
case PREDEF_TYPE_IMAGE2D_ARR_MSAA_DEPTH_ID:
T = Context.OCLImage2dArrayMSAADepthTy;
break;
Run clang-format to unify the switch statement style as suggest here: http://reviews.llvm.org/D12855#246073. NFC. llvm-svn: 247678
2015-09-15 20:18:29 +08:00
case PREDEF_TYPE_IMAGE3D_ID:
T = Context.OCLImage3dTy;
break;
case PREDEF_TYPE_SAMPLER_ID:
T = Context.OCLSamplerTy;
break;
case PREDEF_TYPE_EVENT_ID:
T = Context.OCLEventTy;
break;
[OpenCL] Add new types for OpenCL 2.0. Patch by Pedro Ferreira. Reviewers: pekka.jaaskelainen Differential Revision: http://reviews.llvm.org/D12855 llvm-svn: 247676
2015-09-15 19:18:52 +08:00
case PREDEF_TYPE_CLK_EVENT_ID:
T = Context.OCLClkEventTy;
break;
case PREDEF_TYPE_QUEUE_ID:
T = Context.OCLQueueTy;
break;
case PREDEF_TYPE_NDRANGE_ID:
T = Context.OCLNDRangeTy;
break;
case PREDEF_TYPE_RESERVE_ID_ID:
T = Context.OCLReserveIDTy;
break;
Run clang-format to unify the switch statement style as suggest here: http://reviews.llvm.org/D12855#246073. NFC. llvm-svn: 247678
2015-09-15 20:18:29 +08:00
case PREDEF_TYPE_AUTO_DEDUCT:
T = Context.getAutoDeductType();
break;
case PREDEF_TYPE_AUTO_RREF_DEDUCT:
T = Context.getAutoRRefDeductType();
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
break;
case PREDEF_TYPE_ARC_UNBRIDGED_CAST:
T = Context.ARCUnbridgedCastTy;
break;
case PREDEF_TYPE_BUILTIN_FN:
T = Context.BuiltinFnTy;
break;
[OPENMP 4.0] Initial support for array sections. Adds parsing/sema analysis/serialization/deserialization for array sections in OpenMP constructs (introduced in OpenMP 4.0). Currently it is allowed to use array sections only in OpenMP clauses that accepts list of expressions. Differential Revision: http://reviews.llvm.org/D10732 llvm-svn: 245937
2015-08-25 22:24:04 +08:00
case PREDEF_TYPE_OMP_ARRAY_SECTION:
T = Context.OMPArraySectionTy;
break;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
assert(!T.isNull() && "Unknown predefined type");
return T.withFastQualifiers(FastQuals);
}
Index -= NUM_PREDEF_TYPE_IDS;
assert(Index < TypesLoaded.size() && "Type index out-of-range");
if (TypesLoaded[Index].isNull()) {
TypesLoaded[Index] = readTypeRecord(Index);
if (TypesLoaded[Index].isNull())
return QualType();
TypesLoaded[Index]->setFromAST();
if (DeserializationListener)
DeserializationListener->TypeRead(TypeIdx::fromTypeID(ID),
TypesLoaded[Index]);
}
return TypesLoaded[Index].withFastQualifiers(FastQuals);
}
QualType ASTReader::getLocalType(ModuleFile &F, unsigned LocalID) {
return GetType(getGlobalTypeID(F, LocalID));
}
serialization::TypeID
ASTReader::getGlobalTypeID(ModuleFile &F, unsigned LocalID) const {
unsigned FastQuals = LocalID & Qualifiers::FastMask;
unsigned LocalIndex = LocalID >> Qualifiers::FastWidth;
if (LocalIndex < NUM_PREDEF_TYPE_IDS)
return LocalID;
ContinuousRangeMap<uint32_t, int, 2>::iterator I
= F.TypeRemap.find(LocalIndex - NUM_PREDEF_TYPE_IDS);
assert(I != F.TypeRemap.end() && "Invalid index into type index remap");
unsigned GlobalIndex = LocalIndex + I->second;
return (GlobalIndex << Qualifiers::FastWidth) | FastQuals;
}
TemplateArgumentLocInfo
ASTReader::GetTemplateArgumentLocInfo(ModuleFile &F,
TemplateArgument::ArgKind Kind,
const RecordData &Record,
unsigned &Index) {
switch (Kind) {
case TemplateArgument::Expression:
return ReadExpr(F);
case TemplateArgument::Type:
return GetTypeSourceInfo(F, Record, Index);
case TemplateArgument::Template: {
NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
Index);
SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
SourceLocation());
}
case TemplateArgument::TemplateExpansion: {
NestedNameSpecifierLoc QualifierLoc = ReadNestedNameSpecifierLoc(F, Record,
Index);
SourceLocation TemplateNameLoc = ReadSourceLocation(F, Record, Index);
SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Index);
return TemplateArgumentLocInfo(QualifierLoc, TemplateNameLoc,
EllipsisLoc);
}
case TemplateArgument::Null:
case TemplateArgument::Integral:
case TemplateArgument::Declaration:
case TemplateArgument::NullPtr:
case TemplateArgument::Pack:
// FIXME: Is this right?
return TemplateArgumentLocInfo();
}
llvm_unreachable("unexpected template argument loc");
}
TemplateArgumentLoc
ASTReader::ReadTemplateArgumentLoc(ModuleFile &F,
const RecordData &Record, unsigned &Index) {
TemplateArgument Arg = ReadTemplateArgument(F, Record, Index);
if (Arg.getKind() == TemplateArgument::Expression) {
if (Record[Index++]) // bool InfoHasSameExpr.
return TemplateArgumentLoc(Arg, TemplateArgumentLocInfo(Arg.getAsExpr()));
}
return TemplateArgumentLoc(Arg, GetTemplateArgumentLocInfo(F, Arg.getKind(),
Record, Index));
}
Added source locs for angled parentheses in class/var template partial specs. llvm-svn: 188134
2013-08-10 15:24:53 +08:00
const ASTTemplateArgumentListInfo*
ASTReader::ReadASTTemplateArgumentListInfo(ModuleFile &F,
const RecordData &Record,
unsigned &Index) {
SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Index);
SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Index);
unsigned NumArgsAsWritten = Record[Index++];
TemplateArgumentListInfo TemplArgsInfo(LAngleLoc, RAngleLoc);
for (unsigned i = 0; i != NumArgsAsWritten; ++i)
TemplArgsInfo.addArgument(ReadTemplateArgumentLoc(F, Record, Index));
return ASTTemplateArgumentListInfo::Create(getContext(), TemplArgsInfo);
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
Decl *ASTReader::GetExternalDecl(uint32_t ID) {
return GetDecl(ID);
}
[modules] When we try to complete the redeclaration chain for a class template specialization, pull in any lazy specializations of the class template. llvm-svn: 227668
2015-01-31 11:04:55 +08:00
template<typename TemplateSpecializationDecl>
static void completeRedeclChainForTemplateSpecialization(Decl *D) {
if (auto *TSD = dyn_cast<TemplateSpecializationDecl>(D))
TSD->getSpecializedTemplate()->LoadLazySpecializations();
}
If a declaration is loaded, and then a module import adds a redeclaration, then ensure that querying the first declaration for its most recent declaration checks for redeclarations from the imported module. This works as follows: * The 'most recent' pointer on a canonical declaration grows a pointer to the external AST source and a generation number (space- and time-optimized for the case where there is no external source). * Each time the 'most recent' pointer is queried, if it has an external source, we check whether it's up to date, and update it if not. * The ancillary data stored on the canonical declaration is allocated lazily to avoid filling it in for declarations that end up being non-canonical. We'll still perform a redundant (ASTContext) allocation if someone asks for the most recent declaration from a decl before setPreviousDecl is called, but such cases are probably all bugs, and are now easy to find. Some finessing is still in order here -- in particular, we use a very general mechanism for handling the DefinitionData pointer on CXXRecordData, and a more targeted approach would be more compact. Also, the MayHaveOutOfDateDef mechanism should now be expunged, since it was addressing only a corner of the full problem space here. That's not covered by this patch. Early performance benchmarks show that this makes no measurable difference to Clang performance without modules enabled (and fixes a major correctness issue with modules enabled). I'll revert if a full performance comparison shows any problems. llvm-svn: 209046
2014-05-17 07:01:30 +08:00
void ASTReader::CompleteRedeclChain(const Decl *D) {
If two sibling modules declare the same entity, and we indirectly pull a declaration of that entity in from one of those modules, keep track of the fact that we've not completed the redeclaration chain yet so that we can pull the remaining declarations in from the other module if they're needed. llvm-svn: 209161
2014-05-20 04:59:20 +08:00
if (NumCurrentElementsDeserializing) {
// We arrange to not care about the complete redeclaration chain while we're
// deserializing. Just remember that the AST has marked this one as complete
// but that it's not actually complete yet, so we know we still need to
// complete it later.
PendingIncompleteDeclChains.push_back(const_cast<Decl*>(D));
return;
}
If a declaration is loaded, and then a module import adds a redeclaration, then ensure that querying the first declaration for its most recent declaration checks for redeclarations from the imported module. This works as follows: * The 'most recent' pointer on a canonical declaration grows a pointer to the external AST source and a generation number (space- and time-optimized for the case where there is no external source). * Each time the 'most recent' pointer is queried, if it has an external source, we check whether it's up to date, and update it if not. * The ancillary data stored on the canonical declaration is allocated lazily to avoid filling it in for declarations that end up being non-canonical. We'll still perform a redundant (ASTContext) allocation if someone asks for the most recent declaration from a decl before setPreviousDecl is called, but such cases are probably all bugs, and are now easy to find. Some finessing is still in order here -- in particular, we use a very general mechanism for handling the DefinitionData pointer on CXXRecordData, and a more targeted approach would be more compact. Also, the MayHaveOutOfDateDef mechanism should now be expunged, since it was addressing only a corner of the full problem space here. That's not covered by this patch. Early performance benchmarks show that this makes no measurable difference to Clang performance without modules enabled (and fixes a major correctness issue with modules enabled). I'll revert if a full performance comparison shows any problems. llvm-svn: 209046
2014-05-17 07:01:30 +08:00
const DeclContext *DC = D->getDeclContext()->getRedeclContext();
// If this is a named declaration, complete it by looking it up
// within its context.
//
[modules] When completing the redecl chain for an anonymous declaration in a merged context, pull in the lexical decls in that context, since one of them may complete the redecl chain. llvm-svn: 216652
2014-08-28 13:44:07 +08:00
// FIXME: Merging a function definition should merge
If a declaration is loaded, and then a module import adds a redeclaration, then ensure that querying the first declaration for its most recent declaration checks for redeclarations from the imported module. This works as follows: * The 'most recent' pointer on a canonical declaration grows a pointer to the external AST source and a generation number (space- and time-optimized for the case where there is no external source). * Each time the 'most recent' pointer is queried, if it has an external source, we check whether it's up to date, and update it if not. * The ancillary data stored on the canonical declaration is allocated lazily to avoid filling it in for declarations that end up being non-canonical. We'll still perform a redundant (ASTContext) allocation if someone asks for the most recent declaration from a decl before setPreviousDecl is called, but such cases are probably all bugs, and are now easy to find. Some finessing is still in order here -- in particular, we use a very general mechanism for handling the DefinitionData pointer on CXXRecordData, and a more targeted approach would be more compact. Also, the MayHaveOutOfDateDef mechanism should now be expunged, since it was addressing only a corner of the full problem space here. That's not covered by this patch. Early performance benchmarks show that this makes no measurable difference to Clang performance without modules enabled (and fixes a major correctness issue with modules enabled). I'll revert if a full performance comparison shows any problems. llvm-svn: 209046
2014-05-17 07:01:30 +08:00
// all mergeable entities within it.
if (isa<TranslationUnitDecl>(DC) || isa<NamespaceDecl>(DC) ||
isa<CXXRecordDecl>(DC) || isa<EnumDecl>(DC)) {
if (DeclarationName Name = cast<NamedDecl>(D)->getDeclName()) {
[modules] In C++, stop serializing and deserializing a list of declarations in the identifier table. This is redundant, since the TU-scope lookups are also serialized as part of the TU DeclContext, and wasteful in a number of ways. We still emit the decls for PCH / preamble builds, since for those we want identical results, not merely semantically equivalent ones. llvm-svn: 242855
2015-07-22 07:54:07 +08:00
if (!getContext().getLangOpts().CPlusPlus &&
isa<TranslationUnitDecl>(DC)) {
If a declaration is loaded, and then a module import adds a redeclaration, then ensure that querying the first declaration for its most recent declaration checks for redeclarations from the imported module. This works as follows: * The 'most recent' pointer on a canonical declaration grows a pointer to the external AST source and a generation number (space- and time-optimized for the case where there is no external source). * Each time the 'most recent' pointer is queried, if it has an external source, we check whether it's up to date, and update it if not. * The ancillary data stored on the canonical declaration is allocated lazily to avoid filling it in for declarations that end up being non-canonical. We'll still perform a redundant (ASTContext) allocation if someone asks for the most recent declaration from a decl before setPreviousDecl is called, but such cases are probably all bugs, and are now easy to find. Some finessing is still in order here -- in particular, we use a very general mechanism for handling the DefinitionData pointer on CXXRecordData, and a more targeted approach would be more compact. Also, the MayHaveOutOfDateDef mechanism should now be expunged, since it was addressing only a corner of the full problem space here. That's not covered by this patch. Early performance benchmarks show that this makes no measurable difference to Clang performance without modules enabled (and fixes a major correctness issue with modules enabled). I'll revert if a full performance comparison shows any problems. llvm-svn: 209046
2014-05-17 07:01:30 +08:00
// Outside of C++, we don't have a lookup table for the TU, so update
[modules] In C++, stop serializing and deserializing a list of declarations in the identifier table. This is redundant, since the TU-scope lookups are also serialized as part of the TU DeclContext, and wasteful in a number of ways. We still emit the decls for PCH / preamble builds, since for those we want identical results, not merely semantically equivalent ones. llvm-svn: 242855
2015-07-22 07:54:07 +08:00
// the identifier instead. (For C++ modules, we don't store decls
// in the serialized identifier table, so we do the lookup in the TU.)
auto *II = Name.getAsIdentifierInfo();
assert(II && "non-identifier name in C?");
If a declaration is loaded, and then a module import adds a redeclaration, then ensure that querying the first declaration for its most recent declaration checks for redeclarations from the imported module. This works as follows: * The 'most recent' pointer on a canonical declaration grows a pointer to the external AST source and a generation number (space- and time-optimized for the case where there is no external source). * Each time the 'most recent' pointer is queried, if it has an external source, we check whether it's up to date, and update it if not. * The ancillary data stored on the canonical declaration is allocated lazily to avoid filling it in for declarations that end up being non-canonical. We'll still perform a redundant (ASTContext) allocation if someone asks for the most recent declaration from a decl before setPreviousDecl is called, but such cases are probably all bugs, and are now easy to find. Some finessing is still in order here -- in particular, we use a very general mechanism for handling the DefinitionData pointer on CXXRecordData, and a more targeted approach would be more compact. Also, the MayHaveOutOfDateDef mechanism should now be expunged, since it was addressing only a corner of the full problem space here. That's not covered by this patch. Early performance benchmarks show that this makes no measurable difference to Clang performance without modules enabled (and fixes a major correctness issue with modules enabled). I'll revert if a full performance comparison shows any problems. llvm-svn: 209046
2014-05-17 07:01:30 +08:00
if (II->isOutOfDate())
updateOutOfDateIdentifier(*II);
} else
DC->lookup(Name);
[modules] When completing the redecl chain for an anonymous declaration in a merged context, pull in the lexical decls in that context, since one of them may complete the redecl chain. llvm-svn: 216652
2014-08-28 13:44:07 +08:00
} else if (needsAnonymousDeclarationNumber(cast<NamedDecl>(D))) {
function_ref-ize ExternalASTSource::FindExternalLexicalDecl and remove its useless return value. Switch to using it directly when completing the redeclaration chain for an anonymous declaration, and reduce the set of declarations that we load in the process to just those of the right kind. llvm-svn: 244161
2015-08-06 06:41:45 +08:00
// Find all declarations of this kind from the relevant context.
for (auto *DCDecl : cast<Decl>(D->getLexicalDeclContext())->redecls()) {
auto *DC = cast<DeclContext>(DCDecl);
SmallVector<Decl*, 8> Decls;
FindExternalLexicalDecls(
DC, [&](Decl::Kind K) { return K == D->getKind(); }, Decls);
}
If a declaration is loaded, and then a module import adds a redeclaration, then ensure that querying the first declaration for its most recent declaration checks for redeclarations from the imported module. This works as follows: * The 'most recent' pointer on a canonical declaration grows a pointer to the external AST source and a generation number (space- and time-optimized for the case where there is no external source). * Each time the 'most recent' pointer is queried, if it has an external source, we check whether it's up to date, and update it if not. * The ancillary data stored on the canonical declaration is allocated lazily to avoid filling it in for declarations that end up being non-canonical. We'll still perform a redundant (ASTContext) allocation if someone asks for the most recent declaration from a decl before setPreviousDecl is called, but such cases are probably all bugs, and are now easy to find. Some finessing is still in order here -- in particular, we use a very general mechanism for handling the DefinitionData pointer on CXXRecordData, and a more targeted approach would be more compact. Also, the MayHaveOutOfDateDef mechanism should now be expunged, since it was addressing only a corner of the full problem space here. That's not covered by this patch. Early performance benchmarks show that this makes no measurable difference to Clang performance without modules enabled (and fixes a major correctness issue with modules enabled). I'll revert if a full performance comparison shows any problems. llvm-svn: 209046
2014-05-17 07:01:30 +08:00
}
}
[modules] When we try to complete the redeclaration chain for a class template specialization, pull in any lazy specializations of the class template. llvm-svn: 227668
2015-01-31 11:04:55 +08:00
if (auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(D))
CTSD->getSpecializedTemplate()->LoadLazySpecializations();
if (auto *VTSD = dyn_cast<VarTemplateSpecializationDecl>(D))
VTSD->getSpecializedTemplate()->LoadLazySpecializations();
if (auto *FD = dyn_cast<FunctionDecl>(D)) {
if (auto *Template = FD->getPrimaryTemplate())
Template->LoadLazySpecializations();
}
If a declaration is loaded, and then a module import adds a redeclaration, then ensure that querying the first declaration for its most recent declaration checks for redeclarations from the imported module. This works as follows: * The 'most recent' pointer on a canonical declaration grows a pointer to the external AST source and a generation number (space- and time-optimized for the case where there is no external source). * Each time the 'most recent' pointer is queried, if it has an external source, we check whether it's up to date, and update it if not. * The ancillary data stored on the canonical declaration is allocated lazily to avoid filling it in for declarations that end up being non-canonical. We'll still perform a redundant (ASTContext) allocation if someone asks for the most recent declaration from a decl before setPreviousDecl is called, but such cases are probably all bugs, and are now easy to find. Some finessing is still in order here -- in particular, we use a very general mechanism for handling the DefinitionData pointer on CXXRecordData, and a more targeted approach would be more compact. Also, the MayHaveOutOfDateDef mechanism should now be expunged, since it was addressing only a corner of the full problem space here. That's not covered by this patch. Early performance benchmarks show that this makes no measurable difference to Clang performance without modules enabled (and fixes a major correctness issue with modules enabled). I'll revert if a full performance comparison shows any problems. llvm-svn: 209046
2014-05-17 07:01:30 +08:00
}
[modules] Deserialize CXXCtorInitializer list for a constructor lazily. Previously we'd deserialize the list of mem-initializers for a constructor when we deserialized the declaration of the constructor. That could trigger a significant amount of unnecessary work (pulling in all base classes recursively, for a start) and was causing problems for the modules buildbot due to cyclic deserializations. We now deserialize these on demand. This creates a certain amount of duplication with the handling of CXXBaseSpecifiers; I'll look into reducing that next. llvm-svn: 233052
2015-03-24 14:36:48 +08:00
uint64_t ASTReader::ReadCXXCtorInitializersRef(ModuleFile &M,
const RecordData &Record,
unsigned &Idx) {
if (Idx >= Record.size() || Record[Idx] > M.LocalNumCXXCtorInitializers) {
Error("malformed AST file: missing C++ ctor initializers");
return 0;
}
unsigned LocalID = Record[Idx++];
return getGlobalBitOffset(M, M.CXXCtorInitializersOffsets[LocalID - 1]);
}
CXXCtorInitializer **
ASTReader::GetExternalCXXCtorInitializers(uint64_t Offset) {
RecordLocation Loc = getLocalBitOffset(Offset);
BitstreamCursor &Cursor = Loc.F->DeclsCursor;
SavedStreamPosition SavedPosition(Cursor);
Cursor.JumpToBit(Loc.Offset);
ReadingKindTracker ReadingKind(Read_Decl, *this);
RecordData Record;
unsigned Code = Cursor.ReadCode();
unsigned RecCode = Cursor.readRecord(Code, Record);
if (RecCode != DECL_CXX_CTOR_INITIALIZERS) {
Error("malformed AST file: missing C++ ctor initializers");
return nullptr;
}
unsigned Idx = 0;
return ReadCXXCtorInitializers(*Loc.F, Record, Idx);
}
When a module completes the definition of a class template specialization imported from another module, emit an update record, rather than using the broken decl rewriting mechanism. If multiple modules do this, merge the definitions together, much as we would if they were separate declarations. llvm-svn: 206680
2014-04-19 11:48:30 +08:00
uint64_t ASTReader::readCXXBaseSpecifiers(ModuleFile &M,
const RecordData &Record,
unsigned &Idx) {
if (Idx >= Record.size() || Record[Idx] > M.LocalNumCXXBaseSpecifiers) {
Error("malformed AST file: missing C++ base specifier");
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
return 0;
When a module completes the definition of a class template specialization imported from another module, emit an update record, rather than using the broken decl rewriting mechanism. If multiple modules do this, merge the definitions together, much as we would if they were separate declarations. llvm-svn: 206680
2014-04-19 11:48:30 +08:00
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
unsigned LocalID = Record[Idx++];
return getGlobalBitOffset(M, M.CXXBaseSpecifiersOffsets[LocalID - 1]);
}
CXXBaseSpecifier *ASTReader::GetExternalCXXBaseSpecifiers(uint64_t Offset) {
RecordLocation Loc = getLocalBitOffset(Offset);
finish converting the normal cases in ASTReader to use the new BitstreamCursor APIs. llvm-svn: 172937
2013-01-20 08:56:42 +08:00
BitstreamCursor &Cursor = Loc.F->DeclsCursor;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
SavedStreamPosition SavedPosition(Cursor);
Cursor.JumpToBit(Loc.Offset);
ReadingKindTracker ReadingKind(Read_Decl, *this);
RecordData Record;
unsigned Code = Cursor.ReadCode();
update to use the new BitcodeCursor readRecord that takes a StringRef blob parameter, and adopt "advance" in more places. llvm-svn: 172951
2013-01-20 10:38:54 +08:00
unsigned RecCode = Cursor.readRecord(Code, Record);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
if (RecCode != DECL_CXX_BASE_SPECIFIERS) {
When a module completes the definition of a class template specialization imported from another module, emit an update record, rather than using the broken decl rewriting mechanism. If multiple modules do this, merge the definitions together, much as we would if they were separate declarations. llvm-svn: 206680
2014-04-19 11:48:30 +08:00
Error("malformed AST file: missing C++ base specifiers");
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
return nullptr;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
unsigned Idx = 0;
unsigned NumBases = Record[Idx++];
void *Mem = Context.Allocate(sizeof(CXXBaseSpecifier) * NumBases);
CXXBaseSpecifier *Bases = new (Mem) CXXBaseSpecifier [NumBases];
for (unsigned I = 0; I != NumBases; ++I)
Bases[I] = ReadCXXBaseSpecifier(*Loc.F, Record, Idx);
return Bases;
}
serialization::DeclID
ASTReader::getGlobalDeclID(ModuleFile &F, LocalDeclID LocalID) const {
if (LocalID < NUM_PREDEF_DECL_IDS)
return LocalID;
ContinuousRangeMap<uint32_t, int, 2>::iterator I
= F.DeclRemap.find(LocalID - NUM_PREDEF_DECL_IDS);
assert(I != F.DeclRemap.end() && "Invalid index into decl index remap");
return LocalID + I->second;
}
bool ASTReader::isDeclIDFromModule(serialization::GlobalDeclID ID,
ModuleFile &M) const {
[modules] Rework merging of redeclaration chains on module import. We used to save out and eagerly load a (potentially huge) table of merged formerly-canonical declarations when we loaded each module. This was extremely inefficient in the presence of large amounts of merging, and didn't actually save any merging lookup work, because we still needed to perform name lookup to check that our merged declaration lists were complete. This also resulted in a loss of laziness -- even if we only needed an early declaration of an entity, we would eagerly pull in all declarations that had been merged into it regardless. We now store the relevant fragments of the table within the declarations themselves. In detail: * The first declaration of each entity within a module stores a list of first declarations from imported modules that are merged into it. * Loading that declaration pre-loads those other entities, so that they appear earlier within the redeclaration chain. * The name lookup tables list the most recent local lookup result, if there is one, or all directly-imported lookup results if not. llvm-svn: 231424
2015-03-06 07:24:12 +08:00
// Predefined decls aren't from any module.
if (ID < NUM_PREDEF_DECL_IDS)
return false;
Minor simplification, no functionality change. llvm-svn: 242001
2015-07-13 07:51:20 +08:00
return ID - NUM_PREDEF_DECL_IDS >= M.BaseDeclID &&
ID - NUM_PREDEF_DECL_IDS < M.BaseDeclID + M.LocalNumDecls;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
Introduce a fast path for the ASTReader's name lookup within a DeclContext. When the DeclContext is of a kind that can only be defined once and never updated, we limit the search to the module file that conatins the lookup table. Provides a 15% speedup in one modules-heavy source file. llvm-svn: 173050
2013-01-21 23:25:38 +08:00
ModuleFile *ASTReader::getOwningModuleFile(const Decl *D) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
if (!D->isFromASTFile())
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
return nullptr;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(D->getGlobalID());
assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
return I->second;
}
SourceLocation ASTReader::getSourceLocationForDeclID(GlobalDeclID ID) {
if (ID < NUM_PREDEF_DECL_IDS)
return SourceLocation();
When a module completes the definition of a class template specialization imported from another module, emit an update record, rather than using the broken decl rewriting mechanism. If multiple modules do this, merge the definitions together, much as we would if they were separate declarations. llvm-svn: 206680
2014-04-19 11:48:30 +08:00
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
unsigned Index = ID - NUM_PREDEF_DECL_IDS;
if (Index > DeclsLoaded.size()) {
Error("declaration ID out-of-range for AST file");
return SourceLocation();
}
When a module completes the definition of a class template specialization imported from another module, emit an update record, rather than using the broken decl rewriting mechanism. If multiple modules do this, merge the definitions together, much as we would if they were separate declarations. llvm-svn: 206680
2014-04-19 11:48:30 +08:00
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
if (Decl *D = DeclsLoaded[Index])
return D->getLocation();
unsigned RawLocation = 0;
RecordLocation Rec = DeclCursorForID(ID, RawLocation);
return ReadSourceLocation(*Rec.F, RawLocation);
}
[modules] Rework merging of redeclaration chains on module import. We used to save out and eagerly load a (potentially huge) table of merged formerly-canonical declarations when we loaded each module. This was extremely inefficient in the presence of large amounts of merging, and didn't actually save any merging lookup work, because we still needed to perform name lookup to check that our merged declaration lists were complete. This also resulted in a loss of laziness -- even if we only needed an early declaration of an entity, we would eagerly pull in all declarations that had been merged into it regardless. We now store the relevant fragments of the table within the declarations themselves. In detail: * The first declaration of each entity within a module stores a list of first declarations from imported modules that are merged into it. * Loading that declaration pre-loads those other entities, so that they appear earlier within the redeclaration chain. * The name lookup tables list the most recent local lookup result, if there is one, or all directly-imported lookup results if not. llvm-svn: 231424
2015-03-06 07:24:12 +08:00
static Decl *getPredefinedDecl(ASTContext &Context, PredefinedDeclIDs ID) {
switch (ID) {
case PREDEF_DECL_NULL_ID:
return nullptr;
When a module completes the definition of a class template specialization imported from another module, emit an update record, rather than using the broken decl rewriting mechanism. If multiple modules do this, merge the definitions together, much as we would if they were separate declarations. llvm-svn: 206680
2014-04-19 11:48:30 +08:00
[modules] Rework merging of redeclaration chains on module import. We used to save out and eagerly load a (potentially huge) table of merged formerly-canonical declarations when we loaded each module. This was extremely inefficient in the presence of large amounts of merging, and didn't actually save any merging lookup work, because we still needed to perform name lookup to check that our merged declaration lists were complete. This also resulted in a loss of laziness -- even if we only needed an early declaration of an entity, we would eagerly pull in all declarations that had been merged into it regardless. We now store the relevant fragments of the table within the declarations themselves. In detail: * The first declaration of each entity within a module stores a list of first declarations from imported modules that are merged into it. * Loading that declaration pre-loads those other entities, so that they appear earlier within the redeclaration chain. * The name lookup tables list the most recent local lookup result, if there is one, or all directly-imported lookup results if not. llvm-svn: 231424
2015-03-06 07:24:12 +08:00
case PREDEF_DECL_TRANSLATION_UNIT_ID:
return Context.getTranslationUnitDecl();
When a module completes the definition of a class template specialization imported from another module, emit an update record, rather than using the broken decl rewriting mechanism. If multiple modules do this, merge the definitions together, much as we would if they were separate declarations. llvm-svn: 206680
2014-04-19 11:48:30 +08:00
[modules] Rework merging of redeclaration chains on module import. We used to save out and eagerly load a (potentially huge) table of merged formerly-canonical declarations when we loaded each module. This was extremely inefficient in the presence of large amounts of merging, and didn't actually save any merging lookup work, because we still needed to perform name lookup to check that our merged declaration lists were complete. This also resulted in a loss of laziness -- even if we only needed an early declaration of an entity, we would eagerly pull in all declarations that had been merged into it regardless. We now store the relevant fragments of the table within the declarations themselves. In detail: * The first declaration of each entity within a module stores a list of first declarations from imported modules that are merged into it. * Loading that declaration pre-loads those other entities, so that they appear earlier within the redeclaration chain. * The name lookup tables list the most recent local lookup result, if there is one, or all directly-imported lookup results if not. llvm-svn: 231424
2015-03-06 07:24:12 +08:00
case PREDEF_DECL_OBJC_ID_ID:
return Context.getObjCIdDecl();
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
[modules] Rework merging of redeclaration chains on module import. We used to save out and eagerly load a (potentially huge) table of merged formerly-canonical declarations when we loaded each module. This was extremely inefficient in the presence of large amounts of merging, and didn't actually save any merging lookup work, because we still needed to perform name lookup to check that our merged declaration lists were complete. This also resulted in a loss of laziness -- even if we only needed an early declaration of an entity, we would eagerly pull in all declarations that had been merged into it regardless. We now store the relevant fragments of the table within the declarations themselves. In detail: * The first declaration of each entity within a module stores a list of first declarations from imported modules that are merged into it. * Loading that declaration pre-loads those other entities, so that they appear earlier within the redeclaration chain. * The name lookup tables list the most recent local lookup result, if there is one, or all directly-imported lookup results if not. llvm-svn: 231424
2015-03-06 07:24:12 +08:00
case PREDEF_DECL_OBJC_SEL_ID:
return Context.getObjCSelDecl();
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
[modules] Rework merging of redeclaration chains on module import. We used to save out and eagerly load a (potentially huge) table of merged formerly-canonical declarations when we loaded each module. This was extremely inefficient in the presence of large amounts of merging, and didn't actually save any merging lookup work, because we still needed to perform name lookup to check that our merged declaration lists were complete. This also resulted in a loss of laziness -- even if we only needed an early declaration of an entity, we would eagerly pull in all declarations that had been merged into it regardless. We now store the relevant fragments of the table within the declarations themselves. In detail: * The first declaration of each entity within a module stores a list of first declarations from imported modules that are merged into it. * Loading that declaration pre-loads those other entities, so that they appear earlier within the redeclaration chain. * The name lookup tables list the most recent local lookup result, if there is one, or all directly-imported lookup results if not. llvm-svn: 231424
2015-03-06 07:24:12 +08:00
case PREDEF_DECL_OBJC_CLASS_ID:
return Context.getObjCClassDecl();
When a module completes the definition of a class template specialization imported from another module, emit an update record, rather than using the broken decl rewriting mechanism. If multiple modules do this, merge the definitions together, much as we would if they were separate declarations. llvm-svn: 206680
2014-04-19 11:48:30 +08:00
[modules] Rework merging of redeclaration chains on module import. We used to save out and eagerly load a (potentially huge) table of merged formerly-canonical declarations when we loaded each module. This was extremely inefficient in the presence of large amounts of merging, and didn't actually save any merging lookup work, because we still needed to perform name lookup to check that our merged declaration lists were complete. This also resulted in a loss of laziness -- even if we only needed an early declaration of an entity, we would eagerly pull in all declarations that had been merged into it regardless. We now store the relevant fragments of the table within the declarations themselves. In detail: * The first declaration of each entity within a module stores a list of first declarations from imported modules that are merged into it. * Loading that declaration pre-loads those other entities, so that they appear earlier within the redeclaration chain. * The name lookup tables list the most recent local lookup result, if there is one, or all directly-imported lookup results if not. llvm-svn: 231424
2015-03-06 07:24:12 +08:00
case PREDEF_DECL_OBJC_PROTOCOL_ID:
return Context.getObjCProtocolDecl();
When a module completes the definition of a class template specialization imported from another module, emit an update record, rather than using the broken decl rewriting mechanism. If multiple modules do this, merge the definitions together, much as we would if they were separate declarations. llvm-svn: 206680
2014-04-19 11:48:30 +08:00
[modules] Rework merging of redeclaration chains on module import. We used to save out and eagerly load a (potentially huge) table of merged formerly-canonical declarations when we loaded each module. This was extremely inefficient in the presence of large amounts of merging, and didn't actually save any merging lookup work, because we still needed to perform name lookup to check that our merged declaration lists were complete. This also resulted in a loss of laziness -- even if we only needed an early declaration of an entity, we would eagerly pull in all declarations that had been merged into it regardless. We now store the relevant fragments of the table within the declarations themselves. In detail: * The first declaration of each entity within a module stores a list of first declarations from imported modules that are merged into it. * Loading that declaration pre-loads those other entities, so that they appear earlier within the redeclaration chain. * The name lookup tables list the most recent local lookup result, if there is one, or all directly-imported lookup results if not. llvm-svn: 231424
2015-03-06 07:24:12 +08:00
case PREDEF_DECL_INT_128_ID:
return Context.getInt128Decl();
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
[modules] Rework merging of redeclaration chains on module import. We used to save out and eagerly load a (potentially huge) table of merged formerly-canonical declarations when we loaded each module. This was extremely inefficient in the presence of large amounts of merging, and didn't actually save any merging lookup work, because we still needed to perform name lookup to check that our merged declaration lists were complete. This also resulted in a loss of laziness -- even if we only needed an early declaration of an entity, we would eagerly pull in all declarations that had been merged into it regardless. We now store the relevant fragments of the table within the declarations themselves. In detail: * The first declaration of each entity within a module stores a list of first declarations from imported modules that are merged into it. * Loading that declaration pre-loads those other entities, so that they appear earlier within the redeclaration chain. * The name lookup tables list the most recent local lookup result, if there is one, or all directly-imported lookup results if not. llvm-svn: 231424
2015-03-06 07:24:12 +08:00
case PREDEF_DECL_UNSIGNED_INT_128_ID:
return Context.getUInt128Decl();
When a module completes the definition of a class template specialization imported from another module, emit an update record, rather than using the broken decl rewriting mechanism. If multiple modules do this, merge the definitions together, much as we would if they were separate declarations. llvm-svn: 206680
2014-04-19 11:48:30 +08:00
[modules] Rework merging of redeclaration chains on module import. We used to save out and eagerly load a (potentially huge) table of merged formerly-canonical declarations when we loaded each module. This was extremely inefficient in the presence of large amounts of merging, and didn't actually save any merging lookup work, because we still needed to perform name lookup to check that our merged declaration lists were complete. This also resulted in a loss of laziness -- even if we only needed an early declaration of an entity, we would eagerly pull in all declarations that had been merged into it regardless. We now store the relevant fragments of the table within the declarations themselves. In detail: * The first declaration of each entity within a module stores a list of first declarations from imported modules that are merged into it. * Loading that declaration pre-loads those other entities, so that they appear earlier within the redeclaration chain. * The name lookup tables list the most recent local lookup result, if there is one, or all directly-imported lookup results if not. llvm-svn: 231424
2015-03-06 07:24:12 +08:00
case PREDEF_DECL_OBJC_INSTANCETYPE_ID:
return Context.getObjCInstanceTypeDecl();
case PREDEF_DECL_BUILTIN_VA_LIST_ID:
return Context.getBuiltinVaListDecl();
Replace Sema's map of locally-scoped extern "C" declarations with a DeclContext of extern "C" declarations. This is simpler and vastly more efficient for modules builds (we no longer need to load *all* extern "C" declarations to determine if we have a redeclaration). No functionality change intended. llvm-svn: 231538
2015-03-07 08:04:49 +08:00
[modules] Add an assert for redeclarations that we never added to their redecl chain and fix the cases where it fires. * Handle the __va_list_tag as a predefined decl. Previously we failed to merge sometimes it because it's not visible to name lookup. (In passing, remove redundant __va_list_tag typedefs that we were creating for some ABIs. These didn't affect the mangling or representation of the type.) * For Decls derived from Redeclarable that are not in fact redeclarable (implicit params, function params, ObjC type parameters), remove them from the list of expected redeclarable decls. llvm-svn: 243259
2015-07-27 13:40:23 +08:00
case PREDEF_DECL_VA_LIST_TAG:
return Context.getVaListTagDecl();
Support __builtin_ms_va_list. Summary: This change adds support for `__builtin_ms_va_list`, a GCC extension for variadic `ms_abi` functions. The existing `__builtin_va_list` support is inadequate for this because `va_list` is defined differently in the Win64 ABI vs. the System V/AMD64 ABI. Depends on D1622. Reviewers: rsmith, rnk, rjmccall CC: cfe-commits Differential Revision: http://reviews.llvm.org/D1623 llvm-svn: 247941
2015-09-18 04:55:33 +08:00
case PREDEF_DECL_BUILTIN_MS_VA_LIST_ID:
return Context.getBuiltinMSVaListDecl();
Replace Sema's map of locally-scoped extern "C" declarations with a DeclContext of extern "C" declarations. This is simpler and vastly more efficient for modules builds (we no longer need to load *all* extern "C" declarations to determine if we have a redeclaration). No functionality change intended. llvm-svn: 231538
2015-03-07 08:04:49 +08:00
case PREDEF_DECL_EXTERN_C_CONTEXT_ID:
return Context.getExternCContextDecl();
[Sema] Implement __make_integer_seq This new builtin template allows for incredibly fast instantiations of templates like std::integer_sequence. Performance numbers follow: My work station has 64 GB of ram + 20 Xeon Cores at 2.8 GHz. __make_integer_seq<std::integer_sequence, int, 90000> takes 0.25 seconds. std::make_integer_sequence<int, 90000> takes unbound time, it is still running. Clang is consuming gigabytes of memory. Differential Revision: http://reviews.llvm.org/D13786 llvm-svn: 252036
2015-11-04 11:40:30 +08:00
case PREDEF_DECL_MAKE_INTEGER_SEQ_ID:
return Context.getMakeIntegerSeqDecl();
Reapply r259624, it is likely not the commit causing the bot failures. Original message: Make CF constant string decl visible to name lookup to fix module errors The return type of the __builtin___*StringMakeConstantString functions is a pointer to a struct, so we need that struct to be visible to name lookup so that we will correctly merge multiple declarations of that type if they come from different modules. Incidentally, to make this visible to name lookup we need to rename the type to __NSConstantString, since the real NSConstantString is an Objective-C interface type. This shouldn't affect anyone outside the compiler since users of the constant string builtins cast the result immediately to CFStringRef. Since this struct type is otherwise implicitly created by the AST context and cannot access namelookup, we make this a predefined type and initialize it in Sema. Note: this issue of builtins that refer to types not visible to name lookup technically also affects other builtins (e.g. objc_msgSendSuper), but in all other cases the builtin is a library builtin and the issue goes away if you include the library that defines the types it uses, unlike for these constant string builtins. rdar://problem/24425801 llvm-svn: 259721
2016-02-04 06:41:00 +08:00
case PREDEF_DECL_CF_CONSTANT_STRING_ID:
return Context.getCFConstantStringDecl();
[modules] Rework merging of redeclaration chains on module import. We used to save out and eagerly load a (potentially huge) table of merged formerly-canonical declarations when we loaded each module. This was extremely inefficient in the presence of large amounts of merging, and didn't actually save any merging lookup work, because we still needed to perform name lookup to check that our merged declaration lists were complete. This also resulted in a loss of laziness -- even if we only needed an early declaration of an entity, we would eagerly pull in all declarations that had been merged into it regardless. We now store the relevant fragments of the table within the declarations themselves. In detail: * The first declaration of each entity within a module stores a list of first declarations from imported modules that are merged into it. * Loading that declaration pre-loads those other entities, so that they appear earlier within the redeclaration chain. * The name lookup tables list the most recent local lookup result, if there is one, or all directly-imported lookup results if not. llvm-svn: 231424
2015-03-06 07:24:12 +08:00
}
Silence C4715 'not all control paths return a value' warnings. llvm-svn: 231455
2015-03-06 15:49:14 +08:00
llvm_unreachable("PredefinedDeclIDs unknown enum value");
[modules] Rework merging of redeclaration chains on module import. We used to save out and eagerly load a (potentially huge) table of merged formerly-canonical declarations when we loaded each module. This was extremely inefficient in the presence of large amounts of merging, and didn't actually save any merging lookup work, because we still needed to perform name lookup to check that our merged declaration lists were complete. This also resulted in a loss of laziness -- even if we only needed an early declaration of an entity, we would eagerly pull in all declarations that had been merged into it regardless. We now store the relevant fragments of the table within the declarations themselves. In detail: * The first declaration of each entity within a module stores a list of first declarations from imported modules that are merged into it. * Loading that declaration pre-loads those other entities, so that they appear earlier within the redeclaration chain. * The name lookup tables list the most recent local lookup result, if there is one, or all directly-imported lookup results if not. llvm-svn: 231424
2015-03-06 07:24:12 +08:00
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
[modules] Rework merging of redeclaration chains on module import. We used to save out and eagerly load a (potentially huge) table of merged formerly-canonical declarations when we loaded each module. This was extremely inefficient in the presence of large amounts of merging, and didn't actually save any merging lookup work, because we still needed to perform name lookup to check that our merged declaration lists were complete. This also resulted in a loss of laziness -- even if we only needed an early declaration of an entity, we would eagerly pull in all declarations that had been merged into it regardless. We now store the relevant fragments of the table within the declarations themselves. In detail: * The first declaration of each entity within a module stores a list of first declarations from imported modules that are merged into it. * Loading that declaration pre-loads those other entities, so that they appear earlier within the redeclaration chain. * The name lookup tables list the most recent local lookup result, if there is one, or all directly-imported lookup results if not. llvm-svn: 231424
2015-03-06 07:24:12 +08:00
Decl *ASTReader::GetExistingDecl(DeclID ID) {
if (ID < NUM_PREDEF_DECL_IDS) {
Decl *D = getPredefinedDecl(Context, (PredefinedDeclIDs)ID);
if (D) {
// Track that we have merged the declaration with ID \p ID into the
// pre-existing predefined declaration \p D.
[modules] Improve performance when there is a local declaration of an entity before the first imported declaration. We don't need to track all formerly-canonical declarations of an entity; it's sufficient to track those ones for which no other formerly-canonical declaration was imported into the same module. We call those ones "key declarations", and use them as our starting points for collecting redeclarations and performing namespace lookups. llvm-svn: 241999
2015-07-13 07:43:21 +08:00
auto &Merged = KeyDecls[D->getCanonicalDecl()];
[modules] Rework merging of redeclaration chains on module import. We used to save out and eagerly load a (potentially huge) table of merged formerly-canonical declarations when we loaded each module. This was extremely inefficient in the presence of large amounts of merging, and didn't actually save any merging lookup work, because we still needed to perform name lookup to check that our merged declaration lists were complete. This also resulted in a loss of laziness -- even if we only needed an early declaration of an entity, we would eagerly pull in all declarations that had been merged into it regardless. We now store the relevant fragments of the table within the declarations themselves. In detail: * The first declaration of each entity within a module stores a list of first declarations from imported modules that are merged into it. * Loading that declaration pre-loads those other entities, so that they appear earlier within the redeclaration chain. * The name lookup tables list the most recent local lookup result, if there is one, or all directly-imported lookup results if not. llvm-svn: 231424
2015-03-06 07:24:12 +08:00
if (Merged.empty())
Merged.push_back(ID);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
[modules] Rework merging of redeclaration chains on module import. We used to save out and eagerly load a (potentially huge) table of merged formerly-canonical declarations when we loaded each module. This was extremely inefficient in the presence of large amounts of merging, and didn't actually save any merging lookup work, because we still needed to perform name lookup to check that our merged declaration lists were complete. This also resulted in a loss of laziness -- even if we only needed an early declaration of an entity, we would eagerly pull in all declarations that had been merged into it regardless. We now store the relevant fragments of the table within the declarations themselves. In detail: * The first declaration of each entity within a module stores a list of first declarations from imported modules that are merged into it. * Loading that declaration pre-loads those other entities, so that they appear earlier within the redeclaration chain. * The name lookup tables list the most recent local lookup result, if there is one, or all directly-imported lookup results if not. llvm-svn: 231424
2015-03-06 07:24:12 +08:00
return D;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
When a module completes the definition of a class template specialization imported from another module, emit an update record, rather than using the broken decl rewriting mechanism. If multiple modules do this, merge the definitions together, much as we would if they were separate declarations. llvm-svn: 206680
2014-04-19 11:48:30 +08:00
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
unsigned Index = ID - NUM_PREDEF_DECL_IDS;
if (Index >= DeclsLoaded.size()) {
assert(0 && "declaration ID out-of-range for AST file");
Error("declaration ID out-of-range for AST file");
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
return nullptr;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
When a module completes the definition of a class template specialization imported from another module, emit an update record, rather than using the broken decl rewriting mechanism. If multiple modules do this, merge the definitions together, much as we would if they were separate declarations. llvm-svn: 206680
2014-04-19 11:48:30 +08:00
return DeclsLoaded[Index];
}
Decl *ASTReader::GetDecl(DeclID ID) {
if (ID < NUM_PREDEF_DECL_IDS)
return GetExistingDecl(ID);
unsigned Index = ID - NUM_PREDEF_DECL_IDS;
if (Index >= DeclsLoaded.size()) {
assert(0 && "declaration ID out-of-range for AST file");
Error("declaration ID out-of-range for AST file");
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
return nullptr;
When a module completes the definition of a class template specialization imported from another module, emit an update record, rather than using the broken decl rewriting mechanism. If multiple modules do this, merge the definitions together, much as we would if they were separate declarations. llvm-svn: 206680
2014-04-19 11:48:30 +08:00
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
if (!DeclsLoaded[Index]) {
ReadDeclRecord(ID);
if (DeserializationListener)
DeserializationListener->DeclRead(ID, DeclsLoaded[Index]);
}
return DeclsLoaded[Index];
}
DeclID ASTReader::mapGlobalIDToModuleFileGlobalID(ModuleFile &M,
DeclID GlobalID) {
if (GlobalID < NUM_PREDEF_DECL_IDS)
return GlobalID;
GlobalDeclMapType::const_iterator I = GlobalDeclMap.find(GlobalID);
assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
ModuleFile *Owner = I->second;
llvm::DenseMap<ModuleFile *, serialization::DeclID>::iterator Pos
= M.GlobalToLocalDeclIDs.find(Owner);
if (Pos == M.GlobalToLocalDeclIDs.end())
return 0;
return GlobalID - Owner->BaseDeclID + Pos->second;
}
serialization::DeclID ASTReader::ReadDeclID(ModuleFile &F,
const RecordData &Record,
unsigned &Idx) {
if (Idx >= Record.size()) {
Error("Corrupted AST file");
return 0;
}
return getGlobalDeclID(F, Record[Idx++]);
}
/// \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).
Stmt *ASTReader::GetExternalDeclStmt(uint64_t Offset) {
// Switch case IDs are per Decl.
ClearSwitchCaseIDs();
// Offset here is a global offset across the entire chain.
RecordLocation Loc = getLocalBitOffset(Offset);
Loc.F->DeclsCursor.JumpToBit(Loc.Offset);
return ReadStmtFromStream(*Loc.F);
}
[modules] Stop walking all modules when looking for lexical decls for a DeclContext. These only ever come from the owning module file for the Decl. llvm-svn: 244285
2015-08-07 06:07:25 +08:00
void ASTReader::FindExternalLexicalDecls(
const DeclContext *DC, llvm::function_ref<bool(Decl::Kind)> IsKindWeWant,
SmallVectorImpl<Decl *> &Decls) {
bool PredefsVisited[NUM_PREDEF_DECL_IDS] = {};
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
[modules] Fix use-after-iterator-invalidation bug. llvm-svn: 244288
2015-08-07 06:14:12 +08:00
auto Visit = [&] (ModuleFile *M, LexicalContents LexicalDecls) {
[modules] Stop walking all modules when looking for lexical decls for a DeclContext. These only ever come from the owning module file for the Decl. llvm-svn: 244285
2015-08-07 06:07:25 +08:00
assert(LexicalDecls.size() % 2 == 0 && "expected an even number of entries");
for (int I = 0, N = LexicalDecls.size(); I != N; I += 2) {
auto K = (Decl::Kind)+LexicalDecls[I];
if (!IsKindWeWant(K))
continue;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
[modules] Stop walking all modules when looking for lexical decls for a DeclContext. These only ever come from the owning module file for the Decl. llvm-svn: 244285
2015-08-07 06:07:25 +08:00
auto ID = (serialization::DeclID)+LexicalDecls[I + 1];
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
[modules] Stop walking all modules when looking for lexical decls for a DeclContext. These only ever come from the owning module file for the Decl. llvm-svn: 244285
2015-08-07 06:07:25 +08:00
// Don't add predefined declarations to the lexical context more
// than once.
if (ID < NUM_PREDEF_DECL_IDS) {
if (PredefsVisited[ID])
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
continue;
[modules] Stop walking all modules when looking for lexical decls for a DeclContext. These only ever come from the owning module file for the Decl. llvm-svn: 244285
2015-08-07 06:07:25 +08:00
PredefsVisited[ID] = true;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
[modules] Stop walking all modules when looking for lexical decls for a DeclContext. These only ever come from the owning module file for the Decl. llvm-svn: 244285
2015-08-07 06:07:25 +08:00
if (Decl *D = GetLocalDecl(*M, ID)) {
Add an assert to catch lexical decl deserialization bugs. llvm-svn: 244671
2015-08-12 05:21:20 +08:00
assert(D->getKind() == K && "wrong kind for lexical decl");
[modules] Stop walking all modules when looking for lexical decls for a DeclContext. These only ever come from the owning module file for the Decl. llvm-svn: 244285
2015-08-07 06:07:25 +08:00
if (!DC->isDeclInLexicalTraversal(D))
Decls.push_back(D);
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
};
[modules] Stop walking all modules when looking for lexical decls for a DeclContext. These only ever come from the owning module file for the Decl. llvm-svn: 244285
2015-08-07 06:07:25 +08:00
if (isa<TranslationUnitDecl>(DC)) {
for (auto Lexical : TULexicalDecls)
Visit(Lexical.first, Lexical.second);
} else {
auto I = LexicalDecls.find(DC);
if (I != LexicalDecls.end())
[modules] When instantiating the contents of an imported CXXRecordDecl, we can emit lexical contents for a declaration for another module. Track which module those contents came from, and ensure that we only grab the lexical contents from a single such instantiation. llvm-svn: 244682
2015-08-12 06:00:24 +08:00
Visit(I->second.first, I->second.second);
[modules] Stop walking all modules when looking for lexical decls for a DeclContext. These only ever come from the owning module file for the Decl. llvm-svn: 244285
2015-08-07 06:07:25 +08:00
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
++NumLexicalDeclContextsRead;
}
namespace {
class DeclIDComp {
ASTReader &Reader;
ModuleFile &Mod;
public:
DeclIDComp(ASTReader &Reader, ModuleFile &M) : Reader(Reader), Mod(M) {}
bool operator()(LocalDeclID L, LocalDeclID R) const {
SourceLocation LHS = getLocation(L);
SourceLocation RHS = getLocation(R);
return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
}
bool operator()(SourceLocation LHS, LocalDeclID R) const {
SourceLocation RHS = getLocation(R);
return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
}
bool operator()(LocalDeclID L, SourceLocation RHS) const {
SourceLocation LHS = getLocation(L);
return Reader.getSourceManager().isBeforeInTranslationUnit(LHS, RHS);
}
SourceLocation getLocation(LocalDeclID ID) const {
return Reader.getSourceManager().getFileLoc(
Reader.getSourceLocationForDeclID(Reader.getGlobalDeclID(Mod, ID)));
}
};
Revert r240270 ("Fixed/added namespace ending comments using clang-tidy"). llvm-svn: 240353
2015-06-23 07:07:51 +08:00
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
void ASTReader::FindFileRegionDecls(FileID File,
unsigned Offset, unsigned Length,
SmallVectorImpl<Decl *> &Decls) {
SourceManager &SM = getSourceManager();
llvm::DenseMap<FileID, FileDeclsInfo>::iterator I = FileDeclIDs.find(File);
if (I == FileDeclIDs.end())
return;
FileDeclsInfo &DInfo = I->second;
if (DInfo.Decls.empty())
return;
SourceLocation
BeginLoc = SM.getLocForStartOfFile(File).getLocWithOffset(Offset);
SourceLocation EndLoc = BeginLoc.getLocWithOffset(Length);
DeclIDComp DIDComp(*this, *DInfo.Mod);
ArrayRef<serialization::LocalDeclID>::iterator
BeginIt = std::lower_bound(DInfo.Decls.begin(), DInfo.Decls.end(),
BeginLoc, DIDComp);
if (BeginIt != DInfo.Decls.begin())
--BeginIt;
// If we are pointing at a top-level decl inside an objc container, we need
// to backtrack until we find it otherwise we will fail to report that the
// region overlaps with an objc container.
while (BeginIt != DInfo.Decls.begin() &&
GetDecl(getGlobalDeclID(*DInfo.Mod, *BeginIt))
->isTopLevelDeclInObjCContainer())
--BeginIt;
ArrayRef<serialization::LocalDeclID>::iterator
EndIt = std::upper_bound(DInfo.Decls.begin(), DInfo.Decls.end(),
EndLoc, DIDComp);
if (EndIt != DInfo.Decls.end())
++EndIt;
for (ArrayRef<serialization::LocalDeclID>::iterator
DIt = BeginIt; DIt != EndIt; ++DIt)
Decls.push_back(GetDecl(getGlobalDeclID(*DInfo.Mod, *DIt)));
}
Simplify FindExternalVisibleDeclsByName by making it return a bool indicating if it found any decls, rather than returning a list of found decls. This removes a returning-ArrayRef-to-deleted-storage bug from MultiplexExternalSemaSource (in code not exercised by any of the clang binaries), reduces the work required in the found-no-decls case with PCH, and importantly removes the need for DeclContext::lookup to be reentrant. No functionality change intended! llvm-svn: 174576
2013-02-07 11:30:24 +08:00
bool
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
ASTReader::FindExternalVisibleDeclsByName(const DeclContext *DC,
DeclarationName Name) {
Re-commit r246497 (and dependent changes r246524 and r246521), reverted in r246546, with a workaround for an MSVC 2013 miscompile and an MSVC 2015 rejects-valid. Original commit message: [modules] Rework serialized DeclContext lookup table management. Instead of walking the loaded ModuleFiles looking for lookup tables for the context, store them all in one place, and merge them together if we find we have too many (currently, more than 4). If we do merge, include the merged form in our serialized lookup table, so that downstream readers never need to look at our imports' tables. This gives a huge performance improvement to builds with very large numbers of modules (in some cases, more than a 2x speedup was observed). llvm-svn: 246582
2015-09-02 04:35:42 +08:00
assert(DC->hasExternalVisibleStorage() && DC == DC->getPrimaryContext() &&
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
"DeclContext has no visible decls in storage");
if (!Name)
Simplify FindExternalVisibleDeclsByName by making it return a bool indicating if it found any decls, rather than returning a list of found decls. This removes a returning-ArrayRef-to-deleted-storage bug from MultiplexExternalSemaSource (in code not exercised by any of the clang binaries), reduces the work required in the found-no-decls case with PCH, and importantly removes the need for DeclContext::lookup to be reentrant. No functionality change intended! llvm-svn: 174576
2013-02-07 11:30:24 +08:00
return false;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
Re-commit r246497 (and dependent changes r246524 and r246521), reverted in r246546, with a workaround for an MSVC 2013 miscompile and an MSVC 2015 rejects-valid. Original commit message: [modules] Rework serialized DeclContext lookup table management. Instead of walking the loaded ModuleFiles looking for lookup tables for the context, store them all in one place, and merge them together if we find we have too many (currently, more than 4). If we do merge, include the merged form in our serialized lookup table, so that downstream readers never need to look at our imports' tables. This gives a huge performance improvement to builds with very large numbers of modules (in some cases, more than a 2x speedup was observed). llvm-svn: 246582
2015-09-02 04:35:42 +08:00
auto It = Lookups.find(DC);
if (It == Lookups.end())
return false;
[modules] When we merge together multiple class template specialization definitions (because some other declaration declares a special member that isn't present in the canonical definition), we need to search *all* of them; we can't just stop when we find the requested name in any of the definitions, because that can fail to find things (and in particular, it can fail to find the member of the canonical declaration and return a bogus ODR failure). llvm-svn: 215612
2014-08-14 10:21:01 +08:00
Deserializing LookupResults(this);
Re-commit r246497 (and dependent changes r246524 and r246521), reverted in r246546, with a workaround for an MSVC 2013 miscompile and an MSVC 2015 rejects-valid. Original commit message: [modules] Rework serialized DeclContext lookup table management. Instead of walking the loaded ModuleFiles looking for lookup tables for the context, store them all in one place, and merge them together if we find we have too many (currently, more than 4). If we do merge, include the merged form in our serialized lookup table, so that downstream readers never need to look at our imports' tables. This gives a huge performance improvement to builds with very large numbers of modules (in some cases, more than a 2x speedup was observed). llvm-svn: 246582
2015-09-02 04:35:42 +08:00
// Load the list of declarations.
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
SmallVector<NamedDecl *, 64> Decls;
Re-commit r246497 (and dependent changes r246524 and r246521), reverted in r246546, with a workaround for an MSVC 2013 miscompile and an MSVC 2015 rejects-valid. Original commit message: [modules] Rework serialized DeclContext lookup table management. Instead of walking the loaded ModuleFiles looking for lookup tables for the context, store them all in one place, and merge them together if we find we have too many (currently, more than 4). If we do merge, include the merged form in our serialized lookup table, so that downstream readers never need to look at our imports' tables. This gives a huge performance improvement to builds with very large numbers of modules (in some cases, more than a 2x speedup was observed). llvm-svn: 246582
2015-09-02 04:35:42 +08:00
for (DeclID ID : It->second.Table.find(Name)) {
NamedDecl *ND = cast<NamedDecl>(GetDecl(ID));
if (ND->getDeclName() == Name)
Decls.push_back(ND);
}
[modules] When we merge together multiple class template specialization definitions (because some other declaration declares a special member that isn't present in the canonical definition), we need to search *all* of them; we can't just stop when we find the requested name in any of the definitions, because that can fail to find things (and in particular, it can fail to find the member of the canonical declaration and return a bogus ODR failure). llvm-svn: 215612
2014-08-14 10:21:01 +08:00
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
++NumVisibleDeclContextsRead;
SetExternalVisibleDeclsForName(DC, Name, Decls);
Simplify FindExternalVisibleDeclsByName by making it return a bool indicating if it found any decls, rather than returning a list of found decls. This removes a returning-ArrayRef-to-deleted-storage bug from MultiplexExternalSemaSource (in code not exercised by any of the clang binaries), reduces the work required in the found-no-decls case with PCH, and importantly removes the need for DeclContext::lookup to be reentrant. No functionality change intended! llvm-svn: 174576
2013-02-07 11:30:24 +08:00
return !Decls.empty();
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
void ASTReader::completeVisibleDeclsMap(const DeclContext *DC) {
if (!DC->hasExternalVisibleStorage())
return;
[modules] Rework serialized DeclContext lookup table management. Instead of walking the loaded ModuleFiles looking for lookup tables for the context, store them all in one place, and merge them together if we find we have too many (currently, more than 4). If we do merge, include the merged form in our serialized lookup table, so that downstream readers never need to look at our imports' tables. This gives a huge performance improvement to builds with very large numbers of modules (in some cases, more than a 2x speedup was observed). llvm-svn: 246497
2015-09-01 06:17:11 +08:00
Re-commit r246497 (and dependent changes r246524 and r246521), reverted in r246546, with a workaround for an MSVC 2013 miscompile and an MSVC 2015 rejects-valid. Original commit message: [modules] Rework serialized DeclContext lookup table management. Instead of walking the loaded ModuleFiles looking for lookup tables for the context, store them all in one place, and merge them together if we find we have too many (currently, more than 4). If we do merge, include the merged form in our serialized lookup table, so that downstream readers never need to look at our imports' tables. This gives a huge performance improvement to builds with very large numbers of modules (in some cases, more than a 2x speedup was observed). llvm-svn: 246582
2015-09-02 04:35:42 +08:00
auto It = Lookups.find(DC);
assert(It != Lookups.end() &&
"have external visible storage but no lookup tables");
Reverting r246497 (which requires also reverting r246524 and r246521 to avoid merge conflicts). It broke the build on MSVC 2015. It also broke an MSVC 2013 bot with testing issues. llvm\tools\clang\lib\serialization\MultiOnDiskHashTable.h(117): error C2065: 'Files': undeclared identifier http://bb.pgr.jp/builders/ninja-clang-i686-msc18-R/builds/2917 llvm-svn: 246546
2015-09-01 21:24:39 +08:00
Re-commit r246497 (and dependent changes r246524 and r246521), reverted in r246546, with a workaround for an MSVC 2013 miscompile and an MSVC 2015 rejects-valid. Original commit message: [modules] Rework serialized DeclContext lookup table management. Instead of walking the loaded ModuleFiles looking for lookup tables for the context, store them all in one place, and merge them together if we find we have too many (currently, more than 4). If we do merge, include the merged form in our serialized lookup table, so that downstream readers never need to look at our imports' tables. This gives a huge performance improvement to builds with very large numbers of modules (in some cases, more than a 2x speedup was observed). llvm-svn: 246582
2015-09-02 04:35:42 +08:00
DeclsMap Decls;
for (DeclID ID : It->second.Table.findAll()) {
NamedDecl *ND = cast<NamedDecl>(GetDecl(ID));
Decls[ND->getDeclName()].push_back(ND);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
++NumVisibleDeclContextsRead;
Add typedefs for Densemaps containing SmallVectors to avoid repeating the SmallVector size when creating iterators for the DenseMap. llvm-svn: 185682
2013-07-05 12:33:53 +08:00
for (DeclsMap::iterator I = Decls.begin(), E = Decls.end(); I != E; ++I) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
SetExternalVisibleDeclsForName(DC, I->first, I->second);
}
const_cast<DeclContext *>(DC)->setHasExternalVisibleStorage(false);
}
Re-commit r246497 (and dependent changes r246524 and r246521), reverted in r246546, with a workaround for an MSVC 2013 miscompile and an MSVC 2015 rejects-valid. Original commit message: [modules] Rework serialized DeclContext lookup table management. Instead of walking the loaded ModuleFiles looking for lookup tables for the context, store them all in one place, and merge them together if we find we have too many (currently, more than 4). If we do merge, include the merged form in our serialized lookup table, so that downstream readers never need to look at our imports' tables. This gives a huge performance improvement to builds with very large numbers of modules (in some cases, more than a 2x speedup was observed). llvm-svn: 246582
2015-09-02 04:35:42 +08:00
const serialization::reader::DeclContextLookupTable *
ASTReader::getLoadedLookupTables(DeclContext *Primary) const {
auto I = Lookups.find(Primary);
return I == Lookups.end() ? nullptr : &I->second;
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
/// \brief Under non-PCH compilation the consumer receives the objc methods
/// before receiving the implementation, and codegen depends on this.
/// We simulate this by deserializing and passing to consumer the methods of the
/// implementation before passing the deserialized implementation decl.
static void PassObjCImplDeclToConsumer(ObjCImplDecl *ImplD,
ASTConsumer *Consumer) {
assert(ImplD && Consumer);
[C++11] Replacing ObjCContainerDecl iterators meth_begin() and meth_end() with iterator_range methods(). Updating all of the usages of the iterators with range-based for loops. llvm-svn: 203832
2014-03-14 03:03:34 +08:00
for (auto *I : ImplD->methods())
Consumer->HandleInterestingDecl(DeclGroupRef(I));
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
Consumer->HandleInterestingDecl(DeclGroupRef(ImplD));
}
void ASTReader::PassInterestingDeclsToConsumer() {
assert(Consumer);
If an update record makes a declaration interesting, pass it to the consumer. llvm-svn: 204550
2014-03-23 08:27:18 +08:00
if (PassingDeclsToConsumer)
return;
// Guard variable to avoid recursively redoing the process of passing
// decls to consumer.
SaveAndRestore<bool> GuardPassingDeclsToConsumer(PassingDeclsToConsumer,
true);
[modules] Remove redundant import of lexical decls when building a lookup table for a DeclContext, and fix propagation of exception specifications along redeclaration chains. This reverts r232905, r232907, and r232907, which reverted r232793, r232853, and r232853. One additional change is present here to resolve issues with LLDB: distinguish between whether lexical decls missing from the lookup table are local or are provided by the external AST source, and still look in the external source if that's where they came from. llvm-svn: 232928
2015-03-23 11:25:59 +08:00
// Ensure that we've loaded all potentially-interesting declarations
// that need to be eagerly loaded.
for (auto ID : EagerlyDeserializedDecls)
GetDecl(ID);
EagerlyDeserializedDecls.clear();
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
while (!InterestingDecls.empty()) {
Decl *D = InterestingDecls.front();
InterestingDecls.pop_front();
PassInterestingDeclToConsumer(D);
}
}
void ASTReader::PassInterestingDeclToConsumer(Decl *D) {
if (ObjCImplDecl *ImplD = dyn_cast<ObjCImplDecl>(D))
PassObjCImplDeclToConsumer(ImplD, Consumer);
else
Consumer->HandleInterestingDecl(DeclGroupRef(D));
}
void ASTReader::StartTranslationUnit(ASTConsumer *Consumer) {
this->Consumer = Consumer;
[modules] Remove redundant import of lexical decls when building a lookup table for a DeclContext, and fix propagation of exception specifications along redeclaration chains. This reverts r232905, r232907, and r232907, which reverted r232793, r232853, and r232853. One additional change is present here to resolve issues with LLDB: distinguish between whether lexical decls missing from the lookup table are local or are provided by the external AST source, and still look in the external source if that's where they came from. llvm-svn: 232928
2015-03-23 11:25:59 +08:00
if (Consumer)
PassInterestingDeclsToConsumer();
Make module files passed to a module build via -fmodule-file= available to consumers of that module. Previously, such a file would only be available if the module happened to actually import something from that module. llvm-svn: 232583
2015-03-18 09:42:29 +08:00
if (DeserializationListener)
DeserializationListener->ReaderInitialized(this);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
void ASTReader::PrintStats() {
std::fprintf(stderr, "*** AST File Statistics:\n");
unsigned NumTypesLoaded
= TypesLoaded.size() - std::count(TypesLoaded.begin(), TypesLoaded.end(),
QualType());
unsigned NumDeclsLoaded
= DeclsLoaded.size() - std::count(DeclsLoaded.begin(), DeclsLoaded.end(),
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
(Decl *)nullptr);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
unsigned NumIdentifiersLoaded
= IdentifiersLoaded.size() - std::count(IdentifiersLoaded.begin(),
IdentifiersLoaded.end(),
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
(IdentifierInfo *)nullptr);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
unsigned NumMacrosLoaded
= MacrosLoaded.size() - std::count(MacrosLoaded.begin(),
MacrosLoaded.end(),
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
(MacroInfo *)nullptr);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
unsigned NumSelectorsLoaded
= SelectorsLoaded.size() - std::count(SelectorsLoaded.begin(),
SelectorsLoaded.end(),
Selector());
if (unsigned TotalNumSLocEntries = getTotalNumSLocs())
std::fprintf(stderr, " %u/%u source location entries read (%f%%)\n",
NumSLocEntriesRead, TotalNumSLocEntries,
((float)NumSLocEntriesRead/TotalNumSLocEntries * 100));
if (!TypesLoaded.empty())
std::fprintf(stderr, " %u/%u types read (%f%%)\n",
NumTypesLoaded, (unsigned)TypesLoaded.size(),
((float)NumTypesLoaded/TypesLoaded.size() * 100));
if (!DeclsLoaded.empty())
std::fprintf(stderr, " %u/%u declarations read (%f%%)\n",
NumDeclsLoaded, (unsigned)DeclsLoaded.size(),
((float)NumDeclsLoaded/DeclsLoaded.size() * 100));
if (!IdentifiersLoaded.empty())
std::fprintf(stderr, " %u/%u identifiers read (%f%%)\n",
NumIdentifiersLoaded, (unsigned)IdentifiersLoaded.size(),
((float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100));
if (!MacrosLoaded.empty())
std::fprintf(stderr, " %u/%u macros read (%f%%)\n",
NumMacrosLoaded, (unsigned)MacrosLoaded.size(),
((float)NumMacrosLoaded/MacrosLoaded.size() * 100));
if (!SelectorsLoaded.empty())
std::fprintf(stderr, " %u/%u selectors read (%f%%)\n",
NumSelectorsLoaded, (unsigned)SelectorsLoaded.size(),
((float)NumSelectorsLoaded/SelectorsLoaded.size() * 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 (TotalNumMethodPoolEntries) {
std::fprintf(stderr, " %u/%u method pool entries read (%f%%)\n",
NumMethodPoolEntriesRead, TotalNumMethodPoolEntries,
((float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries
* 100));
}
Add some more ASTReader statistics for global method pool lookups. llvm-svn: 173702
2013-01-29 01:54:36 +08:00
if (NumMethodPoolLookups) {
std::fprintf(stderr, " %u/%u method pool lookups succeeded (%f%%)\n",
NumMethodPoolHits, NumMethodPoolLookups,
((float)NumMethodPoolHits/NumMethodPoolLookups * 100.0));
}
if (NumMethodPoolTableLookups) {
std::fprintf(stderr, " %u/%u method pool table lookups succeeded (%f%%)\n",
NumMethodPoolTableHits, NumMethodPoolTableLookups,
((float)NumMethodPoolTableHits/NumMethodPoolTableLookups
* 100.0));
}
Track the number of lookups and hits into the on-disk hash tables for identifiers within the AST file reader. llvm-svn: 173403
2013-01-25 08:38:33 +08:00
if (NumIdentifierLookupHits) {
std::fprintf(stderr,
" %u / %u identifier table lookups succeeded (%f%%)\n",
NumIdentifierLookupHits, NumIdentifierLookups,
(double)NumIdentifierLookupHits*100.0/NumIdentifierLookups);
}
Implement the reader of the global module index and wire it into the AST reader. The global module index tracks all of the identifiers known to a set of module files. Lookup of those identifiers looks first in the global module index, which returns the set of module files in which that identifier can be found. The AST reader only needs to look into those module files and any module files not known to the global index (e.g., because they were (re)built after the global index), reducing the number of on-disk hash tables to visit. For an example source I'm looking at, we go from 237844 total identifier lookups into on-disk hash tables down to 126817. Unfortunately, this does not translate into a performance advantage. At best, it's a wash once the global module index has been built, but that's ignore the cost of building the global module index (which is itself fairly large). Profiles show that the global module index code is far less efficient than it should be; optimizing it might give enough of an advantage to justify its continued inclusion. llvm-svn: 173405
2013-01-25 09:03:03 +08:00
if (GlobalIndex) {
std::fprintf(stderr, "\n");
GlobalIndex->printStats();
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
std::fprintf(stderr, "\n");
dump();
std::fprintf(stderr, "\n");
}
template<typename Key, typename ModuleFile, unsigned InitialCapacity>
static void
dumpModuleIDMap(StringRef Name,
const ContinuousRangeMap<Key, ModuleFile *,
InitialCapacity> &Map) {
if (Map.begin() == Map.end())
return;
typedef ContinuousRangeMap<Key, ModuleFile *, InitialCapacity> MapType;
llvm::errs() << Name << ":\n";
for (typename MapType::const_iterator I = Map.begin(), IEnd = Map.end();
I != IEnd; ++I) {
llvm::errs() << " " << I->first << " -> " << I->second->FileName
<< "\n";
}
}
Annotate dump() methods with LLVM_DUMP_METHOD, addressing Richard Smith r259192 post commit comment. llvm-svn: 259232
2016-01-30 03:38:18 +08:00
LLVM_DUMP_METHOD void ASTReader::dump() {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
llvm::errs() << "*** PCH/ModuleFile Remappings:\n";
dumpModuleIDMap("Global bit offset map", GlobalBitOffsetsMap);
dumpModuleIDMap("Global source location entry map", GlobalSLocEntryMap);
dumpModuleIDMap("Global type map", GlobalTypeMap);
dumpModuleIDMap("Global declaration map", GlobalDeclMap);
dumpModuleIDMap("Global identifier map", GlobalIdentifierMap);
dumpModuleIDMap("Global macro map", GlobalMacroMap);
dumpModuleIDMap("Global submodule map", GlobalSubmoduleMap);
dumpModuleIDMap("Global selector map", GlobalSelectorMap);
dumpModuleIDMap("Global preprocessed entity map",
GlobalPreprocessedEntityMap);
llvm::errs() << "\n*** PCH/Modules Loaded:";
for (ModuleManager::ModuleConstIterator M = ModuleMgr.begin(),
MEnd = ModuleMgr.end();
M != MEnd; ++M)
(*M)->dump();
}
/// Return the amount of memory used by memory buffers, breaking down
/// by heap-backed versus mmap'ed memory.
void ASTReader::getMemoryBufferSizes(MemoryBufferSizes &sizes) const {
for (ModuleConstIterator I = ModuleMgr.begin(),
E = ModuleMgr.end(); I != E; ++I) {
if (llvm::MemoryBuffer *buf = (*I)->Buffer.get()) {
size_t bytes = buf->getBufferSize();
switch (buf->getBufferKind()) {
case llvm::MemoryBuffer::MemoryBuffer_Malloc:
sizes.malloc_bytes += bytes;
break;
case llvm::MemoryBuffer::MemoryBuffer_MMap:
sizes.mmap_bytes += bytes;
break;
}
}
}
}
void ASTReader::InitializeSema(Sema &S) {
SemaObj = &S;
S.addExternalSource(this);
// Makes sure any declarations that were deserialized "too early"
// still get added to the identifier's declaration chains.
Avoid a couple of assertions when preprocessing with modules 1. We were hitting the NextIsPrevious assertion because we were trying to merge decl chains that were independent of each other because we had no Sema object to allow them to find existing decls. This is fixed by delaying loading the "preloaded" decls until Sema is available. 2. We were trying to get identifier info from an annotation token, which asserts. The fix is to special-case the module annotations in the preprocessed output printer. Fixed in a single commit because when you hit 1 you almost invariably hit 2 as well. llvm-svn: 217550
2014-09-11 05:29:41 +08:00
for (uint64_t ID : PreloadedDeclIDs) {
NamedDecl *D = cast<NamedDecl>(GetDecl(ID));
pushExternalDeclIntoScope(D, D->getDeclName());
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
Avoid a couple of assertions when preprocessing with modules 1. We were hitting the NextIsPrevious assertion because we were trying to merge decl chains that were independent of each other because we had no Sema object to allow them to find existing decls. This is fixed by delaying loading the "preloaded" decls until Sema is available. 2. We were trying to get identifier info from an annotation token, which asserts. The fix is to special-case the module annotations in the preprocessed output printer. Fixed in a single commit because when you hit 1 you almost invariably hit 2 as well. llvm-svn: 217550
2014-09-11 05:29:41 +08:00
PreloadedDeclIDs.clear();
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
C++ modules: don't lose track of a 'namespace std' that is imported from a module. llvm-svn: 192951
2013-10-18 14:54:39 +08:00
// FIXME: What happens if these are changed by a module import?
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
if (!FPPragmaOptions.empty()) {
assert(FPPragmaOptions.size() == 1 && "Wrong number of FP_PRAGMA_OPTIONS");
SemaObj->FPFeatures.fp_contract = FPPragmaOptions[0];
}
C++ modules: don't lose track of a 'namespace std' that is imported from a module. llvm-svn: 192951
2013-10-18 14:54:39 +08:00
// FIXME: What happens if these are changed by a module import?
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
if (!OpenCLExtensions.empty()) {
unsigned I = 0;
#define OPENCLEXT(nm) SemaObj->OpenCLFeatures.nm = OpenCLExtensions[I++];
#include "clang/Basic/OpenCLExtensions.def"
assert(OpenCLExtensions.size() == I && "Wrong number of OPENCL_EXTENSIONS");
}
C++ modules: don't lose track of a 'namespace std' that is imported from a module. llvm-svn: 192951
2013-10-18 14:54:39 +08:00
UpdateSema();
}
void ASTReader::UpdateSema() {
assert(SemaObj && "no Sema to update");
// Load the offsets of the declarations that Sema references.
// They will be lazily deserialized when needed.
if (!SemaDeclRefs.empty()) {
assert(SemaDeclRefs.size() % 2 == 0);
for (unsigned I = 0; I != SemaDeclRefs.size(); I += 2) {
if (!SemaObj->StdNamespace)
SemaObj->StdNamespace = SemaDeclRefs[I];
if (!SemaObj->StdBadAlloc)
SemaObj->StdBadAlloc = SemaDeclRefs[I+1];
}
SemaDeclRefs.clear();
}
Implemented support for "pragma clang optimize on/off", based on attribute 'optnone'. This patch implements support for selectively disabling optimizations on a range of function definitions through a pragma. The implementation is that all function definitions in the range are decorated with attribute 'optnone'. #pragma clang optimize off // All function definitions in here are decorated with 'optnone'. #pragma clang optimize on // Compilation resumes as normal. llvm-svn: 209510
2014-05-23 20:13:25 +08:00
// Update the state of 'pragma clang optimize'. Use the same API as if we had
// encountered the pragma in the source.
if(OptimizeOffPragmaLocation.isValid())
SemaObj->ActOnPragmaOptimize(/* IsOn = */ false, OptimizeOffPragmaLocation);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
Remove redundant bouncing between StringRef and a pair of 'const char *'. llvm-svn: 242562
2015-07-18 03:51:03 +08:00
IdentifierInfo *ASTReader::get(StringRef Name) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
// Note that we are loading an identifier.
Deserializing AnIdentifier(this);
Implement the reader of the global module index and wire it into the AST reader. The global module index tracks all of the identifiers known to a set of module files. Lookup of those identifiers looks first in the global module index, which returns the set of module files in which that identifier can be found. The AST reader only needs to look into those module files and any module files not known to the global index (e.g., because they were (re)built after the global index), reducing the number of on-disk hash tables to visit. For an example source I'm looking at, we go from 237844 total identifier lookups into on-disk hash tables down to 126817. Unfortunately, this does not translate into a performance advantage. At best, it's a wash once the global module index has been built, but that's ignore the cost of building the global module index (which is itself fairly large). Profiles show that the global module index code is far less efficient than it should be; optimizing it might give enough of an advantage to justify its continued inclusion. llvm-svn: 173405
2013-01-25 09:03:03 +08:00
Improve coordination between the module manager and the global module index, optimizing the operation that skips lookup in modules where we know the identifier will not be found. This makes the global module index optimization actually useful, providing an 8.5% speedup over modules without the global module index for -fsyntax-only. llvm-svn: 173529
2013-01-26 07:32:03 +08:00
IdentifierLookupVisitor Visitor(Name, /*PriorGeneration=*/0,
Track the number of lookups and hits into the on-disk hash tables for identifiers within the AST file reader. llvm-svn: 173403
2013-01-25 08:38:33 +08:00
NumIdentifierLookups,
NumIdentifierLookupHits);
[modules] Stop performing PCM lookups for all identifiers when building with C++ modules. Instead, serialize a list of interesting identifiers and mark those ones out of date on module import. Avoiding the identifier lookups here gives a 20-30% speedup in builds with large numbers of modules. No functionality change intended. llvm-svn: 242868
2015-07-22 10:08:40 +08:00
// We don't need to do identifier table lookups in C++ modules (we preload
// all interesting declarations, and don't need to use the scope for name
// lookups). Perform the lookup in PCH files, though, since we don't build
// a complete initial identifier table if we're carrying on from a PCH.
if (Context.getLangOpts().CPlusPlus) {
for (auto F : ModuleMgr.pch_modules())
[Modules] Wrap the main ModuleManager visitor in a function_ref. Avoids the awkward passing of an opaque void *UserData argument. No functional change intended. llvm-svn: 243213
2015-07-25 20:14:04 +08:00
if (Visitor(*F))
[modules] Stop performing PCM lookups for all identifiers when building with C++ modules. Instead, serialize a list of interesting identifiers and mark those ones out of date on module import. Avoiding the identifier lookups here gives a 20-30% speedup in builds with large numbers of modules. No functionality change intended. llvm-svn: 242868
2015-07-22 10:08:40 +08:00
break;
} else {
// If there is a global index, look there first to determine which modules
// provably do not have any results for this identifier.
GlobalModuleIndex::HitSet Hits;
GlobalModuleIndex::HitSet *HitsPtr = nullptr;
if (!loadGlobalIndex()) {
if (GlobalIndex->lookupIdentifier(Name, Hits)) {
HitsPtr = &Hits;
}
}
[Modules] Wrap the main ModuleManager visitor in a function_ref. Avoids the awkward passing of an opaque void *UserData argument. No functional change intended. llvm-svn: 243213
2015-07-25 20:14:04 +08:00
ModuleMgr.visit(Visitor, HitsPtr);
[modules] Stop performing PCM lookups for all identifiers when building with C++ modules. Instead, serialize a list of interesting identifiers and mark those ones out of date on module import. Avoiding the identifier lookups here gives a 20-30% speedup in builds with large numbers of modules. No functionality change intended. llvm-svn: 242868
2015-07-22 10:08:40 +08:00
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
IdentifierInfo *II = Visitor.getIdentifierInfo();
markIdentifierUpToDate(II);
return II;
}
namespace clang {
/// \brief An identifier-lookup iterator that enumerates all of the
/// identifiers stored within a set of AST files.
class ASTIdentifierIterator : public IdentifierIterator {
/// \brief The AST reader whose identifiers are being enumerated.
const ASTReader &Reader;
/// \brief The current index into the chain of AST files stored in
/// the AST reader.
unsigned Index;
/// \brief The current position within the identifier lookup table
/// of the current AST file.
ASTIdentifierLookupTable::key_iterator Current;
/// \brief The end position within the identifier lookup table of
/// the current AST file.
ASTIdentifierLookupTable::key_iterator End;
public:
explicit ASTIdentifierIterator(const ASTReader &Reader);
[C++11] Add 'override' keyword to virtual methods that override their base class. llvm-svn: 203746
2014-03-13 10:13:41 +08:00
StringRef Next() override;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
};
Revert r240270 ("Fixed/added namespace ending comments using clang-tidy"). llvm-svn: 240353
2015-06-23 07:07:51 +08:00
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
ASTIdentifierIterator::ASTIdentifierIterator(const ASTReader &Reader)
: Reader(Reader), Index(Reader.ModuleMgr.size() - 1) {
ASTIdentifierLookupTable *IdTable
= (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index].IdentifierLookupTable;
Current = IdTable->key_begin();
End = IdTable->key_end();
}
StringRef ASTIdentifierIterator::Next() {
while (Current == End) {
// If we have exhausted all of our AST files, we're done.
if (Index == 0)
return StringRef();
--Index;
ASTIdentifierLookupTable *IdTable
= (ASTIdentifierLookupTable *)Reader.ModuleMgr[Index].
IdentifierLookupTable;
Current = IdTable->key_begin();
End = IdTable->key_end();
}
// We have any identifiers remaining in the current AST file; return
// the next one.
Factor the trait for lookup into the on-based hash table of identifiers into two parts: the part that involves dealing with the key (which can be re-used) and the ASTReader-specific part that creates the IdentifierInfos. While I'm at it, StringRef'ify this code, which was using pair<const char*, unsigned>. No functionality change. llvm-svn: 173283
2013-01-24 02:53:14 +08:00
StringRef Result = *Current;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
++Current;
Factor the trait for lookup into the on-based hash table of identifiers into two parts: the part that involves dealing with the key (which can be re-used) and the ASTReader-specific part that creates the IdentifierInfos. While I'm at it, StringRef'ify this code, which was using pair<const char*, unsigned>. No functionality change. llvm-svn: 173283
2013-01-24 02:53:14 +08:00
return Result;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
[Modules] Use global index to improve typo correction performance Typo correction for an unqualified name needs to walk through all of the identifier tables of all modules. When we have a global index, just walk its identifier table only. rdar://13425732 llvm-svn: 179730
2013-04-18 06:10:55 +08:00
IdentifierIterator *ASTReader::getIdentifiers() {
if (!loadGlobalIndex())
return GlobalIndex->createIdentifierIterator();
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
return new ASTIdentifierIterator(*this);
}
namespace clang { namespace serialization {
class ReadMethodPoolVisitor {
ASTReader &Reader;
Selector Sel;
unsigned PriorGeneration;
Enhance the ObjC global method pool to record whether there were 0, 1, or >= 2 methods (with a particular selector) inside categories. This is done by extending ObjCMethodList (which is only used by the global method pool) to have 2 extra bits of information. We will later take advantage of this info in global method pool for the overridden methods calculation. llvm-svn: 179652
2013-04-17 08:08:58 +08:00
unsigned InstanceBits;
unsigned FactoryBits;
Objective-C: Serialize "more than one decl" state of ObjCMethodList. This fixes PR21587, what r221933 fixed for regular programs is now also fixed for decls coming from PCH files. Use another bit from the count/bits uint16_t for storing the "more than one decl" bit. This reduces the number of bits for the count from 14 to 13. The selector with the most overloads in Cocoa.h has ~55 overloads, so 13 bits should still be plenty. Since this changes the meaning of a serialized bit pattern, also increase clang::serialization::VERSION_MAJOR. Storing the "more than one decl" state of only the first overload isn't quite correct, but Sema::AreMultipleMethodsInGlobalPool() currently only looks at the state of the first overload so it's good enough for now. llvm-svn: 224892
2014-12-28 06:14:15 +08:00
bool InstanceHasMoreThanOneDecl;
bool FactoryHasMoreThanOneDecl;
Remove useless 'llvm::' qualifier from names like StringRef and others that are brought into 'clang' namespace by clang/Basic/LLVM.h llvm-svn: 172323
2013-01-13 03:30:44 +08:00
SmallVector<ObjCMethodDecl *, 4> InstanceMethods;
SmallVector<ObjCMethodDecl *, 4> FactoryMethods;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
public:
Address review feedback on r221933. Remove ObjCMethodList::Count, instead store a "has more than one decl" bit in the low bit of the ObjCMethodDecl pointer, using a PointerIntPair. Most of this patch is replacing ".Method" with ".getMethod()". No intended behavior change. llvm-svn: 224876
2014-12-27 11:58:08 +08:00
ReadMethodPoolVisitor(ASTReader &Reader, Selector Sel,
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
unsigned PriorGeneration)
Address review feedback on r221933. Remove ObjCMethodList::Count, instead store a "has more than one decl" bit in the low bit of the ObjCMethodDecl pointer, using a PointerIntPair. Most of this patch is replacing ".Method" with ".getMethod()". No intended behavior change. llvm-svn: 224876
2014-12-27 11:58:08 +08:00
: Reader(Reader), Sel(Sel), PriorGeneration(PriorGeneration),
Objective-C: Serialize "more than one decl" state of ObjCMethodList. This fixes PR21587, what r221933 fixed for regular programs is now also fixed for decls coming from PCH files. Use another bit from the count/bits uint16_t for storing the "more than one decl" bit. This reduces the number of bits for the count from 14 to 13. The selector with the most overloads in Cocoa.h has ~55 overloads, so 13 bits should still be plenty. Since this changes the meaning of a serialized bit pattern, also increase clang::serialization::VERSION_MAJOR. Storing the "more than one decl" state of only the first overload isn't quite correct, but Sema::AreMultipleMethodsInGlobalPool() currently only looks at the state of the first overload so it's good enough for now. llvm-svn: 224892
2014-12-28 06:14:15 +08:00
InstanceBits(0), FactoryBits(0), InstanceHasMoreThanOneDecl(false),
FactoryHasMoreThanOneDecl(false) {}
Address review feedback on r221933. Remove ObjCMethodList::Count, instead store a "has more than one decl" bit in the low bit of the ObjCMethodDecl pointer, using a PointerIntPair. Most of this patch is replacing ".Method" with ".getMethod()". No intended behavior change. llvm-svn: 224876
2014-12-27 11:58:08 +08:00
[Modules] Wrap the main ModuleManager visitor in a function_ref. Avoids the awkward passing of an opaque void *UserData argument. No functional change intended. llvm-svn: 243213
2015-07-25 20:14:04 +08:00
bool operator()(ModuleFile &M) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
if (!M.SelectorLookupTable)
return false;
// If we've already searched this module file, skip it now.
Remove some noise "this->"s left behind by r243213. llvm-svn: 243614
2015-07-30 11:37:16 +08:00
if (M.Generation <= PriorGeneration)
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
return true;
Remove some noise "this->"s left behind by r243213. llvm-svn: 243614
2015-07-30 11:37:16 +08:00
++Reader.NumMethodPoolTableLookups;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
ASTSelectorLookupTable *PoolTable
= (ASTSelectorLookupTable*)M.SelectorLookupTable;
Remove some noise "this->"s left behind by r243213. llvm-svn: 243614
2015-07-30 11:37:16 +08:00
ASTSelectorLookupTable::iterator Pos = PoolTable->find(Sel);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
if (Pos == PoolTable->end())
return false;
Add some more ASTReader statistics for global method pool lookups. llvm-svn: 173702
2013-01-29 01:54:36 +08:00
Remove some noise "this->"s left behind by r243213. llvm-svn: 243614
2015-07-30 11:37:16 +08:00
++Reader.NumMethodPoolTableHits;
++Reader.NumSelectorsRead;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
// FIXME: Not quite happy with the statistics here. We probably should
// disable this tracking when called via LoadSelector.
// Also, should entries without methods count as misses?
Remove some noise "this->"s left behind by r243213. llvm-svn: 243614
2015-07-30 11:37:16 +08:00
++Reader.NumMethodPoolEntriesRead;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
ASTSelectorLookupTrait::data_type Data = *Pos;
Remove some noise "this->"s left behind by r243213. llvm-svn: 243614
2015-07-30 11:37:16 +08:00
if (Reader.DeserializationListener)
Reader.DeserializationListener->SelectorRead(Data.ID, Sel);
InstanceMethods.append(Data.Instance.begin(), Data.Instance.end());
FactoryMethods.append(Data.Factory.begin(), Data.Factory.end());
InstanceBits = Data.InstanceBits;
FactoryBits = Data.FactoryBits;
InstanceHasMoreThanOneDecl = Data.InstanceHasMoreThanOneDecl;
FactoryHasMoreThanOneDecl = Data.FactoryHasMoreThanOneDecl;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
return true;
}
/// \brief Retrieve the instance methods found by this visitor.
ArrayRef<ObjCMethodDecl *> getInstanceMethods() const {
return InstanceMethods;
}
/// \brief Retrieve the instance methods found by this visitor.
ArrayRef<ObjCMethodDecl *> getFactoryMethods() const {
return FactoryMethods;
}
Enhance the ObjC global method pool to record whether there were 0, 1, or >= 2 methods (with a particular selector) inside categories. This is done by extending ObjCMethodList (which is only used by the global method pool) to have 2 extra bits of information. We will later take advantage of this info in global method pool for the overridden methods calculation. llvm-svn: 179652
2013-04-17 08:08:58 +08:00
unsigned getInstanceBits() const { return InstanceBits; }
unsigned getFactoryBits() const { return FactoryBits; }
Objective-C: Serialize "more than one decl" state of ObjCMethodList. This fixes PR21587, what r221933 fixed for regular programs is now also fixed for decls coming from PCH files. Use another bit from the count/bits uint16_t for storing the "more than one decl" bit. This reduces the number of bits for the count from 14 to 13. The selector with the most overloads in Cocoa.h has ~55 overloads, so 13 bits should still be plenty. Since this changes the meaning of a serialized bit pattern, also increase clang::serialization::VERSION_MAJOR. Storing the "more than one decl" state of only the first overload isn't quite correct, but Sema::AreMultipleMethodsInGlobalPool() currently only looks at the state of the first overload so it's good enough for now. llvm-svn: 224892
2014-12-28 06:14:15 +08:00
bool instanceHasMoreThanOneDecl() const {
return InstanceHasMoreThanOneDecl;
}
bool factoryHasMoreThanOneDecl() const { return FactoryHasMoreThanOneDecl; }
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
};
Revert r240270 ("Fixed/added namespace ending comments using clang-tidy"). llvm-svn: 240353
2015-06-23 07:07:51 +08:00
} } // end namespace clang::serialization
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
/// \brief Add the given set of methods to the method list.
static void addMethodsToPool(Sema &S, ArrayRef<ObjCMethodDecl *> Methods,
ObjCMethodList &List) {
for (unsigned I = 0, N = Methods.size(); I != N; ++I) {
S.addMethodToGlobalList(&List, Methods[I]);
}
}
void ASTReader::ReadMethodPool(Selector Sel) {
// Get the selector generation and update it to the current generation.
unsigned &Generation = SelectorGeneration[Sel];
unsigned PriorGeneration = Generation;
If a declaration is loaded, and then a module import adds a redeclaration, then ensure that querying the first declaration for its most recent declaration checks for redeclarations from the imported module. This works as follows: * The 'most recent' pointer on a canonical declaration grows a pointer to the external AST source and a generation number (space- and time-optimized for the case where there is no external source). * Each time the 'most recent' pointer is queried, if it has an external source, we check whether it's up to date, and update it if not. * The ancillary data stored on the canonical declaration is allocated lazily to avoid filling it in for declarations that end up being non-canonical. We'll still perform a redundant (ASTContext) allocation if someone asks for the most recent declaration from a decl before setPreviousDecl is called, but such cases are probably all bugs, and are now easy to find. Some finessing is still in order here -- in particular, we use a very general mechanism for handling the DefinitionData pointer on CXXRecordData, and a more targeted approach would be more compact. Also, the MayHaveOutOfDateDef mechanism should now be expunged, since it was addressing only a corner of the full problem space here. That's not covered by this patch. Early performance benchmarks show that this makes no measurable difference to Clang performance without modules enabled (and fixes a major correctness issue with modules enabled). I'll revert if a full performance comparison shows any problems. llvm-svn: 209046
2014-05-17 07:01:30 +08:00
Generation = getGeneration();
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
// Search for methods defined with this selector.
Add some more ASTReader statistics for global method pool lookups. llvm-svn: 173702
2013-01-29 01:54:36 +08:00
++NumMethodPoolLookups;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
ReadMethodPoolVisitor Visitor(*this, Sel, PriorGeneration);
[Modules] Wrap the main ModuleManager visitor in a function_ref. Avoids the awkward passing of an opaque void *UserData argument. No functional change intended. llvm-svn: 243213
2015-07-25 20:14:04 +08:00
ModuleMgr.visit(Visitor);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
if (Visitor.getInstanceMethods().empty() &&
Add some more ASTReader statistics for global method pool lookups. llvm-svn: 173702
2013-01-29 01:54:36 +08:00
Visitor.getFactoryMethods().empty())
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
return;
Add some more ASTReader statistics for global method pool lookups. llvm-svn: 173702
2013-01-29 01:54:36 +08:00
++NumMethodPoolHits;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
if (!getSema())
return;
Sema &S = *getSema();
Sema::GlobalMethodPool::iterator Pos
= S.MethodPool.insert(std::make_pair(Sel, Sema::GlobalMethods())).first;
Fix bogus 'method is unavailable' errors with modules This just tweaks the fix from r224892 (which handled PCHs) to work with modules, where we will serialize each method individually and hence the hasMoreThanOneDecl bit needs to be updated as we add the methods. llvm-svn: 225659
2015-01-13 03:27:00 +08:00
Enhance the ObjC global method pool to record whether there were 0, 1, or >= 2 methods (with a particular selector) inside categories. This is done by extending ObjCMethodList (which is only used by the global method pool) to have 2 extra bits of information. We will later take advantage of this info in global method pool for the overridden methods calculation. llvm-svn: 179652
2013-04-17 08:08:58 +08:00
Pos->second.first.setBits(Visitor.getInstanceBits());
Objective-C: Serialize "more than one decl" state of ObjCMethodList. This fixes PR21587, what r221933 fixed for regular programs is now also fixed for decls coming from PCH files. Use another bit from the count/bits uint16_t for storing the "more than one decl" bit. This reduces the number of bits for the count from 14 to 13. The selector with the most overloads in Cocoa.h has ~55 overloads, so 13 bits should still be plenty. Since this changes the meaning of a serialized bit pattern, also increase clang::serialization::VERSION_MAJOR. Storing the "more than one decl" state of only the first overload isn't quite correct, but Sema::AreMultipleMethodsInGlobalPool() currently only looks at the state of the first overload so it's good enough for now. llvm-svn: 224892
2014-12-28 06:14:15 +08:00
Pos->second.first.setHasMoreThanOneDecl(Visitor.instanceHasMoreThanOneDecl());
Enhance the ObjC global method pool to record whether there were 0, 1, or >= 2 methods (with a particular selector) inside categories. This is done by extending ObjCMethodList (which is only used by the global method pool) to have 2 extra bits of information. We will later take advantage of this info in global method pool for the overridden methods calculation. llvm-svn: 179652
2013-04-17 08:08:58 +08:00
Pos->second.second.setBits(Visitor.getFactoryBits());
Objective-C: Serialize "more than one decl" state of ObjCMethodList. This fixes PR21587, what r221933 fixed for regular programs is now also fixed for decls coming from PCH files. Use another bit from the count/bits uint16_t for storing the "more than one decl" bit. This reduces the number of bits for the count from 14 to 13. The selector with the most overloads in Cocoa.h has ~55 overloads, so 13 bits should still be plenty. Since this changes the meaning of a serialized bit pattern, also increase clang::serialization::VERSION_MAJOR. Storing the "more than one decl" state of only the first overload isn't quite correct, but Sema::AreMultipleMethodsInGlobalPool() currently only looks at the state of the first overload so it's good enough for now. llvm-svn: 224892
2014-12-28 06:14:15 +08:00
Pos->second.second.setHasMoreThanOneDecl(Visitor.factoryHasMoreThanOneDecl());
Fix bogus 'method is unavailable' errors with modules This just tweaks the fix from r224892 (which handled PCHs) to work with modules, where we will serialize each method individually and hence the hasMoreThanOneDecl bit needs to be updated as we add the methods. llvm-svn: 225659
2015-01-13 03:27:00 +08:00
// Add methods to the global pool *after* setting hasMoreThanOneDecl, since
// when building a module we keep every method individually and may need to
// update hasMoreThanOneDecl as we add the methods.
addMethodsToPool(S, Visitor.getInstanceMethods(), Pos->second.first);
addMethodsToPool(S, Visitor.getFactoryMethods(), Pos->second.second);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
void ASTReader::ReadKnownNamespaces(
SmallVectorImpl<NamespaceDecl *> &Namespaces) {
Namespaces.clear();
for (unsigned I = 0, N = KnownNamespaces.size(); I != N; ++I) {
if (NamespaceDecl *Namespace
= dyn_cast_or_null<NamespaceDecl>(GetDecl(KnownNamespaces[I])))
Namespaces.push_back(Namespace);
}
}
Add a new -Wundefined-inline warning for inline functions which are used but not defined. Fixes PR14993! llvm-svn: 174158
2013-02-01 16:13:20 +08:00
void ASTReader::ReadUndefinedButUsed(
Remove elements from Sema.UndefinedInternals as functions are defined. Also filter the elements before emitting them into a PCH. No user-visible functionality change, except that PCH files may be smaller? llvm-svn: 174034
2013-01-31 11:23:57 +08:00
llvm::DenseMap<NamedDecl*, SourceLocation> &Undefined) {
Add a new -Wundefined-inline warning for inline functions which are used but not defined. Fixes PR14993! llvm-svn: 174158
2013-02-01 16:13:20 +08:00
for (unsigned Idx = 0, N = UndefinedButUsed.size(); Idx != N;) {
NamedDecl *D = cast<NamedDecl>(GetDecl(UndefinedButUsed[Idx++]));
Preserve Sema::UndefinedInternals across PCH boundaries. Fixes -Wundefined-internal warnings with PCH. llvm-svn: 173538
2013-01-26 08:35:08 +08:00
SourceLocation Loc =
Add a new -Wundefined-inline warning for inline functions which are used but not defined. Fixes PR14993! llvm-svn: 174158
2013-02-01 16:13:20 +08:00
SourceLocation::getFromRawEncoding(UndefinedButUsed[Idx++]);
Preserve Sema::UndefinedInternals across PCH boundaries. Fixes -Wundefined-internal warnings with PCH. llvm-svn: 173538
2013-01-26 08:35:08 +08:00
Undefined.insert(std::make_pair(D, Loc));
}
}
Detect uses of mismatching forms of 'new' and 'delete' Emit warning when operand to `delete` is allocated with `new[]` or operand to `delete[]` is allocated with `new`. rev 2 update: `getNewExprFromInitListOrExpr` should return `dyn_cast_or_null` instead of `dyn_cast`, since `E` might be null. Reviewers: rtrieu, jordan_rose, rsmith Subscribers: majnemer, cfe-commits Differential Revision: http://reviews.llvm.org/D4661 llvm-svn: 237608
2015-05-19 03:59:11 +08:00
void ASTReader::ReadMismatchingDeleteExpressions(llvm::MapVector<
FieldDecl *, llvm::SmallVector<std::pair<SourceLocation, bool>, 4>> &
Exprs) {
for (unsigned Idx = 0, N = DelayedDeleteExprs.size(); Idx != N;) {
FieldDecl *FD = cast<FieldDecl>(GetDecl(DelayedDeleteExprs[Idx++]));
uint64_t Count = DelayedDeleteExprs[Idx++];
for (uint64_t C = 0; C < Count; ++C) {
SourceLocation DeleteLoc =
SourceLocation::getFromRawEncoding(DelayedDeleteExprs[Idx++]);
const bool IsArrayForm = DelayedDeleteExprs[Idx++];
Exprs[FD].push_back(std::make_pair(DeleteLoc, IsArrayForm));
}
}
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
void ASTReader::ReadTentativeDefinitions(
SmallVectorImpl<VarDecl *> &TentativeDefs) {
for (unsigned I = 0, N = TentativeDefinitions.size(); I != N; ++I) {
VarDecl *Var = dyn_cast_or_null<VarDecl>(GetDecl(TentativeDefinitions[I]));
if (Var)
TentativeDefs.push_back(Var);
}
TentativeDefinitions.clear();
}
void ASTReader::ReadUnusedFileScopedDecls(
SmallVectorImpl<const DeclaratorDecl *> &Decls) {
for (unsigned I = 0, N = UnusedFileScopedDecls.size(); I != N; ++I) {
DeclaratorDecl *D
= dyn_cast_or_null<DeclaratorDecl>(GetDecl(UnusedFileScopedDecls[I]));
if (D)
Decls.push_back(D);
}
UnusedFileScopedDecls.clear();
}
void ASTReader::ReadDelegatingConstructors(
SmallVectorImpl<CXXConstructorDecl *> &Decls) {
for (unsigned I = 0, N = DelegatingCtorDecls.size(); I != N; ++I) {
CXXConstructorDecl *D
= dyn_cast_or_null<CXXConstructorDecl>(GetDecl(DelegatingCtorDecls[I]));
if (D)
Decls.push_back(D);
}
DelegatingCtorDecls.clear();
}
void ASTReader::ReadExtVectorDecls(SmallVectorImpl<TypedefNameDecl *> &Decls) {
for (unsigned I = 0, N = ExtVectorDecls.size(); I != N; ++I) {
TypedefNameDecl *D
= dyn_cast_or_null<TypedefNameDecl>(GetDecl(ExtVectorDecls[I]));
if (D)
Decls.push_back(D);
}
ExtVectorDecls.clear();
}
Add -Wunused-local-typedef, a warning that finds unused local typedefs. The warning warns on TypedefNameDecls -- typedefs and C++11 using aliases -- that are !isReferenced(). Since the isReferenced() bit on TypedefNameDecls wasn't used for anything before this warning it wasn't always set correctly, so this patch also adds a few missing MarkAnyDeclReferenced() calls in various places for TypedefNameDecls. This is made a bit complicated due to local typedefs possibly being used only after their local scope has closed. Consider: template <class T> void template_fun(T t) { typename T::Foo s3foo; // YYY (void)s3foo; } void template_fun_user() { struct Local { typedef int Foo; // XXX } p; template_fun(p); } Here the typedef in XXX is only used at end-of-translation unit, when YYY in template_fun() gets instantiated. To handle this, typedefs that are unused when their scope exits are added to a set of potentially unused typedefs, and that set gets checked at end-of-TU. Typedefs that are still unused at that point then get warned on. There's also serialization code for this set, so that the warning works with precompiled headers and modules. For modules, the warning is emitted when the module is built, for precompiled headers each time the header gets used. Finally, consider a function using C++14 auto return types to return a local type defined in a header: auto f() { struct S { typedef int a; }; return S(); } Here, the typedef escapes its local scope and could be used by only some translation units including the header. To not warn on this, add a RecursiveASTVisitor that marks all delcs on local types returned from auto functions as referenced. (Except if it's a function with internal linkage, or the decls are private and the local type has no friends -- in these cases, it _is_ safe to warn.) Several of the included testcases (most of the interesting ones) were provided by Richard Smith. (gcc's spelling -Wunused-local-typedefs is supported as an alias for this warning.) llvm-svn: 217298
2014-09-06 09:25:55 +08:00
void ASTReader::ReadUnusedLocalTypedefNameCandidates(
llvm::SmallSetVector<const TypedefNameDecl *, 4> &Decls) {
for (unsigned I = 0, N = UnusedLocalTypedefNameCandidates.size(); I != N;
++I) {
TypedefNameDecl *D = dyn_cast_or_null<TypedefNameDecl>(
GetDecl(UnusedLocalTypedefNameCandidates[I]));
if (D)
Decls.insert(D);
}
UnusedLocalTypedefNameCandidates.clear();
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
void ASTReader::ReadReferencedSelectors(
SmallVectorImpl<std::pair<Selector, SourceLocation> > &Sels) {
if (ReferencedSelectorsData.empty())
return;
// If there are @selector references added them to its pool. This is for
// implementation of -Wselector.
unsigned int DataSize = ReferencedSelectorsData.size()-1;
unsigned I = 0;
while (I < DataSize) {
Selector Sel = DecodeSelector(ReferencedSelectorsData[I++]);
SourceLocation SelLoc
= SourceLocation::getFromRawEncoding(ReferencedSelectorsData[I++]);
Sels.push_back(std::make_pair(Sel, SelLoc));
}
ReferencedSelectorsData.clear();
}
void ASTReader::ReadWeakUndeclaredIdentifiers(
SmallVectorImpl<std::pair<IdentifierInfo *, WeakInfo> > &WeakIDs) {
if (WeakUndeclaredIdentifiers.empty())
return;
for (unsigned I = 0, N = WeakUndeclaredIdentifiers.size(); I < N; /*none*/) {
IdentifierInfo *WeakId
= DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
IdentifierInfo *AliasId
= DecodeIdentifierInfo(WeakUndeclaredIdentifiers[I++]);
SourceLocation Loc
= SourceLocation::getFromRawEncoding(WeakUndeclaredIdentifiers[I++]);
bool Used = WeakUndeclaredIdentifiers[I++];
WeakInfo WI(AliasId, Loc);
WI.setUsed(Used);
WeakIDs.push_back(std::make_pair(WeakId, WI));
}
WeakUndeclaredIdentifiers.clear();
}
void ASTReader::ReadUsedVTables(SmallVectorImpl<ExternalVTableUse> &VTables) {
for (unsigned Idx = 0, N = VTableUses.size(); Idx < N; /* In loop */) {
ExternalVTableUse VT;
VT.Record = dyn_cast_or_null<CXXRecordDecl>(GetDecl(VTableUses[Idx++]));
VT.Location = SourceLocation::getFromRawEncoding(VTableUses[Idx++]);
VT.DefinitionRequired = VTableUses[Idx++];
VTables.push_back(VT);
}
VTableUses.clear();
}
void ASTReader::ReadPendingInstantiations(
SmallVectorImpl<std::pair<ValueDecl *, SourceLocation> > &Pending) {
for (unsigned Idx = 0, N = PendingInstantiations.size(); Idx < N;) {
ValueDecl *D = cast<ValueDecl>(GetDecl(PendingInstantiations[Idx++]));
SourceLocation Loc
= SourceLocation::getFromRawEncoding(PendingInstantiations[Idx++]);
Pending.push_back(std::make_pair(D, Loc));
}
PendingInstantiations.clear();
}
PR9992: Serialize and deserialize the token sequence for a function template in -fdelayed-template-parsing mode. Patch by Will Wilson! llvm-svn: 187916
2013-08-08 05:41:30 +08:00
void ASTReader::ReadLateParsedTemplates(
[Modules] Preserve source order for the map of late parsed templates. Clang was inserting these into a dense map. While it never iterated the dense map during normal compilation, it did when emitting a module. Fix this by using a standard MapVector to preserve the order in which we encounter the late parsed templates. I suspect this still isn't ideal, as we don't seem to remove things from this map even when we mark the templates as no longer late parsed. But I don't know enough about this particular extension to craft a nice, subtle test case covering this. I've managed to get the stress test to at least do some late parsing and demonstrate the core problem here. This patch fixes the test and provides deterministic behavior which is a strict improvement over the prior state. I've cleaned up some of the code here as well to be explicit about inserting when that is what is actually going on. llvm-svn: 233264
2015-03-26 17:08:15 +08:00
llvm::MapVector<const FunctionDecl *, LateParsedTemplate *> &LPTMap) {
PR9992: Serialize and deserialize the token sequence for a function template in -fdelayed-template-parsing mode. Patch by Will Wilson! llvm-svn: 187916
2013-08-08 05:41:30 +08:00
for (unsigned Idx = 0, N = LateParsedTemplates.size(); Idx < N;
/* In loop */) {
FunctionDecl *FD = cast<FunctionDecl>(GetDecl(LateParsedTemplates[Idx++]));
LateParsedTemplate *LT = new LateParsedTemplate;
LT->D = GetDecl(LateParsedTemplates[Idx++]);
ModuleFile *F = getOwningModuleFile(LT->D);
assert(F && "No module");
unsigned TokN = LateParsedTemplates[Idx++];
LT->Toks.reserve(TokN);
for (unsigned T = 0; T < TokN; ++T)
LT->Toks.push_back(ReadToken(*F, LateParsedTemplates, Idx));
[Modules] Preserve source order for the map of late parsed templates. Clang was inserting these into a dense map. While it never iterated the dense map during normal compilation, it did when emitting a module. Fix this by using a standard MapVector to preserve the order in which we encounter the late parsed templates. I suspect this still isn't ideal, as we don't seem to remove things from this map even when we mark the templates as no longer late parsed. But I don't know enough about this particular extension to craft a nice, subtle test case covering this. I've managed to get the stress test to at least do some late parsing and demonstrate the core problem here. This patch fixes the test and provides deterministic behavior which is a strict improvement over the prior state. I've cleaned up some of the code here as well to be explicit about inserting when that is what is actually going on. llvm-svn: 233264
2015-03-26 17:08:15 +08:00
LPTMap.insert(std::make_pair(FD, LT));
PR9992: Serialize and deserialize the token sequence for a function template in -fdelayed-template-parsing mode. Patch by Will Wilson! llvm-svn: 187916
2013-08-08 05:41:30 +08:00
}
LateParsedTemplates.clear();
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
void ASTReader::LoadSelector(Selector Sel) {
// It would be complicated to avoid reading the methods anyway. So don't.
ReadMethodPool(Sel);
}
void ASTReader::SetIdentifierInfo(IdentifierID ID, IdentifierInfo *II) {
assert(ID && "Non-zero identifier ID required");
assert(ID <= IdentifiersLoaded.size() && "identifier ID out of range");
IdentifiersLoaded[ID - 1] = II;
if (DeserializationListener)
DeserializationListener->IdentifierRead(ID, II);
}
/// \brief Set the globally-visible declarations associated with the given
/// identifier.
///
/// If the AST reader is currently in a state where the given declaration IDs
/// cannot safely be resolved, they are queued until it is safe to resolve
/// 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.
///
Ensure that the identifier chains have the most recent declaration after module deserialization. This commit introduces a set of related changes to ensure that the declaration that shows up in the identifier chain after deserializing declarations with a given identifier is, in fact, the most recent declaration. The primary change involves waiting until after we deserialize and wire up redeclaration chains before updating the identifier chains. There is a minor optimization in here to avoid recursively deserializing names as part of looking to see whether top-level declarations for a given name exist. A related change that became suddenly more urgent is to property record a merged declaration when an entity first declared in the current translation unit is later deserialized from a module (that had not been loaded at the time of the original declaration). Since we key off the canonical declaration (which is parsed, not from an AST file) for emitted redeclarations, we simply record this as a merged declaration during AST writing and let the readers merge them. Re-fixes <rdar://problem/13189985>, presumably for good this time. llvm-svn: 175447
2013-02-18 23:53:43 +08:00
/// \param Decls if non-null, this vector will be populated with the set of
/// deserialized declarations. These declarations will not be pushed into
/// scope.
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
void
ASTReader::SetGloballyVisibleDecls(IdentifierInfo *II,
const SmallVectorImpl<uint32_t> &DeclIDs,
Ensure that the identifier chains have the most recent declaration after module deserialization. This commit introduces a set of related changes to ensure that the declaration that shows up in the identifier chain after deserializing declarations with a given identifier is, in fact, the most recent declaration. The primary change involves waiting until after we deserialize and wire up redeclaration chains before updating the identifier chains. There is a minor optimization in here to avoid recursively deserializing names as part of looking to see whether top-level declarations for a given name exist. A related change that became suddenly more urgent is to property record a merged declaration when an entity first declared in the current translation unit is later deserialized from a module (that had not been loaded at the time of the original declaration). Since we key off the canonical declaration (which is parsed, not from an AST file) for emitted redeclarations, we simply record this as a merged declaration during AST writing and let the readers merge them. Re-fixes <rdar://problem/13189985>, presumably for good this time. llvm-svn: 175447
2013-02-18 23:53:43 +08:00
SmallVectorImpl<Decl *> *Decls) {
if (NumCurrentElementsDeserializing && !Decls) {
PendingIdentifierInfos[II].append(DeclIDs.begin(), DeclIDs.end());
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
return;
}
for (unsigned I = 0, N = DeclIDs.size(); I != N; ++I) {
Avoid a couple of assertions when preprocessing with modules 1. We were hitting the NextIsPrevious assertion because we were trying to merge decl chains that were independent of each other because we had no Sema object to allow them to find existing decls. This is fixed by delaying loading the "preloaded" decls until Sema is available. 2. We were trying to get identifier info from an annotation token, which asserts. The fix is to special-case the module annotations in the preprocessed output printer. Fixed in a single commit because when you hit 1 you almost invariably hit 2 as well. llvm-svn: 217550
2014-09-11 05:29:41 +08:00
if (!SemaObj) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
// 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.
Avoid a couple of assertions when preprocessing with modules 1. We were hitting the NextIsPrevious assertion because we were trying to merge decl chains that were independent of each other because we had no Sema object to allow them to find existing decls. This is fixed by delaying loading the "preloaded" decls until Sema is available. 2. We were trying to get identifier info from an annotation token, which asserts. The fix is to special-case the module annotations in the preprocessed output printer. Fixed in a single commit because when you hit 1 you almost invariably hit 2 as well. llvm-svn: 217550
2014-09-11 05:29:41 +08:00
PreloadedDeclIDs.push_back(DeclIDs[I]);
continue;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
Avoid a couple of assertions when preprocessing with modules 1. We were hitting the NextIsPrevious assertion because we were trying to merge decl chains that were independent of each other because we had no Sema object to allow them to find existing decls. This is fixed by delaying loading the "preloaded" decls until Sema is available. 2. We were trying to get identifier info from an annotation token, which asserts. The fix is to special-case the module annotations in the preprocessed output printer. Fixed in a single commit because when you hit 1 you almost invariably hit 2 as well. llvm-svn: 217550
2014-09-11 05:29:41 +08:00
NamedDecl *D = cast<NamedDecl>(GetDecl(DeclIDs[I]));
// If we're simply supposed to record the declarations, do so now.
if (Decls) {
Decls->push_back(D);
continue;
}
// 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.
pushExternalDeclIntoScope(D, II);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
}
Revert r173056; it breaks one of the CodeGen-with-PCH tests. llvm-svn: 173058
2013-01-22 00:52:34 +08:00
IdentifierInfo *ASTReader::DecodeIdentifierInfo(IdentifierID ID) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
if (ID == 0)
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
return nullptr;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
if (IdentifiersLoaded.empty()) {
Error("no identifier table in AST file");
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
return nullptr;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
ID -= 1;
if (!IdentifiersLoaded[ID]) {
GlobalIdentifierMapType::iterator I = GlobalIdentifierMap.find(ID + 1);
assert(I != GlobalIdentifierMap.end() && "Corrupted global identifier map");
ModuleFile *M = I->second;
unsigned Index = ID - M->BaseIdentifierID;
const char *Str = M->IdentifierTableData + M->IdentifierOffsets[Index];
// All of the strings in the AST file are preceded by a 16-bit length.
// Extract that 16-bit length to avoid having to execute strlen().
// 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'.
const unsigned char *StrLenPtr = (const unsigned char*) Str - 2;
unsigned StrLen = (((unsigned) StrLenPtr[0])
| (((unsigned) StrLenPtr[1]) << 8)) - 1;
Revert r173056; it breaks one of the CodeGen-with-PCH tests. llvm-svn: 173058
2013-01-22 00:52:34 +08:00
IdentifiersLoaded[ID]
= &PP.getIdentifierTable().get(StringRef(Str, StrLen));
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
if (DeserializationListener)
DeserializationListener->IdentifierRead(ID + 1, IdentifiersLoaded[ID]);
}
return IdentifiersLoaded[ID];
}
Revert r173056; it breaks one of the CodeGen-with-PCH tests. llvm-svn: 173058
2013-01-22 00:52:34 +08:00
IdentifierInfo *ASTReader::getLocalIdentifier(ModuleFile &M, unsigned LocalID) {
return DecodeIdentifierInfo(getGlobalIdentifierID(M, LocalID));
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
IdentifierID ASTReader::getGlobalIdentifierID(ModuleFile &M, unsigned LocalID) {
if (LocalID < NUM_PREDEF_IDENT_IDS)
return LocalID;
ContinuousRangeMap<uint32_t, int, 2>::iterator I
= M.IdentifierRemap.find(LocalID - NUM_PREDEF_IDENT_IDS);
assert(I != M.IdentifierRemap.end()
&& "Invalid index into identifier index remap");
return LocalID + I->second;
}
[PCH/Modules] De/Serialize MacroInfos separately than MacroDirectives. -Serialize the macro directives history into its own section -Get rid of the macro updates section -When de/serializing an identifier from a module, associate only one macro per submodule that defined+exported it. llvm-svn: 177761
2013-03-23 05:12:57 +08:00
MacroInfo *ASTReader::getMacro(MacroID ID) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
if (ID == 0)
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
return nullptr;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
if (MacrosLoaded.empty()) {
Error("no macro table in AST file");
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
return nullptr;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
ID -= NUM_PREDEF_MACRO_IDS;
if (!MacrosLoaded[ID]) {
GlobalMacroMapType::iterator I
= GlobalMacroMap.find(ID + NUM_PREDEF_MACRO_IDS);
assert(I != GlobalMacroMap.end() && "Corrupted global macro map");
ModuleFile *M = I->second;
unsigned Index = ID - M->BaseMacroID;
[PCH/Modules] De/Serialize MacroInfos separately than MacroDirectives. -Serialize the macro directives history into its own section -Get rid of the macro updates section -When de/serializing an identifier from a module, associate only one macro per submodule that defined+exported it. llvm-svn: 177761
2013-03-23 05:12:57 +08:00
MacrosLoaded[ID] = ReadMacroRecord(*M, M->MacroOffsets[Index]);
if (DeserializationListener)
DeserializationListener->MacroRead(ID + NUM_PREDEF_MACRO_IDS,
MacrosLoaded[ID]);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
return MacrosLoaded[ID];
}
MacroID ASTReader::getGlobalMacroID(ModuleFile &M, unsigned LocalID) {
if (LocalID < NUM_PREDEF_MACRO_IDS)
return LocalID;
ContinuousRangeMap<uint32_t, int, 2>::iterator I
= M.MacroRemap.find(LocalID - NUM_PREDEF_MACRO_IDS);
assert(I != M.MacroRemap.end() && "Invalid index into macro index remap");
return LocalID + I->second;
}
serialization::SubmoduleID
ASTReader::getGlobalSubmoduleID(ModuleFile &M, unsigned LocalID) {
if (LocalID < NUM_PREDEF_SUBMODULE_IDS)
return LocalID;
ContinuousRangeMap<uint32_t, int, 2>::iterator I
= M.SubmoduleRemap.find(LocalID - NUM_PREDEF_SUBMODULE_IDS);
assert(I != M.SubmoduleRemap.end()
&& "Invalid index into submodule index remap");
return LocalID + I->second;
}
Module *ASTReader::getSubmodule(SubmoduleID GlobalID) {
if (GlobalID < NUM_PREDEF_SUBMODULE_IDS) {
assert(GlobalID == 0 && "Unhandled global submodule ID");
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
return nullptr;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
if (GlobalID > SubmodulesLoaded.size()) {
Error("submodule ID out of range in AST file");
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
return nullptr;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
return SubmodulesLoaded[GlobalID - NUM_PREDEF_SUBMODULE_IDS];
}
Provide Decl::getOwningModule(), which determines the (sub)module in which a particular declaration resides. Use this information to customize the "definition of 'blah' must be imported from another module" diagnostic with the module the user actually has to import. Additionally, recover by importing that module, so we don't complain about other names in that module. Still TODO: coming up with decent Fix-Its for these cases, and expand this recovery approach for other name lookup failures. llvm-svn: 172290
2013-01-12 09:29:50 +08:00
Module *ASTReader::getModule(unsigned ID) {
return getSubmodule(ID);
}
Re-commit r246497 (and dependent changes r246524 and r246521), reverted in r246546, with a workaround for an MSVC 2013 miscompile and an MSVC 2015 rejects-valid. Original commit message: [modules] Rework serialized DeclContext lookup table management. Instead of walking the loaded ModuleFiles looking for lookup tables for the context, store them all in one place, and merge them together if we find we have too many (currently, more than 4). If we do merge, include the merged form in our serialized lookup table, so that downstream readers never need to look at our imports' tables. This gives a huge performance improvement to builds with very large numbers of modules (in some cases, more than a 2x speedup was observed). llvm-svn: 246582
2015-09-02 04:35:42 +08:00
ModuleFile *ASTReader::getLocalModuleFile(ModuleFile &F, unsigned ID) {
if (ID & 1) {
// It's a module, look it up by submodule ID.
auto I = GlobalSubmoduleMap.find(getGlobalSubmoduleID(F, ID >> 1));
return I == GlobalSubmoduleMap.end() ? nullptr : I->second;
} else {
// It's a prefix (preamble, PCH, ...). Look it up by index.
unsigned IndexFromEnd = ID >> 1;
assert(IndexFromEnd && "got reference to unknown module file");
return getModuleManager().pch_modules().end()[-IndexFromEnd];
}
}
unsigned ASTReader::getModuleFileID(ModuleFile *F) {
if (!F)
return 1;
// For a file representing a module, use the submodule ID of the top-level
// module as the file ID. For any other kind of file, the number of such
// files loaded beforehand will be the same on reload.
// FIXME: Is this true even if we have an explicit module file and a PCH?
if (F->isModule())
return ((F->BaseSubmoduleID + NUM_PREDEF_SUBMODULE_IDS) << 1) | 1;
auto PCHModules = getModuleManager().pch_modules();
auto I = std::find(PCHModules.begin(), PCHModules.end(), F);
assert(I != PCHModules.end() && "emitting reference to unknown file");
return (I - PCHModules.end()) << 1;
}
Add a function to ExternalASTSource that returns a descriptor that abstracts the commonalities between modules and PCH files that are needed to emit debug info for a module or precompiled header. llvm-svn: 241083
2015-07-01 01:39:43 +08:00
llvm::Optional<ExternalASTSource::ASTSourceDescriptor>
ASTReader::getSourceDescriptor(unsigned ID) {
if (const Module *M = getSubmodule(ID))
Refactor ASTReader::getSourceDescriptor(const Module &) into a constructor of ASTSourceDescriptor. It was effectively a static function. NFC. llvm-svn: 248069
2015-09-19 08:10:32 +08:00
return ExternalASTSource::ASTSourceDescriptor(*M);
Add a function to ExternalASTSource that returns a descriptor that abstracts the commonalities between modules and PCH files that are needed to emit debug info for a module or precompiled header. llvm-svn: 241083
2015-07-01 01:39:43 +08:00
// If there is only a single PCH, return it instead.
// Chained PCH are not suported.
if (ModuleMgr.size() == 1) {
ModuleFile &MF = ModuleMgr.getPrimaryModule();
Module Debugging: Canonicalize the file names used as PCH module names by stripping the path. Follow-up to r258555. This is safe because only one PCH per CU is currently supported for module debugging. rdar://problem/24301262 llvm-svn: 258582
2016-01-23 07:30:56 +08:00
StringRef ModuleName = llvm::sys::path::filename(MF.OriginalSourceFileName);
return ASTReader::ASTSourceDescriptor(ModuleName, MF.OriginalDir,
MF.FileName, MF.Signature);
Add a function to ExternalASTSource that returns a descriptor that abstracts the commonalities between modules and PCH files that are needed to emit debug info for a module or precompiled header. llvm-svn: 241083
2015-07-01 01:39:43 +08:00
}
return None;
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
Selector ASTReader::getLocalSelector(ModuleFile &M, unsigned LocalID) {
return DecodeSelector(getGlobalSelectorID(M, LocalID));
}
Selector ASTReader::DecodeSelector(serialization::SelectorID ID) {
if (ID == 0)
return Selector();
if (ID > SelectorsLoaded.size()) {
Error("selector ID out of range in AST file");
return Selector();
}
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
if (SelectorsLoaded[ID - 1].getAsOpaquePtr() == nullptr) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
// Load this selector from the selector table.
GlobalSelectorMapType::iterator I = GlobalSelectorMap.find(ID);
assert(I != GlobalSelectorMap.end() && "Corrupted global selector map");
ModuleFile &M = *I->second;
ASTSelectorLookupTrait Trait(*this, M);
unsigned Idx = ID - M.BaseSelectorID - NUM_PREDEF_SELECTOR_IDS;
SelectorsLoaded[ID - 1] =
Trait.ReadKey(M.SelectorLookupTableData + M.SelectorOffsets[Idx], 0);
if (DeserializationListener)
DeserializationListener->SelectorRead(ID, SelectorsLoaded[ID - 1]);
}
return SelectorsLoaded[ID - 1];
}
Selector ASTReader::GetExternalSelector(serialization::SelectorID ID) {
return DecodeSelector(ID);
}
uint32_t ASTReader::GetNumExternalSelectors() {
// ID 0 (the null selector) is considered an external selector.
return getTotalNumSelectors() + 1;
}
serialization::SelectorID
ASTReader::getGlobalSelectorID(ModuleFile &M, unsigned LocalID) const {
if (LocalID < NUM_PREDEF_SELECTOR_IDS)
return LocalID;
ContinuousRangeMap<uint32_t, int, 2>::iterator I
= M.SelectorRemap.find(LocalID - NUM_PREDEF_SELECTOR_IDS);
assert(I != M.SelectorRemap.end()
&& "Invalid index into selector index remap");
return LocalID + I->second;
}
DeclarationName
ASTReader::ReadDeclarationName(ModuleFile &F,
const RecordData &Record, unsigned &Idx) {
DeclarationName::NameKind Kind = (DeclarationName::NameKind)Record[Idx++];
switch (Kind) {
case DeclarationName::Identifier:
Revert r173056; it breaks one of the CodeGen-with-PCH tests. llvm-svn: 173058
2013-01-22 00:52:34 +08:00
return DeclarationName(GetIdentifierInfo(F, Record, Idx));
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
case DeclarationName::ObjCZeroArgSelector:
case DeclarationName::ObjCOneArgSelector:
case DeclarationName::ObjCMultiArgSelector:
return DeclarationName(ReadSelector(F, Record, Idx));
case DeclarationName::CXXConstructorName:
return Context.DeclarationNames.getCXXConstructorName(
Context.getCanonicalType(readType(F, Record, Idx)));
case DeclarationName::CXXDestructorName:
return Context.DeclarationNames.getCXXDestructorName(
Context.getCanonicalType(readType(F, Record, Idx)));
case DeclarationName::CXXConversionFunctionName:
return Context.DeclarationNames.getCXXConversionFunctionName(
Context.getCanonicalType(readType(F, Record, Idx)));
case DeclarationName::CXXOperatorName:
return Context.DeclarationNames.getCXXOperatorName(
(OverloadedOperatorKind)Record[Idx++]);
case DeclarationName::CXXLiteralOperatorName:
return Context.DeclarationNames.getCXXLiteralOperatorName(
GetIdentifierInfo(F, Record, Idx));
case DeclarationName::CXXUsingDirective:
return DeclarationName::getUsingDirectiveName();
}
llvm_unreachable("Invalid NameKind!");
}
void ASTReader::ReadDeclarationNameLoc(ModuleFile &F,
DeclarationNameLoc &DNLoc,
DeclarationName Name,
const RecordData &Record, unsigned &Idx) {
switch (Name.getNameKind()) {
case DeclarationName::CXXConstructorName:
case DeclarationName::CXXDestructorName:
case DeclarationName::CXXConversionFunctionName:
DNLoc.NamedType.TInfo = GetTypeSourceInfo(F, Record, Idx);
break;
case DeclarationName::CXXOperatorName:
DNLoc.CXXOperatorName.BeginOpNameLoc
= ReadSourceLocation(F, Record, Idx).getRawEncoding();
DNLoc.CXXOperatorName.EndOpNameLoc
= ReadSourceLocation(F, Record, Idx).getRawEncoding();
break;
case DeclarationName::CXXLiteralOperatorName:
DNLoc.CXXLiteralOperatorName.OpNameLoc
= ReadSourceLocation(F, Record, Idx).getRawEncoding();
break;
case DeclarationName::Identifier:
case DeclarationName::ObjCZeroArgSelector:
case DeclarationName::ObjCOneArgSelector:
case DeclarationName::ObjCMultiArgSelector:
case DeclarationName::CXXUsingDirective:
break;
}
}
void ASTReader::ReadDeclarationNameInfo(ModuleFile &F,
DeclarationNameInfo &NameInfo,
const RecordData &Record, unsigned &Idx) {
NameInfo.setName(ReadDeclarationName(F, Record, Idx));
NameInfo.setLoc(ReadSourceLocation(F, Record, Idx));
DeclarationNameLoc DNLoc;
ReadDeclarationNameLoc(F, DNLoc, NameInfo.getName(), Record, Idx);
NameInfo.setInfo(DNLoc);
}
void ASTReader::ReadQualifierInfo(ModuleFile &F, QualifierInfo &Info,
const RecordData &Record, unsigned &Idx) {
Info.QualifierLoc = ReadNestedNameSpecifierLoc(F, Record, Idx);
unsigned NumTPLists = Record[Idx++];
Info.NumTemplParamLists = NumTPLists;
if (NumTPLists) {
Info.TemplParamLists = new (Context) TemplateParameterList*[NumTPLists];
for (unsigned i=0; i != NumTPLists; ++i)
Info.TemplParamLists[i] = ReadTemplateParameterList(F, Record, Idx);
}
}
TemplateName
ASTReader::ReadTemplateName(ModuleFile &F, const RecordData &Record,
unsigned &Idx) {
TemplateName::NameKind Kind = (TemplateName::NameKind)Record[Idx++];
switch (Kind) {
case TemplateName::Template:
return TemplateName(ReadDeclAs<TemplateDecl>(F, Record, Idx));
case TemplateName::OverloadedTemplate: {
unsigned size = Record[Idx++];
UnresolvedSet<8> Decls;
while (size--)
Decls.addDecl(ReadDeclAs<NamedDecl>(F, Record, Idx));
return Context.getOverloadedTemplateName(Decls.begin(), Decls.end());
}
case TemplateName::QualifiedTemplate: {
NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx);
bool hasTemplKeyword = Record[Idx++];
TemplateDecl *Template = ReadDeclAs<TemplateDecl>(F, Record, Idx);
return Context.getQualifiedTemplateName(NNS, hasTemplKeyword, Template);
}
case TemplateName::DependentTemplate: {
NestedNameSpecifier *NNS = ReadNestedNameSpecifier(F, Record, Idx);
if (Record[Idx++]) // isIdentifier
return Context.getDependentTemplateName(NNS,
GetIdentifierInfo(F, Record,
Idx));
return Context.getDependentTemplateName(NNS,
(OverloadedOperatorKind)Record[Idx++]);
}
case TemplateName::SubstTemplateTemplateParm: {
TemplateTemplateParmDecl *param
= ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx);
if (!param) return TemplateName();
TemplateName replacement = ReadTemplateName(F, Record, Idx);
return Context.getSubstTemplateTemplateParm(param, replacement);
}
case TemplateName::SubstTemplateTemplateParmPack: {
TemplateTemplateParmDecl *Param
= ReadDeclAs<TemplateTemplateParmDecl>(F, Record, Idx);
if (!Param)
return TemplateName();
TemplateArgument ArgPack = ReadTemplateArgument(F, Record, Idx);
if (ArgPack.getKind() != TemplateArgument::Pack)
return TemplateName();
return Context.getSubstTemplateTemplateParmPack(Param, ArgPack);
}
}
llvm_unreachable("Unhandled template name kind!");
}
[modules] When loading a template specialization, re-canonicalize its template arguments because the reloaded form might have become non-canonical across the serialization/deserialization step (this particularly happens when the canonical form of the type involves an expression). llvm-svn: 244409
2015-08-09 09:05:31 +08:00
TemplateArgument ASTReader::ReadTemplateArgument(ModuleFile &F,
const RecordData &Record,
unsigned &Idx,
bool Canonicalize) {
if (Canonicalize) {
// The caller wants a canonical template argument. Sometimes the AST only
// wants template arguments in canonical form (particularly as the template
// argument lists of template specializations) so ensure we preserve that
// canonical form across serialization.
TemplateArgument Arg = ReadTemplateArgument(F, Record, Idx, false);
return Context.getCanonicalTemplateArgument(Arg);
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
TemplateArgument::ArgKind Kind = (TemplateArgument::ArgKind)Record[Idx++];
switch (Kind) {
case TemplateArgument::Null:
return TemplateArgument();
case TemplateArgument::Type:
return TemplateArgument(readType(F, Record, Idx));
case TemplateArgument::Declaration: {
ValueDecl *D = ReadDeclAs<ValueDecl>(F, Record, Idx);
PR21246: DebugInfo: Emit the appropriate type (cv qualifiers, reference-ness, etc) for non-type template parameters Plumb through the full QualType of the TemplateArgument::Declaration, as it's insufficient to only know whether the type is a reference or pointer (that was necessary for mangling, but insufficient for debug info). This shouldn't increase the size of TemplateArgument as TemplateArgument::Integer is still longer by another 32 bits. Several bits of code were testing that the reference-ness of the parameters matched, but this seemed to be insufficient (various other features of the type could've mismatched and wouldn't've been caught) and unnecessary, at least insofar as removing those tests didn't cause anything to fail. (Richard - perchaps you can hypothesize why any of these checks might need to test reference-ness of the parameters (& explain why reference-ness is part of the mangling - I would've figured that for the reference-ness to be different, a prior template argument would have to be different). I'd be happy to add them in/beef them up and add test cases if there's a reason for them) llvm-svn: 219900
2014-10-16 12:21:25 +08:00
return TemplateArgument(D, readType(F, Record, Idx));
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
case TemplateArgument::NullPtr:
return TemplateArgument(readType(F, Record, Idx), /*isNullPtr*/true);
case TemplateArgument::Integral: {
llvm::APSInt Value = ReadAPSInt(Record, Idx);
QualType T = readType(F, Record, Idx);
return TemplateArgument(Context, Value, T);
}
case TemplateArgument::Template:
return TemplateArgument(ReadTemplateName(F, Record, Idx));
case TemplateArgument::TemplateExpansion: {
TemplateName Name = ReadTemplateName(F, Record, Idx);
Include llvm::Optional in clang/Basic/LLVM.h Post-commit CR feedback from Jordan Rose regarding r175594. llvm-svn: 175679
2013-02-21 06:23:23 +08:00
Optional<unsigned> NumTemplateExpansions;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
if (unsigned NumExpansions = Record[Idx++])
NumTemplateExpansions = NumExpansions - 1;
return TemplateArgument(Name, NumTemplateExpansions);
}
case TemplateArgument::Expression:
return TemplateArgument(ReadExpr(F));
case TemplateArgument::Pack: {
unsigned NumArgs = Record[Idx++];
TemplateArgument *Args = new (Context) TemplateArgument[NumArgs];
for (unsigned I = 0; I != NumArgs; ++I)
Args[I] = ReadTemplateArgument(F, Record, Idx);
[AST] ArrayRefize template argument packs. No functionality change intended. llvm-svn: 244026
2015-08-05 17:40:22 +08:00
return TemplateArgument(llvm::makeArrayRef(Args, NumArgs));
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
}
llvm_unreachable("Unhandled template argument kind!");
}
TemplateParameterList *
ASTReader::ReadTemplateParameterList(ModuleFile &F,
const RecordData &Record, unsigned &Idx) {
SourceLocation TemplateLoc = ReadSourceLocation(F, Record, Idx);
SourceLocation LAngleLoc = ReadSourceLocation(F, Record, Idx);
SourceLocation RAngleLoc = ReadSourceLocation(F, Record, Idx);
unsigned NumParams = Record[Idx++];
SmallVector<NamedDecl *, 16> Params;
Params.reserve(NumParams);
while (NumParams--)
Params.push_back(ReadDeclAs<NamedDecl>(F, Record, Idx));
TemplateParameterList* TemplateParams =
TemplateParameterList::Create(Context, TemplateLoc, LAngleLoc,
ArrayRef-ize TemplateParameterList. NFC llvm-svn: 256463
2015-12-27 15:16:27 +08:00
Params, RAngleLoc);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
return TemplateParams;
}
void
ASTReader::
Use SmallVectorImpl& for function arguments instead of SmallVector. llvm-svn: 185715
2013-07-06 03:34:19 +08:00
ReadTemplateArgumentList(SmallVectorImpl<TemplateArgument> &TemplArgs,
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
ModuleFile &F, const RecordData &Record,
[modules] When loading a template specialization, re-canonicalize its template arguments because the reloaded form might have become non-canonical across the serialization/deserialization step (this particularly happens when the canonical form of the type involves an expression). llvm-svn: 244409
2015-08-09 09:05:31 +08:00
unsigned &Idx, bool Canonicalize) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
unsigned NumTemplateArgs = Record[Idx++];
TemplArgs.reserve(NumTemplateArgs);
while (NumTemplateArgs--)
[modules] When loading a template specialization, re-canonicalize its template arguments because the reloaded form might have become non-canonical across the serialization/deserialization step (this particularly happens when the canonical form of the type involves an expression). llvm-svn: 244409
2015-08-09 09:05:31 +08:00
TemplArgs.push_back(ReadTemplateArgument(F, Record, Idx, Canonicalize));
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
/// \brief Read a UnresolvedSet structure.
Don't eagerly load all conversion operators when loading a class declaration from a PCH/module. llvm-svn: 189646
2013-08-30 12:46:40 +08:00
void ASTReader::ReadUnresolvedSet(ModuleFile &F, LazyASTUnresolvedSet &Set,
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
const RecordData &Record, unsigned &Idx) {
unsigned NumDecls = Record[Idx++];
Set.reserve(Context, NumDecls);
while (NumDecls--) {
Don't eagerly load all conversion operators when loading a class declaration from a PCH/module. llvm-svn: 189646
2013-08-30 12:46:40 +08:00
DeclID ID = ReadDeclID(F, Record, Idx);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
AccessSpecifier AS = (AccessSpecifier)Record[Idx++];
Don't eagerly load all conversion operators when loading a class declaration from a PCH/module. llvm-svn: 189646
2013-08-30 12:46:40 +08:00
Set.addLazyDecl(Context, ID, AS);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
}
CXXBaseSpecifier
ASTReader::ReadCXXBaseSpecifier(ModuleFile &F,
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++]);
bool inheritConstructors = static_cast<bool>(Record[Idx++]);
TypeSourceInfo *TInfo = GetTypeSourceInfo(F, Record, Idx);
SourceRange Range = ReadSourceRange(F, Record, Idx);
SourceLocation EllipsisLoc = ReadSourceLocation(F, Record, Idx);
CXXBaseSpecifier Result(Range, isVirtual, isBaseOfClass, AS, TInfo,
EllipsisLoc);
Result.setInheritConstructors(inheritConstructors);
return Result;
}
[modules] Deserialize CXXCtorInitializer list for a constructor lazily. Previously we'd deserialize the list of mem-initializers for a constructor when we deserialized the declaration of the constructor. That could trigger a significant amount of unnecessary work (pulling in all base classes recursively, for a start) and was causing problems for the modules buildbot due to cyclic deserializations. We now deserialize these on demand. This creates a certain amount of duplication with the handling of CXXBaseSpecifiers; I'll look into reducing that next. llvm-svn: 233052
2015-03-24 14:36:48 +08:00
CXXCtorInitializer **
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
ASTReader::ReadCXXCtorInitializers(ModuleFile &F, const RecordData &Record,
unsigned &Idx) {
unsigned NumInitializers = Record[Idx++];
[modules] Deserialize CXXCtorInitializer list for a constructor lazily. Previously we'd deserialize the list of mem-initializers for a constructor when we deserialized the declaration of the constructor. That could trigger a significant amount of unnecessary work (pulling in all base classes recursively, for a start) and was causing problems for the modules buildbot due to cyclic deserializations. We now deserialize these on demand. This creates a certain amount of duplication with the handling of CXXBaseSpecifiers; I'll look into reducing that next. llvm-svn: 233052
2015-03-24 14:36:48 +08:00
assert(NumInitializers && "wrote ctor initializers but have no inits");
auto **CtorInitializers = new (Context) CXXCtorInitializer*[NumInitializers];
for (unsigned i = 0; i != NumInitializers; ++i) {
TypeSourceInfo *TInfo = nullptr;
bool IsBaseVirtual = false;
FieldDecl *Member = nullptr;
IndirectFieldDecl *IndirectMember = nullptr;
CtorInitializerType Type = (CtorInitializerType)Record[Idx++];
switch (Type) {
case CTOR_INITIALIZER_BASE:
TInfo = GetTypeSourceInfo(F, Record, Idx);
IsBaseVirtual = Record[Idx++];
break;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
[modules] Deserialize CXXCtorInitializer list for a constructor lazily. Previously we'd deserialize the list of mem-initializers for a constructor when we deserialized the declaration of the constructor. That could trigger a significant amount of unnecessary work (pulling in all base classes recursively, for a start) and was causing problems for the modules buildbot due to cyclic deserializations. We now deserialize these on demand. This creates a certain amount of duplication with the handling of CXXBaseSpecifiers; I'll look into reducing that next. llvm-svn: 233052
2015-03-24 14:36:48 +08:00
case CTOR_INITIALIZER_DELEGATING:
TInfo = GetTypeSourceInfo(F, Record, Idx);
break;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
[modules] Deserialize CXXCtorInitializer list for a constructor lazily. Previously we'd deserialize the list of mem-initializers for a constructor when we deserialized the declaration of the constructor. That could trigger a significant amount of unnecessary work (pulling in all base classes recursively, for a start) and was causing problems for the modules buildbot due to cyclic deserializations. We now deserialize these on demand. This creates a certain amount of duplication with the handling of CXXBaseSpecifiers; I'll look into reducing that next. llvm-svn: 233052
2015-03-24 14:36:48 +08:00
case CTOR_INITIALIZER_MEMBER:
Member = ReadDeclAs<FieldDecl>(F, Record, Idx);
break;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
[modules] Deserialize CXXCtorInitializer list for a constructor lazily. Previously we'd deserialize the list of mem-initializers for a constructor when we deserialized the declaration of the constructor. That could trigger a significant amount of unnecessary work (pulling in all base classes recursively, for a start) and was causing problems for the modules buildbot due to cyclic deserializations. We now deserialize these on demand. This creates a certain amount of duplication with the handling of CXXBaseSpecifiers; I'll look into reducing that next. llvm-svn: 233052
2015-03-24 14:36:48 +08:00
case CTOR_INITIALIZER_INDIRECT_MEMBER:
IndirectMember = ReadDeclAs<IndirectFieldDecl>(F, Record, Idx);
break;
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
[modules] Deserialize CXXCtorInitializer list for a constructor lazily. Previously we'd deserialize the list of mem-initializers for a constructor when we deserialized the declaration of the constructor. That could trigger a significant amount of unnecessary work (pulling in all base classes recursively, for a start) and was causing problems for the modules buildbot due to cyclic deserializations. We now deserialize these on demand. This creates a certain amount of duplication with the handling of CXXBaseSpecifiers; I'll look into reducing that next. llvm-svn: 233052
2015-03-24 14:36:48 +08:00
SourceLocation MemberOrEllipsisLoc = ReadSourceLocation(F, Record, Idx);
Expr *Init = ReadExpr(F);
SourceLocation LParenLoc = ReadSourceLocation(F, Record, Idx);
SourceLocation RParenLoc = ReadSourceLocation(F, Record, Idx);
bool IsWritten = Record[Idx++];
unsigned SourceOrderOrNumArrayIndices;
SmallVector<VarDecl *, 8> Indices;
if (IsWritten) {
SourceOrderOrNumArrayIndices = Record[Idx++];
} else {
SourceOrderOrNumArrayIndices = Record[Idx++];
Indices.reserve(SourceOrderOrNumArrayIndices);
for (unsigned i=0; i != SourceOrderOrNumArrayIndices; ++i)
Indices.push_back(ReadDeclAs<VarDecl>(F, Record, Idx));
}
CXXCtorInitializer *BOMInit;
if (Type == CTOR_INITIALIZER_BASE) {
BOMInit = new (Context)
CXXCtorInitializer(Context, TInfo, IsBaseVirtual, LParenLoc, Init,
RParenLoc, MemberOrEllipsisLoc);
} else if (Type == CTOR_INITIALIZER_DELEGATING) {
BOMInit = new (Context)
CXXCtorInitializer(Context, TInfo, LParenLoc, Init, RParenLoc);
} else if (IsWritten) {
if (Member)
BOMInit = new (Context) CXXCtorInitializer(
Context, Member, MemberOrEllipsisLoc, LParenLoc, Init, RParenLoc);
else
BOMInit = new (Context)
CXXCtorInitializer(Context, IndirectMember, MemberOrEllipsisLoc,
LParenLoc, Init, RParenLoc);
} else {
if (IndirectMember) {
assert(Indices.empty() && "Indirect field improperly initialized");
BOMInit = new (Context)
CXXCtorInitializer(Context, IndirectMember, MemberOrEllipsisLoc,
LParenLoc, Init, RParenLoc);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
} else {
[modules] Deserialize CXXCtorInitializer list for a constructor lazily. Previously we'd deserialize the list of mem-initializers for a constructor when we deserialized the declaration of the constructor. That could trigger a significant amount of unnecessary work (pulling in all base classes recursively, for a start) and was causing problems for the modules buildbot due to cyclic deserializations. We now deserialize these on demand. This creates a certain amount of duplication with the handling of CXXBaseSpecifiers; I'll look into reducing that next. llvm-svn: 233052
2015-03-24 14:36:48 +08:00
BOMInit = CXXCtorInitializer::Create(
Context, Member, MemberOrEllipsisLoc, LParenLoc, Init, RParenLoc,
Indices.data(), Indices.size());
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
}
[modules] Deserialize CXXCtorInitializer list for a constructor lazily. Previously we'd deserialize the list of mem-initializers for a constructor when we deserialized the declaration of the constructor. That could trigger a significant amount of unnecessary work (pulling in all base classes recursively, for a start) and was causing problems for the modules buildbot due to cyclic deserializations. We now deserialize these on demand. This creates a certain amount of duplication with the handling of CXXBaseSpecifiers; I'll look into reducing that next. llvm-svn: 233052
2015-03-24 14:36:48 +08:00
if (IsWritten)
BOMInit->setSourceOrder(SourceOrderOrNumArrayIndices);
CtorInitializers[i] = BOMInit;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
[modules] Deserialize CXXCtorInitializer list for a constructor lazily. Previously we'd deserialize the list of mem-initializers for a constructor when we deserialized the declaration of the constructor. That could trigger a significant amount of unnecessary work (pulling in all base classes recursively, for a start) and was causing problems for the modules buildbot due to cyclic deserializations. We now deserialize these on demand. This creates a certain amount of duplication with the handling of CXXBaseSpecifiers; I'll look into reducing that next. llvm-svn: 233052
2015-03-24 14:36:48 +08:00
return CtorInitializers;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
NestedNameSpecifier *
ASTReader::ReadNestedNameSpecifier(ModuleFile &F,
const RecordData &Record, unsigned &Idx) {
unsigned N = Record[Idx++];
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
NestedNameSpecifier *NNS = nullptr, *Prev = nullptr;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
for (unsigned I = 0; I != N; ++I) {
NestedNameSpecifier::SpecifierKind Kind
= (NestedNameSpecifier::SpecifierKind)Record[Idx++];
switch (Kind) {
case NestedNameSpecifier::Identifier: {
IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx);
NNS = NestedNameSpecifier::Create(Context, Prev, II);
break;
}
case NestedNameSpecifier::Namespace: {
NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx);
NNS = NestedNameSpecifier::Create(Context, Prev, NS);
break;
}
case NestedNameSpecifier::NamespaceAlias: {
NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx);
NNS = NestedNameSpecifier::Create(Context, Prev, Alias);
break;
}
case NestedNameSpecifier::TypeSpec:
case NestedNameSpecifier::TypeSpecWithTemplate: {
const Type *T = readType(F, Record, Idx).getTypePtrOrNull();
if (!T)
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
return nullptr;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
bool Template = Record[Idx++];
NNS = NestedNameSpecifier::Create(Context, Prev, Template, T);
break;
}
case NestedNameSpecifier::Global: {
NNS = NestedNameSpecifier::GlobalSpecifier(Context);
// No associated value, and there can't be a prefix.
break;
}
-ms-extensions: Implement __super scope specifier (PR13236). We build a NestedNameSpecifier that records the CXXRecordDecl in which __super appeared. Name lookup is performed in all base classes of the recorded CXXRecordDecl. Use of __super is allowed only inside class and member function scope. llvm-svn: 218484
2014-09-26 08:28:20 +08:00
case NestedNameSpecifier::Super: {
CXXRecordDecl *RD = ReadDeclAs<CXXRecordDecl>(F, Record, Idx);
NNS = NestedNameSpecifier::SuperSpecifier(Context, RD);
break;
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
Prev = NNS;
}
return NNS;
}
NestedNameSpecifierLoc
ASTReader::ReadNestedNameSpecifierLoc(ModuleFile &F, const RecordData &Record,
unsigned &Idx) {
unsigned N = Record[Idx++];
NestedNameSpecifierLocBuilder Builder;
for (unsigned I = 0; I != N; ++I) {
NestedNameSpecifier::SpecifierKind Kind
= (NestedNameSpecifier::SpecifierKind)Record[Idx++];
switch (Kind) {
case NestedNameSpecifier::Identifier: {
IdentifierInfo *II = GetIdentifierInfo(F, Record, Idx);
SourceRange Range = ReadSourceRange(F, Record, Idx);
Builder.Extend(Context, II, Range.getBegin(), Range.getEnd());
break;
}
case NestedNameSpecifier::Namespace: {
NamespaceDecl *NS = ReadDeclAs<NamespaceDecl>(F, Record, Idx);
SourceRange Range = ReadSourceRange(F, Record, Idx);
Builder.Extend(Context, NS, Range.getBegin(), Range.getEnd());
break;
}
case NestedNameSpecifier::NamespaceAlias: {
NamespaceAliasDecl *Alias =ReadDeclAs<NamespaceAliasDecl>(F, Record, Idx);
SourceRange Range = ReadSourceRange(F, Record, Idx);
Builder.Extend(Context, Alias, Range.getBegin(), Range.getEnd());
break;
}
case NestedNameSpecifier::TypeSpec:
case NestedNameSpecifier::TypeSpecWithTemplate: {
bool Template = Record[Idx++];
TypeSourceInfo *T = GetTypeSourceInfo(F, Record, Idx);
if (!T)
return NestedNameSpecifierLoc();
SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
// FIXME: 'template' keyword location not saved anywhere, so we fake it.
Builder.Extend(Context,
Template? T->getTypeLoc().getBeginLoc() : SourceLocation(),
T->getTypeLoc(), ColonColonLoc);
break;
}
case NestedNameSpecifier::Global: {
SourceLocation ColonColonLoc = ReadSourceLocation(F, Record, Idx);
Builder.MakeGlobal(Context, ColonColonLoc);
break;
}
-ms-extensions: Implement __super scope specifier (PR13236). We build a NestedNameSpecifier that records the CXXRecordDecl in which __super appeared. Name lookup is performed in all base classes of the recorded CXXRecordDecl. Use of __super is allowed only inside class and member function scope. llvm-svn: 218484
2014-09-26 08:28:20 +08:00
case NestedNameSpecifier::Super: {
CXXRecordDecl *RD = ReadDeclAs<CXXRecordDecl>(F, Record, Idx);
SourceRange Range = ReadSourceRange(F, Record, Idx);
Builder.MakeSuper(Context, RD, Range.getBegin(), Range.getEnd());
break;
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
}
-ms-extensions: Implement __super scope specifier (PR13236). We build a NestedNameSpecifier that records the CXXRecordDecl in which __super appeared. Name lookup is performed in all base classes of the recorded CXXRecordDecl. Use of __super is allowed only inside class and member function scope. llvm-svn: 218484
2014-09-26 08:28:20 +08:00
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
return Builder.getWithLocInContext(Context);
}
SourceRange
ASTReader::ReadSourceRange(ModuleFile &F, const RecordData &Record,
unsigned &Idx) {
SourceLocation beg = ReadSourceLocation(F, Record, Idx);
SourceLocation end = ReadSourceLocation(F, Record, Idx);
return SourceRange(beg, end);
}
/// \brief Read an integral value
llvm::APInt ASTReader::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 ASTReader::ReadAPSInt(const RecordData &Record, unsigned &Idx) {
bool isUnsigned = Record[Idx++];
return llvm::APSInt(ReadAPInt(Record, Idx), isUnsigned);
}
/// \brief Read a floating-point value
Switch to APFloat constructor taking fltSemantics. This change also makes the serialisation store the required semantics, fixing an issue where PPC128 was always assumed when re-reading a 128-bit value. llvm-svn: 173139
2013-01-22 17:46:51 +08:00
llvm::APFloat ASTReader::ReadAPFloat(const RecordData &Record,
const llvm::fltSemantics &Sem,
unsigned &Idx) {
return llvm::APFloat(Sem, ReadAPInt(Record, Idx));
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
// \brief Read a string
std::string ASTReader::ReadString(const RecordData &Record, unsigned &Idx) {
unsigned Len = Record[Idx++];
std::string Result(Record.data() + Idx, Record.data() + Idx + Len);
Idx += Len;
return Result;
}
[modules] Instead of storing absolute paths in a .pcm file, store the path to the root of the module and use paths relative to that directory wherever possible. This is a step towards allowing explicit modules to be relocated without being rebuilt, which is important for some kinds of distributed builds, for good paths in diagnostics, and for appropriate .d output. This is a recommit of r223443, reverted in r223465; when joining together imported file paths, we now use the system's separator rather than always using '/'. This avoids path mismatches between the original module build and the module user on Windows (at least, in some cases). A more comprehensive fix will follow. llvm-svn: 223539
2014-12-06 06:42:13 +08:00
std::string ASTReader::ReadPath(ModuleFile &F, const RecordData &Record,
unsigned &Idx) {
std::string Filename = ReadString(Record, Idx);
ResolveImportedPath(F, Filename);
return Filename;
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
VersionTuple ASTReader::ReadVersionTuple(const RecordData &Record,
unsigned &Idx) {
unsigned Major = Record[Idx++];
unsigned Minor = Record[Idx++];
unsigned Subminor = Record[Idx++];
if (Minor == 0)
return VersionTuple(Major);
if (Subminor == 0)
return VersionTuple(Major, Minor - 1);
return VersionTuple(Major, Minor - 1, Subminor - 1);
}
CXXTemporary *ASTReader::ReadCXXTemporary(ModuleFile &F,
const RecordData &Record,
unsigned &Idx) {
CXXDestructorDecl *Decl = ReadDeclAs<CXXDestructorDecl>(F, Record, Idx);
return CXXTemporary::Create(Context, Decl);
}
DiagnosticBuilder ASTReader::Diag(unsigned DiagID) {
[modules] If we hit a failure while loading a PCH/module, abort parsing instead of trying to continue in an invalid state. Also don't let libclang create a PCH with such an error. Fixes rdar://13953768 llvm-svn: 182629
2013-05-24 13:44:08 +08:00
return Diag(CurrentImportLoc, DiagID);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
DiagnosticBuilder ASTReader::Diag(SourceLocation Loc, unsigned DiagID) {
return Diags.Report(Loc, DiagID);
}
/// \brief Retrieve the identifier table associated with the
/// preprocessor.
IdentifierTable &ASTReader::getIdentifierTable() {
return PP.getIdentifierTable();
}
/// \brief Record that the given ID maps to the given switch-case
/// statement.
void ASTReader::RecordSwitchCaseID(SwitchCase *SC, unsigned ID) {
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
assert((*CurrSwitchCaseStmts)[ID] == nullptr &&
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
"Already have a SwitchCase with this ID");
(*CurrSwitchCaseStmts)[ID] = SC;
}
/// \brief Retrieve the switch-case statement with the given ID.
SwitchCase *ASTReader::getSwitchCaseWithID(unsigned ID) {
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
assert((*CurrSwitchCaseStmts)[ID] != nullptr && "No SwitchCase with this ID");
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
return (*CurrSwitchCaseStmts)[ID];
}
void ASTReader::ClearSwitchCaseIDs() {
CurrSwitchCaseStmts->clear();
}
void ASTReader::ReadComments() {
std::vector<RawComment *> Comments;
finish converting the normal cases in ASTReader to use the new BitstreamCursor APIs. llvm-svn: 172937
2013-01-20 08:56:42 +08:00
for (SmallVectorImpl<std::pair<BitstreamCursor,
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
serialization::ModuleFile *> >::iterator
I = CommentsCursors.begin(),
E = CommentsCursors.end();
I != E; ++I) {
Comment parsing: when comment ranges are deserialized from multiple modules, correctly order comments in SourceManager::isBeforeInTranslationUnit() order Unfortunately, this is not as simple as it was implemented previously, and actually requires doing a merge sort. llvm-svn: 204936
2014-03-27 23:40:39 +08:00
Comments.clear();
finish converting the normal cases in ASTReader to use the new BitstreamCursor APIs. llvm-svn: 172937
2013-01-20 08:56:42 +08:00
BitstreamCursor &Cursor = I->first;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
serialization::ModuleFile &F = *I->second;
SavedStreamPosition SavedPosition(Cursor);
RecordData Record;
while (true) {
finish converting the normal cases in ASTReader to use the new BitstreamCursor APIs. llvm-svn: 172937
2013-01-20 08:56:42 +08:00
llvm::BitstreamEntry Entry =
Cursor.advanceSkippingSubblocks(BitstreamCursor::AF_DontPopBlockAtEnd);
Comment parsing: when comment ranges are deserialized from multiple modules, correctly order comments in SourceManager::isBeforeInTranslationUnit() order Unfortunately, this is not as simple as it was implemented previously, and actually requires doing a merge sort. llvm-svn: 204936
2014-03-27 23:40:39 +08:00
finish converting the normal cases in ASTReader to use the new BitstreamCursor APIs. llvm-svn: 172937
2013-01-20 08:56:42 +08:00
switch (Entry.Kind) {
case llvm::BitstreamEntry::SubBlock: // Handled for us already.
case llvm::BitstreamEntry::Error:
Error("malformed block record in AST file");
return;
case llvm::BitstreamEntry::EndBlock:
goto NextCursor;
case llvm::BitstreamEntry::Record:
// The interesting case.
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
break;
}
// Read a record.
Record.clear();
update to use the new BitcodeCursor readRecord that takes a StringRef blob parameter, and adopt "advance" in more places. llvm-svn: 172951
2013-01-20 10:38:54 +08:00
switch ((CommentRecordTypes)Cursor.readRecord(Entry.ID, Record)) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
case COMMENTS_RAW_COMMENT: {
unsigned Idx = 0;
SourceRange SR = ReadSourceRange(F, Record, Idx);
RawComment::CommentKind Kind =
(RawComment::CommentKind) Record[Idx++];
bool IsTrailingComment = Record[Idx++];
bool IsAlmostTrailingComment = Record[Idx++];
Add an option to parse all comments as documentation comments Patch by Amin Shali. llvm-svn: 179180
2013-04-10 23:35:17 +08:00
Comments.push_back(new (Context) RawComment(
SR, Kind, IsTrailingComment, IsAlmostTrailingComment,
Context.getLangOpts().CommentOpts.ParseAllComments));
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
break;
}
}
}
Comment parsing: when comment ranges are deserialized from multiple modules, correctly order comments in SourceManager::isBeforeInTranslationUnit() order Unfortunately, this is not as simple as it was implemented previously, and actually requires doing a merge sort. llvm-svn: 204936
2014-03-27 23:40:39 +08:00
NextCursor:
Context.Comments.addDeserializedComments(Comments);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
}
When a module completes the definition of a class template specialization imported from another module, emit an update record, rather than using the broken decl rewriting mechanism. If multiple modules do this, merge the definitions together, much as we would if they were separate declarations. llvm-svn: 206680
2014-04-19 11:48:30 +08:00
std::string ASTReader::getOwningModuleNameForDiagnostic(const Decl *D) {
// If we know the owning module, use it.
[modules] Add local submodule visibility support for declarations. With this change, enabling -fmodules-local-submodule-visibility results in name visibility rules being applied to submodules of the current module in addition to imported modules (that is, names no longer "leak" between submodules of the same top-level module). This also makes it much safer to textually include a non-modular library into a module: each submodule that textually includes that library will get its own "copy" of that library, and so the library becomes visible no matter which including submodule you import. llvm-svn: 237473
2015-05-16 04:05:43 +08:00
if (Module *M = D->getImportedOwningModule())
When a module completes the definition of a class template specialization imported from another module, emit an update record, rather than using the broken decl rewriting mechanism. If multiple modules do this, merge the definitions together, much as we would if they were separate declarations. llvm-svn: 206680
2014-04-19 11:48:30 +08:00
return M->getFullModuleName();
// Otherwise, use the name of the top-level module the decl is within.
if (ModuleFile *M = getOwningModuleFile(D))
return M->ModuleName;
// Not from a module.
return "";
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
void ASTReader::finishPendingActions() {
If two sibling modules declare the same entity, and we indirectly pull a declaration of that entity in from one of those modules, keep track of the fact that we've not completed the redeclaration chain yet so that we can pull the remaining declarations in from the other module if they're needed. llvm-svn: 209161
2014-05-20 04:59:20 +08:00
while (!PendingIdentifierInfos.empty() ||
!PendingIncompleteDeclChains.empty() || !PendingDeclChains.empty() ||
Basic ODR checking for C++ modules: If we have multiple definitions of the same entity from different modules, we nominate the first definition which we see as being the canonical definition. If we load a declaration from a different definition and we can't find a corresponding declaration in the canonical definition, issue a diagnostic. This is insufficient to prevent things from going horribly wrong in all cases -- we might be in the middle of emitting IR for a function when we trigger some deserialization and discover that it refers to an incoherent piece of the AST, by which point it's probably too late to bail out -- but we'll at least produce a diagnostic. llvm-svn: 192950
2013-10-18 14:05:18 +08:00
!PendingMacroIDs.empty() || !PendingDeclContextInfos.empty() ||
[modules] Factor out ODR checking, to avoid unnecessary repeated work in finishPendingActions loop. llvm-svn: 214246
2014-07-30 07:23:27 +08:00
!PendingUpdateRecords.empty()) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
// If any identifiers with corresponding top-level declarations have
// been loaded, load those declarations now.
Add typedefs for Densemaps containing SmallVectors to avoid repeating the SmallVector size when creating iterators for the DenseMap. llvm-svn: 185682
2013-07-05 12:33:53 +08:00
typedef llvm::DenseMap<IdentifierInfo *, SmallVector<Decl *, 2> >
TopLevelDeclsMap;
TopLevelDeclsMap TopLevelDecls;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
while (!PendingIdentifierInfos.empty()) {
Ensure that the identifier chains have the most recent declaration after module deserialization. This commit introduces a set of related changes to ensure that the declaration that shows up in the identifier chain after deserializing declarations with a given identifier is, in fact, the most recent declaration. The primary change involves waiting until after we deserialize and wire up redeclaration chains before updating the identifier chains. There is a minor optimization in here to avoid recursively deserializing names as part of looking to see whether top-level declarations for a given name exist. A related change that became suddenly more urgent is to property record a merged declaration when an entity first declared in the current translation unit is later deserialized from a module (that had not been loaded at the time of the original declaration). Since we key off the canonical declaration (which is parsed, not from an AST file) for emitted redeclarations, we simply record this as a merged declaration during AST writing and let the readers merge them. Re-fixes <rdar://problem/13189985>, presumably for good this time. llvm-svn: 175447
2013-02-18 23:53:43 +08:00
IdentifierInfo *II = PendingIdentifierInfos.back().first;
Fix a FIXME, use std::move. llvm-svn: 205021
2014-03-29 01:31:23 +08:00
SmallVector<uint32_t, 4> DeclIDs =
std::move(PendingIdentifierInfos.back().second);
Use MapVector::pop_back() per LLVM r175538. llvm-svn: 175539
2013-02-20 02:26:28 +08:00
PendingIdentifierInfos.pop_back();
Ensure that the identifier chains have the most recent declaration after module deserialization. This commit introduces a set of related changes to ensure that the declaration that shows up in the identifier chain after deserializing declarations with a given identifier is, in fact, the most recent declaration. The primary change involves waiting until after we deserialize and wire up redeclaration chains before updating the identifier chains. There is a minor optimization in here to avoid recursively deserializing names as part of looking to see whether top-level declarations for a given name exist. A related change that became suddenly more urgent is to property record a merged declaration when an entity first declared in the current translation unit is later deserialized from a module (that had not been loaded at the time of the original declaration). Since we key off the canonical declaration (which is parsed, not from an AST file) for emitted redeclarations, we simply record this as a merged declaration during AST writing and let the readers merge them. Re-fixes <rdar://problem/13189985>, presumably for good this time. llvm-svn: 175447
2013-02-18 23:53:43 +08:00
SetGloballyVisibleDecls(II, DeclIDs, &TopLevelDecls[II]);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
Fix a FIXME, use std::move. llvm-svn: 205021
2014-03-29 01:31:23 +08:00
If two sibling modules declare the same entity, and we indirectly pull a declaration of that entity in from one of those modules, keep track of the fact that we've not completed the redeclaration chain yet so that we can pull the remaining declarations in from the other module if they're needed. llvm-svn: 209161
2014-05-20 04:59:20 +08:00
// For each decl chain that we wanted to complete while deserializing, mark
// it as "still needs to be completed".
for (unsigned I = 0; I != PendingIncompleteDeclChains.size(); ++I) {
markIncompleteDeclChain(PendingIncompleteDeclChains[I]);
}
PendingIncompleteDeclChains.clear();
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
// Load pending declaration chains.
[modules] Rearrange how redeclaration chains are loaded, to remove a walk over all modules and reduce the number of declarations we load when loading a redeclaration chain. The new approach is: * when loading the first declaration of an entity within a module file, we first load all declarations of the entity that were imported into that module file, and then load all the other declarations of that entity from that module file and build a suitable decl chain from them * when loading any other declaration of an entity, we first load the first declaration from the same module file As before, we complete redecl chains through name lookup where necessary. To make this work, I also had to change the way that template specializations are stored -- it no longer suffices to track only canonical specializations; we now emit all "first local" declarations when emitting a list of specializations for a template. On one testcase with several thousand imported module files, this reduces the total runtime by 72%. llvm-svn: 245779
2015-08-22 09:47:18 +08:00
for (unsigned I = 0; I != PendingDeclChains.size(); ++I)
[modules] Further simplification and speedup of redeclaration chain loading. Instead of eagerly deserializing a list of DeclIDs when we load a module file and doing a binary search to find the redeclarations of a decl, store a list of redeclarations of each chain before the first declaration and load it directly. llvm-svn: 245789
2015-08-23 04:13:39 +08:00
loadPendingDeclChain(PendingDeclChains[I].first, PendingDeclChains[I].second);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
PendingDeclChains.clear();
Ensure that the identifier chains have the most recent declaration after module deserialization. This commit introduces a set of related changes to ensure that the declaration that shows up in the identifier chain after deserializing declarations with a given identifier is, in fact, the most recent declaration. The primary change involves waiting until after we deserialize and wire up redeclaration chains before updating the identifier chains. There is a minor optimization in here to avoid recursively deserializing names as part of looking to see whether top-level declarations for a given name exist. A related change that became suddenly more urgent is to property record a merged declaration when an entity first declared in the current translation unit is later deserialized from a module (that had not been loaded at the time of the original declaration). Since we key off the canonical declaration (which is parsed, not from an AST file) for emitted redeclarations, we simply record this as a merged declaration during AST writing and let the readers merge them. Re-fixes <rdar://problem/13189985>, presumably for good this time. llvm-svn: 175447
2013-02-18 23:53:43 +08:00
// Make the most recent of the top-level declarations visible.
Add typedefs for Densemaps containing SmallVectors to avoid repeating the SmallVector size when creating iterators for the DenseMap. llvm-svn: 185682
2013-07-05 12:33:53 +08:00
for (TopLevelDeclsMap::iterator TLD = TopLevelDecls.begin(),
TLDEnd = TopLevelDecls.end(); TLD != TLDEnd; ++TLD) {
Ensure that the identifier chains have the most recent declaration after module deserialization. This commit introduces a set of related changes to ensure that the declaration that shows up in the identifier chain after deserializing declarations with a given identifier is, in fact, the most recent declaration. The primary change involves waiting until after we deserialize and wire up redeclaration chains before updating the identifier chains. There is a minor optimization in here to avoid recursively deserializing names as part of looking to see whether top-level declarations for a given name exist. A related change that became suddenly more urgent is to property record a merged declaration when an entity first declared in the current translation unit is later deserialized from a module (that had not been loaded at the time of the original declaration). Since we key off the canonical declaration (which is parsed, not from an AST file) for emitted redeclarations, we simply record this as a merged declaration during AST writing and let the readers merge them. Re-fixes <rdar://problem/13189985>, presumably for good this time. llvm-svn: 175447
2013-02-18 23:53:43 +08:00
IdentifierInfo *II = TLD->first;
for (unsigned I = 0, N = TLD->second.size(); I != N; ++I) {
[Modules] Fix an issue where the reconstructed redeclaration chain was incomplete, missing the definition from a module. -Make sure that a deserialized external decl gets added to the TU scope. -When associating an identifier with a set of decls, use the most recent local ones, if they exist, otherwise associating decls from modules (that came after a local one) will lead to an incomplete reconstructed re-declaration chain. rdar://13712705 llvm-svn: 180634
2013-04-27 05:33:35 +08:00
pushExternalDeclIntoScope(cast<NamedDecl>(TLD->second[I]), II);
Ensure that the identifier chains have the most recent declaration after module deserialization. This commit introduces a set of related changes to ensure that the declaration that shows up in the identifier chain after deserializing declarations with a given identifier is, in fact, the most recent declaration. The primary change involves waiting until after we deserialize and wire up redeclaration chains before updating the identifier chains. There is a minor optimization in here to avoid recursively deserializing names as part of looking to see whether top-level declarations for a given name exist. A related change that became suddenly more urgent is to property record a merged declaration when an entity first declared in the current translation unit is later deserialized from a module (that had not been loaded at the time of the original declaration). Since we key off the canonical declaration (which is parsed, not from an AST file) for emitted redeclarations, we simply record this as a merged declaration during AST writing and let the readers merge them. Re-fixes <rdar://problem/13189985>, presumably for good this time. llvm-svn: 175447
2013-02-18 23:53:43 +08:00
}
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
// Load any pending macro definitions.
for (unsigned I = 0; I != PendingMacroIDs.size(); ++I) {
[PCH/Modules] De/Serialize MacroInfos separately than MacroDirectives. -Serialize the macro directives history into its own section -Get rid of the macro updates section -When de/serializing an identifier from a module, associate only one macro per submodule that defined+exported it. llvm-svn: 177761
2013-03-23 05:12:57 +08:00
IdentifierInfo *II = PendingMacroIDs.begin()[I].first;
SmallVector<PendingMacroInfo, 2> GlobalIDs;
GlobalIDs.swap(PendingMacroIDs.begin()[I].second);
// Initialize the macro history from chained-PCHs ahead of module imports.
If a module A exports a macro M, and a module B imports that macro and #undef's it, importers of B should not see the macro. This is complicated by the fact that A's macro could also be visible through a different path. The rules (as hashed out on cfe-commits) are included as a documentation update in this change. With this, the number of regressions in libc++'s testsuite when modules are enabled drops from 47 to 7. Those remaining 7 are also macro-related, and are due to remaining bugs in this change (in particular, the handling of submodules is imperfect). llvm-svn: 202560
2014-03-01 08:08:04 +08:00
for (unsigned IDIdx = 0, NumIDs = GlobalIDs.size(); IDIdx != NumIDs;
[PCH/Modules] De/Serialize MacroInfos separately than MacroDirectives. -Serialize the macro directives history into its own section -Get rid of the macro updates section -When de/serializing an identifier from a module, associate only one macro per submodule that defined+exported it. llvm-svn: 177761
2013-03-23 05:12:57 +08:00
++IDIdx) {
const PendingMacroInfo &Info = GlobalIDs[IDIdx];
[modules] Initial support for explicitly loading .pcm files. Implicit module builds are not well-suited to a lot of build systems. In particular, they fare badly in distributed build systems, and they lead to build artifacts that are not tracked as part of the usual dependency management process. This change allows explicitly-built module files (which are already supported through the -emit-module flag) to be explicitly loaded into a build, allowing build systems to opt to manage module builds and dependencies themselves. This is only the first step in supporting such configurations, and it should be considered experimental and subject to change or removal for now. llvm-svn: 220359
2014-10-22 10:05:46 +08:00
if (Info.M->Kind != MK_ImplicitModule &&
Info.M->Kind != MK_ExplicitModule)
[PCH/Modules] De/Serialize MacroInfos separately than MacroDirectives. -Serialize the macro directives history into its own section -Get rid of the macro updates section -When de/serializing an identifier from a module, associate only one macro per submodule that defined+exported it. llvm-svn: 177761
2013-03-23 05:12:57 +08:00
resolvePendingMacro(II, Info);
}
// Handle module imports.
If a module A exports a macro M, and a module B imports that macro and #undef's it, importers of B should not see the macro. This is complicated by the fact that A's macro could also be visible through a different path. The rules (as hashed out on cfe-commits) are included as a documentation update in this change. With this, the number of regressions in libc++'s testsuite when modules are enabled drops from 47 to 7. Those remaining 7 are also macro-related, and are due to remaining bugs in this change (in particular, the handling of submodules is imperfect). llvm-svn: 202560
2014-03-01 08:08:04 +08:00
for (unsigned IDIdx = 0, NumIDs = GlobalIDs.size(); IDIdx != NumIDs;
[PCH/Modules] Revert r172843, it caused a module to fail building. llvm-svn: 172884
2013-01-19 11:14:56 +08:00
++IDIdx) {
[PCH/Modules] De/Serialize MacroInfos separately than MacroDirectives. -Serialize the macro directives history into its own section -Get rid of the macro updates section -When de/serializing an identifier from a module, associate only one macro per submodule that defined+exported it. llvm-svn: 177761
2013-03-23 05:12:57 +08:00
const PendingMacroInfo &Info = GlobalIDs[IDIdx];
[modules] Initial support for explicitly loading .pcm files. Implicit module builds are not well-suited to a lot of build systems. In particular, they fare badly in distributed build systems, and they lead to build artifacts that are not tracked as part of the usual dependency management process. This change allows explicitly-built module files (which are already supported through the -emit-module flag) to be explicitly loaded into a build, allowing build systems to opt to manage module builds and dependencies themselves. This is only the first step in supporting such configurations, and it should be considered experimental and subject to change or removal for now. llvm-svn: 220359
2014-10-22 10:05:46 +08:00
if (Info.M->Kind == MK_ImplicitModule ||
Info.M->Kind == MK_ExplicitModule)
[PCH/Modules] De/Serialize MacroInfos separately than MacroDirectives. -Serialize the macro directives history into its own section -Get rid of the macro updates section -When de/serializing an identifier from a module, associate only one macro per submodule that defined+exported it. llvm-svn: 177761
2013-03-23 05:12:57 +08:00
resolvePendingMacro(II, Info);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
}
PendingMacroIDs.clear();
[PCH] Deserializing the DeclContext of a template parameter is not safe until recursive loading is finished. Otherwise we may end up with a template trying to deserialize a template parameter that is in the process of getting loaded. rdar://13135282 llvm-svn: 175329
2013-02-16 08:48:59 +08:00
// Wire up the DeclContexts for Decls that we delayed setting until
// recursive loading is completed.
while (!PendingDeclContextInfos.empty()) {
PendingDeclContextInfo Info = PendingDeclContextInfos.front();
PendingDeclContextInfos.pop_front();
DeclContext *SemaDC = cast<DeclContext>(GetDecl(Info.SemaDC));
DeclContext *LexicalDC = cast<DeclContext>(GetDecl(Info.LexicalDC));
Info.D->setDeclContextsImpl(SemaDC, LexicalDC, getContext());
}
Basic ODR checking for C++ modules: If we have multiple definitions of the same entity from different modules, we nominate the first definition which we see as being the canonical definition. If we load a declaration from a different definition and we can't find a corresponding declaration in the canonical definition, issue a diagnostic. This is insufficient to prevent things from going horribly wrong in all cases -- we might be in the middle of emitting IR for a function when we trigger some deserialization and discover that it refers to an incoherent piece of the AST, by which point it's probably too late to bail out -- but we'll at least produce a diagnostic. llvm-svn: 192950
2013-10-18 14:05:18 +08:00
Defer loading any pending update records until we've finished deserializing. This fixes a bug where an update record causes us to load an entity that refers to an entity we've not finished loading yet, resulting in badness. llvm-svn: 207603
2014-04-30 10:24:17 +08:00
// Perform any pending declaration updates.
[modules] Don't defer performing updates if we have incomplete redecl chains. Instead, perform them carefully immediately. llvm-svn: 215147
2014-08-08 04:58:41 +08:00
while (!PendingUpdateRecords.empty()) {
Defer loading any pending update records until we've finished deserializing. This fixes a bug where an update record causes us to load an entity that refers to an entity we've not finished loading yet, resulting in badness. llvm-svn: 207603
2014-04-30 10:24:17 +08:00
auto Update = PendingUpdateRecords.pop_back_val();
ReadingKindTracker ReadingKind(Read_Decl, *this);
loadDeclUpdateRecords(Update.first, Update.second);
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
[modules] Sometimes we can deserialize a class member but not have yet encountered any definition for the class; this happens when the definition is added by an update record that is not yet loaded. In such a case, eagerly pick the original parent of the member as the canonical definition of the class rather than muddling through with the canonical declaration (the latter can lead to us failing to merge properly later if the canonical definition turns out to be some other declaration). llvm-svn: 226977
2015-01-24 09:07:20 +08:00
// At this point, all update records for loaded decls are in place, so any
// fake class definitions should have become real.
assert(PendingFakeDefinitionData.empty() &&
"faked up a class definition but never saw the real one");
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
// If we deserialized any C++ or Objective-C class definitions, any
// Objective-C protocol definitions, or any redeclarable templates, make sure
// that all redeclarations point to the definitions. Note that this can only
// happen now, after the redeclaration chains have been fully wired.
Use range based for loops to avoid needing to re-mention SmallPtrSet size. llvm-svn: 216370
2014-08-25 12:15:02 +08:00
for (Decl *D : PendingDefinitions) {
if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
Make TypeDecl much less friendly. llvm-svn: 207007
2014-04-24 02:20:42 +08:00
if (const TagType *TagT = dyn_cast<TagType>(TD->getTypeForDecl())) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
// Make sure that the TagType points at the definition.
const_cast<TagType*>(TagT)->decl = TD;
}
[modules] Avoid accidentally completing the redeclaration chain when updating all the existing declarations of a record-like entity with a pointer to its definition. llvm-svn: 231901
2015-03-11 09:44:51 +08:00
Use range based for loops to avoid needing to re-mention SmallPtrSet size. llvm-svn: 216370
2014-08-25 12:15:02 +08:00
if (auto RD = dyn_cast<CXXRecordDecl>(D)) {
[modules] Avoid accidentally completing the redeclaration chain when updating all the existing declarations of a record-like entity with a pointer to its definition. llvm-svn: 231901
2015-03-11 09:44:51 +08:00
for (auto *R = getMostRecentExistingDecl(RD); R;
R = R->getPreviousDecl()) {
assert((R == D) ==
cast<CXXRecordDecl>(R)->isThisDeclarationADefinition() &&
[modules] Add an assert that we properly manage the IsCompleteDefinition flag on CXXRecordDecls when merging definitions, and make it pass by not trying to save and restore this flag across AST serialization/deserialization. For CXXRecordDecls, we have a separate mechanism to manage this. llvm-svn: 216633
2014-08-28 07:11:59 +08:00
"declaration thinks it's the definition but it isn't");
[C++11] Replacing iterators redecls_begin() and redecls_end() with iterator_range redecls(). Updating all of the usages of the iterators with range-based for loops, which allows the begin/end forms to be removed entirely. llvm-svn: 203179
2014-03-07 07:45:36 +08:00
cast<CXXRecordDecl>(R)->DefinitionData = RD->DefinitionData;
[modules] Add an assert that we properly manage the IsCompleteDefinition flag on CXXRecordDecls when merging definitions, and make it pass by not trying to save and restore this flag across AST serialization/deserialization. For CXXRecordDecls, we have a separate mechanism to manage this. llvm-svn: 216633
2014-08-28 07:11:59 +08:00
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
continue;
}
[modules] Avoid accidentally completing the redeclaration chain when updating all the existing declarations of a record-like entity with a pointer to its definition. llvm-svn: 231901
2015-03-11 09:44:51 +08:00
Use range based for loops to avoid needing to re-mention SmallPtrSet size. llvm-svn: 216370
2014-08-25 12:15:02 +08:00
if (auto ID = dyn_cast<ObjCInterfaceDecl>(D)) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
// Make sure that the ObjCInterfaceType points at the definition.
const_cast<ObjCInterfaceType *>(cast<ObjCInterfaceType>(ID->TypeForDecl))
->Decl = ID;
[modules] Avoid accidentally completing the redeclaration chain when updating all the existing declarations of a record-like entity with a pointer to its definition. llvm-svn: 231901
2015-03-11 09:44:51 +08:00
for (auto *R = getMostRecentExistingDecl(ID); R; R = R->getPreviousDecl())
cast<ObjCInterfaceDecl>(R)->Data = ID->Data;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
continue;
}
[modules] Avoid accidentally completing the redeclaration chain when updating all the existing declarations of a record-like entity with a pointer to its definition. llvm-svn: 231901
2015-03-11 09:44:51 +08:00
Use range based for loops to avoid needing to re-mention SmallPtrSet size. llvm-svn: 216370
2014-08-25 12:15:02 +08:00
if (auto PD = dyn_cast<ObjCProtocolDecl>(D)) {
[modules] Avoid accidentally completing the redeclaration chain when updating all the existing declarations of a record-like entity with a pointer to its definition. llvm-svn: 231901
2015-03-11 09:44:51 +08:00
for (auto *R = getMostRecentExistingDecl(PD); R; R = R->getPreviousDecl())
cast<ObjCProtocolDecl>(R)->Data = PD->Data;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
continue;
}
[modules] Avoid accidentally completing the redeclaration chain when updating all the existing declarations of a record-like entity with a pointer to its definition. llvm-svn: 231901
2015-03-11 09:44:51 +08:00
Use range based for loops to avoid needing to re-mention SmallPtrSet size. llvm-svn: 216370
2014-08-25 12:15:02 +08:00
auto RTD = cast<RedeclarableTemplateDecl>(D)->getCanonicalDecl();
[modules] Avoid accidentally completing the redeclaration chain when updating all the existing declarations of a record-like entity with a pointer to its definition. llvm-svn: 231901
2015-03-11 09:44:51 +08:00
for (auto *R = getMostRecentExistingDecl(RTD); R; R = R->getPreviousDecl())
cast<RedeclarableTemplateDecl>(R)->Common = RTD->Common;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
PendingDefinitions.clear();
// Load the bodies of any functions or methods we've encountered. We do
// this now (delayed) so that we can be sure that the declaration chains
[modules] When we see a definition of a function for which we already have a non-visible definition, skip the new definition to avoid ending up with a function with multiple definitions. llvm-svn: 245664
2015-08-21 11:04:33 +08:00
// have been fully wired up (hasBody relies on this).
// FIXME: We shouldn't require complete redeclaration chains here.
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
for (PendingBodiesMap::iterator PB = PendingBodies.begin(),
PBEnd = PendingBodies.end();
PB != PBEnd; ++PB) {
if (FunctionDecl *FD = dyn_cast<FunctionDecl>(PB->first)) {
// FIXME: Check for =delete/=default?
// FIXME: Complain about ODR violations here?
if (!getContext().getLangOpts().Modules || !FD->hasBody())
FD->setLazyBody(PB->second);
continue;
}
ObjCMethodDecl *MD = cast<ObjCMethodDecl>(PB->first);
if (!getContext().getLangOpts().Modules || !MD->hasBody())
MD->setLazyBody(PB->second);
}
PendingBodies.clear();
[modules] Add local submodule visibility support for declarations. With this change, enabling -fmodules-local-submodule-visibility results in name visibility rules being applied to submodules of the current module in addition to imported modules (that is, names no longer "leak" between submodules of the same top-level module). This also makes it much safer to textually include a non-modular library into a module: each submodule that textually includes that library will get its own "copy" of that library, and so the library becomes visible no matter which including submodule you import. llvm-svn: 237473
2015-05-16 04:05:43 +08:00
// Do some cleanup.
for (auto *ND : PendingMergedDefinitionsToDeduplicate)
getContext().deduplicateMergedDefinitonsFor(ND);
PendingMergedDefinitionsToDeduplicate.clear();
[modules] Factor out ODR checking, to avoid unnecessary repeated work in finishPendingActions loop. llvm-svn: 214246
2014-07-30 07:23:27 +08:00
}
void ASTReader::diagnoseOdrViolations() {
[modules] When performing a lookup into a namespace, ensure that any later redefinitions of that namespace have already been loaded. When writing out the names in a namespace, if we see a name that is locally declared and had imported declarations merged on top of it, export the local declaration as the lookup result, because it will be the most recent declaration of that entity in the redeclaration chain of an importer of the module. llvm-svn: 215518
2014-08-13 09:23:33 +08:00
if (PendingOdrMergeFailures.empty() && PendingOdrMergeChecks.empty())
return;
[modules] Factor out ODR checking, to avoid unnecessary repeated work in finishPendingActions loop. llvm-svn: 214246
2014-07-30 07:23:27 +08:00
// Trigger the import of the full definition of each class that had any
// odr-merging problems, so we can produce better diagnostics for them.
[modules] When performing a lookup into a namespace, ensure that any later redefinitions of that namespace have already been loaded. When writing out the names in a namespace, if we see a name that is locally declared and had imported declarations merged on top of it, export the local declaration as the lookup result, because it will be the most recent declaration of that entity in the redeclaration chain of an importer of the module. llvm-svn: 215518
2014-08-13 09:23:33 +08:00
// These updates may in turn find and diagnose some ODR failures, so take
// ownership of the set first.
auto OdrMergeFailures = std::move(PendingOdrMergeFailures);
PendingOdrMergeFailures.clear();
for (auto &Merge : OdrMergeFailures) {
[modules] Factor out ODR checking, to avoid unnecessary repeated work in finishPendingActions loop. llvm-svn: 214246
2014-07-30 07:23:27 +08:00
Merge.first->buildLookup();
Merge.first->decls_begin();
Merge.first->bases_begin();
Merge.first->vbases_begin();
for (auto *RD : Merge.second) {
RD->decls_begin();
RD->bases_begin();
RD->vbases_begin();
}
}
// For each declaration from a merged context, check that the canonical
// definition of that context also contains a declaration of the same
// entity.
//
// Caution: this loop does things that might invalidate iterators into
// PendingOdrMergeChecks. Don't turn this into a range-based for loop!
while (!PendingOdrMergeChecks.empty()) {
NamedDecl *D = PendingOdrMergeChecks.pop_back_val();
// FIXME: Skip over implicit declarations for now. This matters for things
// like implicitly-declared special member functions. This isn't entirely
// correct; we can end up with multiple unmerged declarations of the same
// implicit entity.
if (D->isImplicit())
continue;
DeclContext *CanonDef = D->getDeclContext();
bool Found = false;
const Decl *DCanon = D->getCanonicalDecl();
[modules] When completing the redecl chain for an anonymous declaration in a merged context, pull in the lexical decls in that context, since one of them may complete the redecl chain. llvm-svn: 216652
2014-08-28 13:44:07 +08:00
for (auto RI : D->redecls()) {
if (RI->getLexicalDeclContext() == CanonDef) {
Found = true;
break;
}
}
if (Found)
continue;
[modules] Defer setting up the lookup table for a DeclContext until we can determine the primary context, rather than sometimes registering the lookup table on the wrong context. This exposed a couple of bugs: * the odr violation check didn't deal properly with mergeable declarations if the declaration retained by name lookup wasn't in the canonical definition of the class * the (broken) RewriteDecl mechanism would emit two name lookup tables for the same DeclContext into the same module file (one as part of the rewritten declaration and one as a visible update for the old declaration) These are both fixed too. llvm-svn: 244192
2015-08-06 12:23:48 +08:00
// Quick check failed, time to do the slow thing. Note, we can't just
// look up the name of D in CanonDef here, because the member that is
// in CanonDef might not be found by name lookup (it might have been
// replaced by a more recent declaration in the lookup table), and we
// can't necessarily find it in the redeclaration chain because it might
// be merely mergeable, not redeclarable.
[modules] Factor out ODR checking, to avoid unnecessary repeated work in finishPendingActions loop. llvm-svn: 214246
2014-07-30 07:23:27 +08:00
llvm::SmallVector<const NamedDecl*, 4> Candidates;
[modules] Defer setting up the lookup table for a DeclContext until we can determine the primary context, rather than sometimes registering the lookup table on the wrong context. This exposed a couple of bugs: * the odr violation check didn't deal properly with mergeable declarations if the declaration retained by name lookup wasn't in the canonical definition of the class * the (broken) RewriteDecl mechanism would emit two name lookup tables for the same DeclContext into the same module file (one as part of the rewritten declaration and one as a visible update for the old declaration) These are both fixed too. llvm-svn: 244192
2015-08-06 12:23:48 +08:00
for (auto *CanonMember : CanonDef->decls()) {
if (CanonMember->getCanonicalDecl() == DCanon) {
// This can happen if the declaration is merely mergeable and not
// actually redeclarable (we looked for redeclarations earlier).
//
// FIXME: We should be able to detect this more efficiently, without
// pulling in all of the members of CanonDef.
Found = true;
break;
[modules] Factor out ODR checking, to avoid unnecessary repeated work in finishPendingActions loop. llvm-svn: 214246
2014-07-30 07:23:27 +08:00
}
[modules] Defer setting up the lookup table for a DeclContext until we can determine the primary context, rather than sometimes registering the lookup table on the wrong context. This exposed a couple of bugs: * the odr violation check didn't deal properly with mergeable declarations if the declaration retained by name lookup wasn't in the canonical definition of the class * the (broken) RewriteDecl mechanism would emit two name lookup tables for the same DeclContext into the same module file (one as part of the rewritten declaration and one as a visible update for the old declaration) These are both fixed too. llvm-svn: 244192
2015-08-06 12:23:48 +08:00
if (auto *ND = dyn_cast<NamedDecl>(CanonMember))
if (ND->getDeclName() == D->getDeclName())
Candidates.push_back(ND);
[modules] Factor out ODR checking, to avoid unnecessary repeated work in finishPendingActions loop. llvm-svn: 214246
2014-07-30 07:23:27 +08:00
}
if (!Found) {
[modules] Number anonymous declarations that are lexically within mergeable contexts, so that we can merge them when we merge the surrounding context. llvm-svn: 216639
2014-08-28 09:33:39 +08:00
// The AST doesn't like TagDecls becoming invalid after they've been
// completed. We only really need to mark FieldDecls as invalid here.
if (!isa<TagDecl>(D))
D->setInvalidDecl();
[modules] Guard against recursively re-entering diagnosing ODR violations while in the middle of emitting an ODR violation diagnostic. I don't yet have a reduced testcase for this issue, working on it... llvm-svn: 229167
2015-02-14 06:43:51 +08:00
// Ensure we don't accidentally recursively enter deserialization while
// we're producing our diagnostic.
Deserializing RecursionGuard(this);
[modules] Factor out ODR checking, to avoid unnecessary repeated work in finishPendingActions loop. llvm-svn: 214246
2014-07-30 07:23:27 +08:00
std::string CanonDefModule =
getOwningModuleNameForDiagnostic(cast<Decl>(CanonDef));
Diag(D->getLocation(), diag::err_module_odr_violation_missing_decl)
<< D << getOwningModuleNameForDiagnostic(D)
<< CanonDef << CanonDefModule.empty() << CanonDefModule;
if (Candidates.empty())
Diag(cast<Decl>(CanonDef)->getLocation(),
diag::note_module_odr_violation_no_possible_decls) << D;
else {
for (unsigned I = 0, N = Candidates.size(); I != N; ++I)
Diag(Candidates[I]->getLocation(),
diag::note_module_odr_violation_possible_decl)
<< Candidates[I];
}
DiagnosedOdrMergeFailures.insert(CanonDef);
}
}
When a module completes the definition of a class template specialization imported from another module, emit an update record, rather than using the broken decl rewriting mechanism. If multiple modules do this, merge the definitions together, much as we would if they were separate declarations. llvm-svn: 206680
2014-04-19 11:48:30 +08:00
[modules] Guard against recursively re-entering diagnosing ODR violations while in the middle of emitting an ODR violation diagnostic. I don't yet have a reduced testcase for this issue, working on it... llvm-svn: 229167
2015-02-14 06:43:51 +08:00
if (OdrMergeFailures.empty())
return;
// Ensure we don't accidentally recursively enter deserialization while
// we're producing our diagnostics.
Deserializing RecursionGuard(this);
When a module completes the definition of a class template specialization imported from another module, emit an update record, rather than using the broken decl rewriting mechanism. If multiple modules do this, merge the definitions together, much as we would if they were separate declarations. llvm-svn: 206680
2014-04-19 11:48:30 +08:00
// Issue any pending ODR-failure diagnostics.
[modules] When performing a lookup into a namespace, ensure that any later redefinitions of that namespace have already been loaded. When writing out the names in a namespace, if we see a name that is locally declared and had imported declarations merged on top of it, export the local declaration as the lookup result, because it will be the most recent declaration of that entity in the redeclaration chain of an importer of the module. llvm-svn: 215518
2014-08-13 09:23:33 +08:00
for (auto &Merge : OdrMergeFailures) {
[modules] Factor out ODR checking, to avoid unnecessary repeated work in finishPendingActions loop. llvm-svn: 214246
2014-07-30 07:23:27 +08:00
// If we've already pointed out a specific problem with this class, don't
// bother issuing a general "something's different" diagnostic.
Update for LLVM API change to make Small(Ptr)Set::insert return pair<iterator, bool> as per the C++ standard's associative container concept. llvm-svn: 222335
2014-11-19 15:49:47 +08:00
if (!DiagnosedOdrMergeFailures.insert(Merge.first).second)
When a module completes the definition of a class template specialization imported from another module, emit an update record, rather than using the broken decl rewriting mechanism. If multiple modules do this, merge the definitions together, much as we would if they were separate declarations. llvm-svn: 206680
2014-04-19 11:48:30 +08:00
continue;
bool Diagnosed = false;
for (auto *RD : Merge.second) {
// Multiple different declarations got merged together; tell the user
// where they came from.
if (Merge.first != RD) {
// FIXME: Walk the definition, figure out what's different,
// and diagnose that.
if (!Diagnosed) {
std::string Module = getOwningModuleNameForDiagnostic(Merge.first);
Diag(Merge.first->getLocation(),
diag::err_module_odr_violation_different_definitions)
<< Merge.first << Module.empty() << Module;
Diagnosed = true;
}
Diag(RD->getLocation(),
diag::note_module_odr_violation_different_definitions)
<< getOwningModuleNameForDiagnostic(RD);
}
}
if (!Diagnosed) {
// All definitions are updates to the same declaration. This happens if a
// module instantiates the declaration of a class template specialization
// and two or more other modules instantiate its definition.
//
// FIXME: Indicate which modules had instantiations of this definition.
// FIXME: How can this even happen?
Diag(Merge.first->getLocation(),
diag::err_module_odr_violation_different_instantiations)
<< Merge.first;
}
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
Extend -ftime-report to give more information about time spent reading module files. llvm-svn: 242094
2015-07-14 08:26:00 +08:00
void ASTReader::StartedDeserializing() {
if (++NumCurrentElementsDeserializing == 1 && ReadTimer.get())
ReadTimer->startTimer();
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
void ASTReader::FinishedDeserializing() {
assert(NumCurrentElementsDeserializing &&
"FinishedDeserializing not paired with StartedDeserializing");
if (NumCurrentElementsDeserializing == 1) {
// We decrease NumCurrentElementsDeserializing only after pending actions
// are finished, to avoid recursively re-calling finishPendingActions().
finishPendingActions();
}
--NumCurrentElementsDeserializing;
[modules] Factor out ODR checking, to avoid unnecessary repeated work in finishPendingActions loop. llvm-svn: 214246
2014-07-30 07:23:27 +08:00
if (NumCurrentElementsDeserializing == 0) {
[modules] Remove redundant import of lexical decls when building a lookup table for a DeclContext, and fix propagation of exception specifications along redeclaration chains. This reverts r232905, r232907, and r232907, which reverted r232793, r232853, and r232853. One additional change is present here to resolve issues with LLDB: distinguish between whether lexical decls missing from the lookup table are local or are provided by the external AST source, and still look in the external source if that's where they came from. llvm-svn: 232928
2015-03-23 11:25:59 +08:00
// Propagate exception specification updates along redeclaration chains.
[modules] Fix an iterator invalidation bug found by the modules selfhost bot. llvm-svn: 233007
2015-03-24 03:54:56 +08:00
while (!PendingExceptionSpecUpdates.empty()) {
auto Updates = std::move(PendingExceptionSpecUpdates);
PendingExceptionSpecUpdates.clear();
for (auto Update : Updates) {
auto *FPT = Update.second->getType()->castAs<FunctionProtoType>();
[modules] Don't needlessly bounce through Sema when updating exception specifications. llvm-svn: 245501
2015-08-20 05:09:32 +08:00
auto ESI = FPT->getExtProtoInfo().ExceptionSpec;
Re-commit r246497 (and dependent changes r246524 and r246521), reverted in r246546, with a workaround for an MSVC 2013 miscompile and an MSVC 2015 rejects-valid. Original commit message: [modules] Rework serialized DeclContext lookup table management. Instead of walking the loaded ModuleFiles looking for lookup tables for the context, store them all in one place, and merge them together if we find we have too many (currently, more than 4). If we do merge, include the merged form in our serialized lookup table, so that downstream readers never need to look at our imports' tables. This gives a huge performance improvement to builds with very large numbers of modules (in some cases, more than a 2x speedup was observed). llvm-svn: 246582
2015-09-02 04:35:42 +08:00
if (auto *Listener = Context.getASTMutationListener())
Listener->ResolvedExceptionSpec(cast<FunctionDecl>(Update.second));
[modules] Don't needlessly bounce through Sema when updating exception specifications. llvm-svn: 245501
2015-08-20 05:09:32 +08:00
for (auto *Redecl : Update.second->redecls())
Context.adjustExceptionSpec(cast<FunctionDecl>(Redecl), ESI);
[modules] Fix an iterator invalidation bug found by the modules selfhost bot. llvm-svn: 233007
2015-03-24 03:54:56 +08:00
}
[modules] Remove redundant import of lexical decls when building a lookup table for a DeclContext, and fix propagation of exception specifications along redeclaration chains. This reverts r232905, r232907, and r232907, which reverted r232793, r232853, and r232853. One additional change is present here to resolve issues with LLDB: distinguish between whether lexical decls missing from the lookup table are local or are provided by the external AST source, and still look in the external source if that's where they came from. llvm-svn: 232928
2015-03-23 11:25:59 +08:00
}
Extend -ftime-report to give more information about time spent reading module files. llvm-svn: 242094
2015-07-14 08:26:00 +08:00
if (ReadTimer)
ReadTimer->stopTimer();
[modules] Defer setting up the lookup table for a DeclContext until we can determine the primary context, rather than sometimes registering the lookup table on the wrong context. This exposed a couple of bugs: * the odr violation check didn't deal properly with mergeable declarations if the declaration retained by name lookup wasn't in the canonical definition of the class * the (broken) RewriteDecl mechanism would emit two name lookup tables for the same DeclContext into the same module file (one as part of the rewritten declaration and one as a visible update for the old declaration) These are both fixed too. llvm-svn: 244192
2015-08-06 12:23:48 +08:00
diagnoseOdrViolations();
If an update record makes a declaration interesting, pass it to the consumer. llvm-svn: 204550
2014-03-23 08:27:18 +08:00
// We are not in recursive loading, so it's safe to pass the "interesting"
// decls to the consumer.
[modules] Factor out ODR checking, to avoid unnecessary repeated work in finishPendingActions loop. llvm-svn: 214246
2014-07-30 07:23:27 +08:00
if (Consumer)
PassInterestingDeclsToConsumer();
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
}
[Modules] Fix an issue where the reconstructed redeclaration chain was incomplete, missing the definition from a module. -Make sure that a deserialized external decl gets added to the TU scope. -When associating an identifier with a set of decls, use the most recent local ones, if they exist, otherwise associating decls from modules (that came after a local one) will lead to an incomplete reconstructed re-declaration chain. rdar://13712705 llvm-svn: 180634
2013-04-27 05:33:35 +08:00
void ASTReader::pushExternalDeclIntoScope(NamedDecl *D, DeclarationName Name) {
[modules] Remove redundant import of lexical decls when building a lookup table for a DeclContext, and fix propagation of exception specifications along redeclaration chains. This reverts r232905, r232907, and r232907, which reverted r232793, r232853, and r232853. One additional change is present here to resolve issues with LLDB: distinguish between whether lexical decls missing from the lookup table are local or are provided by the external AST source, and still look in the external source if that's where they came from. llvm-svn: 232928
2015-03-23 11:25:59 +08:00
if (IdentifierInfo *II = Name.getAsIdentifierInfo()) {
// Remove any fake results before adding any real ones.
auto It = PendingFakeLookupResults.find(II);
if (It != PendingFakeLookupResults.end()) {
[modules] In C++, stop serializing and deserializing a list of declarations in the identifier table. This is redundant, since the TU-scope lookups are also serialized as part of the TU DeclContext, and wasteful in a number of ways. We still emit the decls for PCH / preamble builds, since for those we want identical results, not merely semantically equivalent ones. llvm-svn: 242855
2015-07-22 07:54:07 +08:00
for (auto *ND : It->second)
[modules] Remove redundant import of lexical decls when building a lookup table for a DeclContext, and fix propagation of exception specifications along redeclaration chains. This reverts r232905, r232907, and r232907, which reverted r232793, r232853, and r232853. One additional change is present here to resolve issues with LLDB: distinguish between whether lexical decls missing from the lookup table are local or are provided by the external AST source, and still look in the external source if that's where they came from. llvm-svn: 232928
2015-03-23 11:25:59 +08:00
SemaObj->IdResolver.RemoveDecl(ND);
Workaround a performance issue with modules + PCH More fallout from r228234; when looking up an identifier in a PCH that imports the Cocoa module on Darwin, it was taking 2 to 5 seconds because we were hammering the MapVector::erase() function, which is O(n). For now, just clear() the contained SmallVector to get back to 0.25 - 0.5 seconds. This is probably not the long-term fix, because without modules or without PCH the performance is more like 0.02 seconds. llvm-svn: 234655
2015-04-11 06:25:42 +08:00
// FIXME: this works around module+PCH performance issue.
// Rather than erase the result from the map, which is O(n), just clear
// the vector of NamedDecls.
It->second.clear();
[modules] Remove redundant import of lexical decls when building a lookup table for a DeclContext, and fix propagation of exception specifications along redeclaration chains. This reverts r232905, r232907, and r232907, which reverted r232793, r232853, and r232853. One additional change is present here to resolve issues with LLDB: distinguish between whether lexical decls missing from the lookup table are local or are provided by the external AST source, and still look in the external source if that's where they came from. llvm-svn: 232928
2015-03-23 11:25:59 +08:00
}
}
[Modules] Fix an issue where the reconstructed redeclaration chain was incomplete, missing the definition from a module. -Make sure that a deserialized external decl gets added to the TU scope. -When associating an identifier with a set of decls, use the most recent local ones, if they exist, otherwise associating decls from modules (that came after a local one) will lead to an incomplete reconstructed re-declaration chain. rdar://13712705 llvm-svn: 180634
2013-04-27 05:33:35 +08:00
if (SemaObj->IdResolver.tryAddTopLevelDecl(D, Name) && SemaObj->TUScope) {
SemaObj->TUScope->AddDecl(D);
} else if (SemaObj->TUScope) {
// Adding the decl to IdResolver may have failed because it was already in
// (even though it was not added in scope). If it is already in, make sure
// it gets in the scope as well.
if (std::find(SemaObj->IdResolver.begin(Name),
SemaObj->IdResolver.end(), D) != SemaObj->IdResolver.end())
SemaObj->TUScope->AddDecl(D);
}
}
Introduce module file extensions to piggy-back data onto module files. Introduce the notion of a module file extension, which introduces additional information into a module file at the time it is built that can then be queried when the module file is read. Module file extensions are identified by a block name (which must be unique to the extension) and can write any bitstream records into their own extension block within the module file. When a module file is loaded, any extension blocks are matched up with module file extension readers, that are per-module-file and are given access to the input bitstream. Note that module file extensions can only be introduced by programmatic clients that have access to the CompilerInvocation. There is only one such extension at the moment, which is used for testing the module file extension harness. As a future direction, one could imagine allowing the plugin mechanism to introduce new module file extensions. llvm-svn: 251955
2015-11-04 02:33:07 +08:00
ASTReader::ASTReader(
Preprocessor &PP, ASTContext &Context,
const PCHContainerReader &PCHContainerRdr,
ArrayRef<IntrusiveRefCntPtr<ModuleFileExtension>> Extensions,
StringRef isysroot, bool DisableValidation,
bool AllowASTWithCompilerErrors,
bool AllowConfigurationMismatch, bool ValidateSystemInputs,
bool UseGlobalIndex,
std::unique_ptr<llvm::Timer> ReadTimer)
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
: Listener(new PCHValidator(PP, *this)), DeserializationListener(nullptr),
Let ASTReader optionally delete its ASTDeserializationListener. Use this to fix the leak of DeserializedDeclsDumper and DeserializedDeclsChecker in FrontendAction (found by LSan), PR19560. The "delete this" bool is necessary because both PCHGenerator and ASTUnit return the same object from both getDeserializationListener() and getASTMutationListener(), so ASTReader can't just have a unique_ptr. It's also not possible to just let FrontendAction (or CompilerInstance) own these listeners due to lifetime issues (see comments on PR19560). Finally, ASTDeserializationListener can't easily be refcounted, since several of the current listeners are allocated on the stack. Having this bool isn't ideal, but it's a pattern that's used in other places in the codebase too, and it seems better than leaking. llvm-svn: 208277
2014-05-08 12:26:47 +08:00
OwnsDeserializationListener(false), SourceMgr(PP.getSourceManager()),
Make the clang module container format selectable from the command line. - introduces a new cc1 option -fmodule-format=[raw,obj] with 'raw' being the default - supports arbitrary module container formats that libclang is agnostic to - adds the format to the module hash to avoid collisions - splits the old PCHContainerOperations into PCHContainerWriter and a PCHContainerReader. Thanks to Richard Smith for reviewing this patch! llvm-svn: 242499
2015-07-17 09:19:54 +08:00
FileMgr(PP.getFileManager()), PCHContainerRdr(PCHContainerRdr),
Introduce a PCHContainerOperations interface (NFC). A PCHContainerOperations abstract interface provides operations for creating and unwrapping containers for serialized ASTs (precompiled headers and clang modules). The default implementation is RawPCHContainerOperations, which uses a flat file for the output. The main application for this interface will be an ObjectFilePCHContainerOperations implementation that uses LLVM to wrap the module in an ELF/Mach-O/COFF container to store debug info alongside the AST. rdar://problem/20091852 llvm-svn: 240225
2015-06-21 02:53:08 +08:00
Diags(PP.getDiagnostics()), SemaObj(nullptr), PP(PP), Context(Context),
Make the clang module container format selectable from the command line. - introduces a new cc1 option -fmodule-format=[raw,obj] with 'raw' being the default - supports arbitrary module container formats that libclang is agnostic to - adds the format to the module hash to avoid collisions - splits the old PCHContainerOperations into PCHContainerWriter and a PCHContainerReader. Thanks to Richard Smith for reviewing this patch! llvm-svn: 242499
2015-07-17 09:19:54 +08:00
Consumer(nullptr), ModuleMgr(PP.getFileManager(), PCHContainerRdr),
Extend -ftime-report to give more information about time spent reading module files. llvm-svn: 242094
2015-07-14 08:26:00 +08:00
ReadTimer(std::move(ReadTimer)),
Introduce a PCHContainerOperations interface (NFC). A PCHContainerOperations abstract interface provides operations for creating and unwrapping containers for serialized ASTs (precompiled headers and clang modules). The default implementation is RawPCHContainerOperations, which uses a flat file for the output. The main application for this interface will be an ObjectFilePCHContainerOperations implementation that uses LLVM to wrap the module in an ELF/Mach-O/COFF container to store debug info alongside the AST. rdar://problem/20091852 llvm-svn: 240225
2015-06-21 02:53:08 +08:00
isysroot(isysroot), DisableValidation(DisableValidation),
Let ASTReader optionally delete its ASTDeserializationListener. Use this to fix the leak of DeserializedDeclsDumper and DeserializedDeclsChecker in FrontendAction (found by LSan), PR19560. The "delete this" bool is necessary because both PCHGenerator and ASTUnit return the same object from both getDeserializationListener() and getASTMutationListener(), so ASTReader can't just have a unique_ptr. It's also not possible to just let FrontendAction (or CompilerInstance) own these listeners due to lifetime issues (see comments on PR19560). Finally, ASTDeserializationListener can't easily be refcounted, since several of the current listeners are allocated on the stack. Having this bool isn't ideal, but it's a pattern that's used in other places in the codebase too, and it seems better than leaking. llvm-svn: 208277
2014-05-08 12:26:47 +08:00
AllowASTWithCompilerErrors(AllowASTWithCompilerErrors),
AllowConfigurationMismatch(AllowConfigurationMismatch),
ValidateSystemInputs(ValidateSystemInputs),
UseGlobalIndex(UseGlobalIndex), TriedLoadingGlobalIndex(false),
Introduce a PCHContainerOperations interface (NFC). A PCHContainerOperations abstract interface provides operations for creating and unwrapping containers for serialized ASTs (precompiled headers and clang modules). The default implementation is RawPCHContainerOperations, which uses a flat file for the output. The main application for this interface will be an ObjectFilePCHContainerOperations implementation that uses LLVM to wrap the module in an ELF/Mach-O/COFF container to store debug info alongside the AST. rdar://problem/20091852 llvm-svn: 240225
2015-06-21 02:53:08 +08:00
CurrSwitchCaseStmts(&SwitchCaseStmts), NumSLocEntriesRead(0),
TotalNumSLocEntries(0), NumStatementsRead(0), TotalNumStatements(0),
NumMacrosRead(0), TotalNumMacros(0), NumIdentifierLookups(0),
NumIdentifierLookupHits(0), NumSelectorsRead(0),
Let ASTReader optionally delete its ASTDeserializationListener. Use this to fix the leak of DeserializedDeclsDumper and DeserializedDeclsChecker in FrontendAction (found by LSan), PR19560. The "delete this" bool is necessary because both PCHGenerator and ASTUnit return the same object from both getDeserializationListener() and getASTMutationListener(), so ASTReader can't just have a unique_ptr. It's also not possible to just let FrontendAction (or CompilerInstance) own these listeners due to lifetime issues (see comments on PR19560). Finally, ASTDeserializationListener can't easily be refcounted, since several of the current listeners are allocated on the stack. Having this bool isn't ideal, but it's a pattern that's used in other places in the codebase too, and it seems better than leaking. llvm-svn: 208277
2014-05-08 12:26:47 +08:00
NumMethodPoolEntriesRead(0), NumMethodPoolLookups(0),
NumMethodPoolHits(0), NumMethodPoolTableLookups(0),
NumMethodPoolTableHits(0), TotalNumMethodPoolEntries(0),
NumLexicalDeclContextsRead(0), TotalLexicalDeclContexts(0),
NumVisibleDeclContextsRead(0), TotalVisibleDeclContexts(0),
TotalModulesSizeInBits(0), NumCurrentElementsDeserializing(0),
[modules] Deserialize CXXCtorInitializer list for a constructor lazily. Previously we'd deserialize the list of mem-initializers for a constructor when we deserialized the declaration of the constructor. That could trigger a significant amount of unnecessary work (pulling in all base classes recursively, for a start) and was causing problems for the modules buildbot due to cyclic deserializations. We now deserialize these on demand. This creates a certain amount of duplication with the handling of CXXBaseSpecifiers; I'll look into reducing that next. llvm-svn: 233052
2015-03-24 14:36:48 +08:00
PassingDeclsToConsumer(false), ReadingKind(Read_None) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
SourceMgr.setExternalSLocEntrySource(this);
Introduce module file extensions to piggy-back data onto module files. Introduce the notion of a module file extension, which introduces additional information into a module file at the time it is built that can then be queried when the module file is read. Module file extensions are identified by a block name (which must be unique to the extension) and can write any bitstream records into their own extension block within the module file. When a module file is loaded, any extension blocks are matched up with module file extension readers, that are per-module-file and are given access to the input bitstream. Note that module file extensions can only be introduced by programmatic clients that have access to the CompilerInvocation. There is only one such extension at the moment, which is used for testing the module file extension harness. As a future direction, one could imagine allowing the plugin mechanism to introduce new module file extensions. llvm-svn: 251955
2015-11-04 02:33:07 +08:00
for (const auto &Ext : Extensions) {
auto BlockName = Ext->getExtensionMetadata().BlockName;
auto Known = ModuleFileExtensions.find(BlockName);
if (Known != ModuleFileExtensions.end()) {
Diags.Report(diag::warn_duplicate_module_file_extension)
<< BlockName;
continue;
}
ModuleFileExtensions.insert({BlockName, Ext});
}
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
ASTReader::~ASTReader() {
Let ASTReader optionally delete its ASTDeserializationListener. Use this to fix the leak of DeserializedDeclsDumper and DeserializedDeclsChecker in FrontendAction (found by LSan), PR19560. The "delete this" bool is necessary because both PCHGenerator and ASTUnit return the same object from both getDeserializationListener() and getASTMutationListener(), so ASTReader can't just have a unique_ptr. It's also not possible to just let FrontendAction (or CompilerInstance) own these listeners due to lifetime issues (see comments on PR19560). Finally, ASTDeserializationListener can't easily be refcounted, since several of the current listeners are allocated on the stack. Having this bool isn't ideal, but it's a pattern that's used in other places in the codebase too, and it seems better than leaking. llvm-svn: 208277
2014-05-08 12:26:47 +08:00
if (OwnsDeserializationListener)
delete DeserializationListener;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}