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

8452 lines
300 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"
#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] 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
void ChainedASTReaderListener::visitModuleFile(StringRef Filename) {
First->visitModuleFile(Filename);
Second->visitModuleFile(Filename);
}
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,
bool isOverridden) {
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()))
Continue |= First->visitInputFile(Filename, isSystem, isOverridden);
if (Second->needsInputFileVisitation() &&
(!isSystem || Second->needsSystemInputFileVisitation()))
Continue |= Second->visitInputFile(Filename, isSystem, isOverridden);
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
}
Revert changes from r170428, 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
//===----------------------------------------------------------------------===//
ASTReaderListener::~ASTReaderListener() {}
/// \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"
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".
static bool isInterestingIdentifier(IdentifierInfo &II) {
return II.isPoisoned() ||
II.isExtensionToken() ||
II.getObjCOrBuiltinID() ||
II.hasRevertedTokenIDToIdentifier() ||
II.hadMacroDefinition() ||
II.getFETokenInfo<void>();
}
Revert changes from r170428, 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;
IdentID ID = Reader.getGlobalIdentifierID(F, RawID);
if (!IsInteresting) {
// For uninteresting identifiers, just build the IdentifierInfo
// and associate it with the persistent ID.
IdentifierInfo *II = KnownII;
if (!II) {
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
II = &Reader.getIdentifierTable().getOwn(k);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
KnownII = II;
}
Reader.SetIdentifierInfo(ID, II);
[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
if (!II->isFromAST()) {
bool WasInteresting = isInterestingIdentifier(*II);
II->setIsFromAST();
if (WasInteresting)
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
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);
Revert changes from r170428, 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 CPlusPlusOperatorKeyword = Bits & 0x01;
Bits >>= 1;
bool HasRevertedTokenIDToIdentifier = Bits & 0x01;
Bits >>= 1;
bool Poisoned = Bits & 0x01;
Bits >>= 1;
bool ExtensionToken = Bits & 0x01;
Bits >>= 1;
bool hadMacroDefinition = Bits & 0x01;
Bits >>= 1;
assert(Bits == 0 && "Extra bits in the identifier?");
DataLen -= 8;
// Build the IdentifierInfo itself and link the identifier ID with
// the new IdentifierInfo.
IdentifierInfo *II = KnownII;
if (!II) {
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
II = &Reader.getIdentifierTable().getOwn(StringRef(k));
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
KnownII = II;
}
Reader.markIdentifierUpToDate(II);
[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
if (!II->isFromAST()) {
bool WasInteresting = isInterestingIdentifier(*II);
II->setIsFromAST();
if (WasInteresting)
II->setChangedSinceDeserialization();
}
Revert changes from r170428, 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 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)
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
II->RevertTokenIDToIdentifier();
II->setObjCOrBuiltinID(ObjCOrBuiltinID);
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.
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;
}
unsigned
ASTDeclContextNameLookupTrait::ComputeHash(const DeclNameKey &Key) const {
llvm::FoldingSetNodeID ID;
ID.AddInteger(Key.Kind);
switch (Key.Kind) {
case DeclarationName::Identifier:
case DeclarationName::CXXLiteralOperatorName:
ID.AddString(((IdentifierInfo*)Key.Data)->getName());
break;
case DeclarationName::ObjCZeroArgSelector:
case DeclarationName::ObjCOneArgSelector:
case DeclarationName::ObjCMultiArgSelector:
ID.AddInteger(serialization::ComputeHash(Selector(Key.Data)));
break;
case DeclarationName::CXXOperatorName:
ID.AddInteger((OverloadedOperatorKind)Key.Data);
break;
case DeclarationName::CXXConstructorName:
case DeclarationName::CXXDestructorName:
case DeclarationName::CXXConversionFunctionName:
case DeclarationName::CXXUsingDirective:
break;
}
return ID.ComputeHash();
}
ASTDeclContextNameLookupTrait::internal_key_type
ASTDeclContextNameLookupTrait::GetInternalKey(
const external_key_type& Name) const {
DeclNameKey Key;
Key.Kind = Name.getNameKind();
switch (Name.getNameKind()) {
case DeclarationName::Identifier:
Key.Data = (uint64_t)Name.getAsIdentifierInfo();
break;
case DeclarationName::ObjCZeroArgSelector:
case DeclarationName::ObjCOneArgSelector:
case DeclarationName::ObjCMultiArgSelector:
Key.Data = (uint64_t)Name.getObjCSelector().getAsOpaquePtr();
break;
case DeclarationName::CXXOperatorName:
Key.Data = Name.getCXXOverloadedOperator();
break;
case DeclarationName::CXXLiteralOperatorName:
Key.Data = (uint64_t)Name.getCXXLiteralIdentifier();
break;
case DeclarationName::CXXConstructorName:
case DeclarationName::CXXDestructorName:
case DeclarationName::CXXConversionFunctionName:
case DeclarationName::CXXUsingDirective:
Key.Data = 0;
break;
}
return Key;
}
std::pair<unsigned, unsigned>
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);
}
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
DeclNameKey Key;
Key.Kind = (DeclarationName::NameKind)*d++;
switch (Key.Kind) {
case DeclarationName::Identifier:
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
Key.Data = (uint64_t)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
break;
case DeclarationName::ObjCZeroArgSelector:
case DeclarationName::ObjCOneArgSelector:
case DeclarationName::ObjCMultiArgSelector:
Key.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:
Key.Data = *d++; // OverloadedOperatorKind
break;
case DeclarationName::CXXLiteralOperatorName:
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
Key.Data = (uint64_t)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
break;
case DeclarationName::CXXConstructorName:
case DeclarationName::CXXDestructorName:
case DeclarationName::CXXConversionFunctionName:
case DeclarationName::CXXUsingDirective:
Key.Data = 0;
break;
}
return Key;
}
ASTDeclContextNameLookupTrait::data_type
ASTDeclContextNameLookupTrait::ReadData(internal_key_type,
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 NumDecls = endian::readNext<uint16_t, little, unaligned>(d);
[PCH] Make the const_cast explicit to silence a compiler warning. Patch by David Greene. llvm-svn: 172262
2013-01-12 06:29:49 +08:00
LE32DeclID *Start = reinterpret_cast<LE32DeclID *>(
const_cast<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
return std::make_pair(Start, Start + NumDecls);
}
bool ASTReader::ReadDeclContextStorage(ModuleFile &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 &Cursor,
Revert changes from r170428, 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::pair<uint64_t, uint64_t> &Offsets,
DeclContextInfo &Info) {
SavedStreamPosition SavedPosition(Cursor);
// First the lexical decls.
if (Offsets.first != 0) {
Cursor.JumpToBit(Offsets.first);
RecordData Record;
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
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, &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 != DECL_CONTEXT_LEXICAL) {
Error("Expected lexical block");
return true;
}
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
Info.LexicalDecls = reinterpret_cast<const KindDeclIDPair*>(Blob.data());
Info.NumLexicalDecls = Blob.size() / sizeof(KindDeclIDPair);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
}
// Now the lookup table.
if (Offsets.second != 0) {
Cursor.JumpToBit(Offsets.second);
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;
Revert changes from r170428, 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 = 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, &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 != DECL_CONTEXT_VISIBLE) {
Error("Expected visible lookup table block");
return true;
}
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
Info.NameLookupTableData = ASTDeclContextNameLookupTable::Create(
(const unsigned char *)Blob.data() + Record[0],
(const unsigned char *)Blob.data() + sizeof(uint32_t),
(const unsigned char *)Blob.data(),
ASTDeclContextNameLookupTrait(*this, 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
}
return false;
}
void ASTReader::Error(StringRef Msg) {
Error(diag::err_fe_pch_malformed, Msg);
[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
if (Context.getLangOpts().Modules && !Diags.isDiagnosticInFlight()) {
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;
for (int I = 0, N = Record[Idx++]; I != N; ++I) {
// 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);
}
// 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++];
assert(NumEntries && "Numentries is 00000");
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 &&
ContentCache->ContentsEntry == ContentCache->OrigEntry) {
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.
assert(!SourceMgr.getMainFileID().isInvalid() && "missing main file");
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) {
Revert changes from r170428, 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 (Cursor.EnterSubBlock(BlockID)) {
Error("malformed block record in AST file");
return Failure;
}
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();
MI->setArgumentList(MacroArgs.data(), MacroArgs.size(),
PP.getPreprocessorAllocator());
}
// 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) {
internal_key_type ikey = { FE->getSize(), FE->getModificationTime(),
[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
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) {
if (a.Size != b.Size || 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++;
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
HFI.HeaderRole = static_cast<ModuleMap::ModuleHeaderRole>
((Flags >> 6) & 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.isImport = (Flags >> 5) & 0x01;
HFI.isPragmaOnce = (Flags >> 4) & 0x01;
HFI.DirInfo = (Flags >> 2) & 0x03;
HFI.Resolved = (Flags >> 1) & 0x01;
HFI.IndexHeaderMapHeader = Flags & 0x01;
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.NumIncludes = endian::readNext<uint16_t, little, unaligned>(d);
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] 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
if (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] 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
if (LocalSMID) {
// 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);
HFI.isModuleHeader = true;
FileManager &FileMgr = Reader.getFileManager();
ModuleMap &ModMap =
Reader.getPreprocessor().getHeaderSearchInfo().getModuleMap();
[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
// FIXME: This information should be propagated through the
// SUBMODULE_HEADER etc records rather than from here.
[modules] Track how 'header' directives were written in module map files, rather than trying to extract this information from the FileEntry after the fact. This has a number of beneficial effects. For instance, diagnostic messages for failed module builds give a path relative to the "module root" rather than an absolute file path, and the contents of the module includes file is no longer dependent on what files the including TU happened to inspect prior to triggering the module build. llvm-svn: 223095
2014-12-02 08:08:08 +08:00
// FIXME: We don't ever mark excluded headers.
[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 = key.Filename;
if (key.Imported)
Reader.ResolveImportedPath(M, Filename);
Module::Header H = { key.Filename, FileMgr.getFile(Filename) };
Try to fix the MSVC build. llvm-svn: 223105
2014-12-02 10:13:09 +08:00
ModMap.addHeader(Mod, H, HFI.getHeaderRole());
[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
assert(End == d && "Wrong data length in HeaderFileInfo deserialization");
(void)End;
// This HeaderFileInfo was externally loaded.
HFI.External = true;
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);
for (ModuleReverseIterator I = ModuleMgr.rbegin(),
E = ModuleMgr.rend(); I != E; ++I) {
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 &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;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
Cursor.JumpToBit((*I)->MacroStartOffset);
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:
getLocalIdentifier(**I, Record[0]);
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;
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)
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
: Name(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()
{
}
Revert changes from r170428, 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 bool visit(ModuleFile &M, void *UserData) {
IdentifierLookupVisitor *This
= static_cast<IdentifierLookupVisitor *>(UserData);
// If we've already searched this module file, skip it now.
if (M.Generation <= This->PriorGeneration)
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;
ASTIdentifierLookupTrait Trait(IdTable->getInfoObj().getReader(),
M, This->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
++This->NumIdentifierLookups;
ASTIdentifierLookupTable::iterator Pos = IdTable->find(This->Name,&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.
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
++This->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
This->Found = *Pos;
return true;
}
// \brief Retrieve the identifier info found within the module
// files.
IdentifierInfo *getIdentifierInfo() const { return Found; }
};
}
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);
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.visit(IdentifierLookupVisitor::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;
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
std::string Filename;
off_t StoredSize;
time_t StoredTime;
bool Overridden;
[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
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
assert(Record[0] == ID && "Bogus stored ID or offset");
StoredSize = static_cast<off_t>(Record[1]);
StoredTime = static_cast<time_t>(Record[2]);
Overridden = static_cast<bool>(Record[3]);
Filename = 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
ResolveImportedPath(F, Filename);
Fix VS2012 build after r203881 llvm-svn: 203951
2014-03-15 01:45:06 +08:00
InputFileInfo R = { std::move(Filename), StoredSize, StoredTime, Overridden };
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
}
std::string ASTReader::getInputFileName(ModuleFile &F, unsigned int ID) {
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
return readInputFileInfo(F, ID).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
}
[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;
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
const FileEntry *File
= Overridden? FileMgr.getVirtualFile(Filename, StoredSize, StoredTime)
: FileMgr.getFile(Filename, /*OpenFile=*/false);
// 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.
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
if (Overridden && 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;
ErrorStr += "' referenced by AST file";
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();
if (!Overridden && SM.isFileOverridden(File)) {
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.
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
//
// This also happens in networked file systems, so disable this
// check if validation is disabled or if we have an explicitly
// built PCM file.
//
// FIXME: Should we also do this for PCH files? They could also
// reasonably get shared across a network during a distributed build.
(StoredTime != File->getModificationTime() && !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
#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
}
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
InputFile IF = InputFile(File, Overridden, IsOutOfDate);
// 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
}
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;
Revert changes from r170428, 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;
}
[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
// 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 too.
bool AllowCompatibleConfigurationMismatch = 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
// 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
// system input files reside at [NumUserInputs, NumInputs).
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
if (!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
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)
Listener->visitModuleFile(F.FileName);
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);
Listener->visitInputFile(FI.Filename, IsSystem, FI.Overridden);
}
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
}
Revert changes from r170428, 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 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;
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;
}
bool hasErrors = Record[5];
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
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
// Load the AST file.
switch(ReadASTCore(ImportedFile, ImportedKind, ImportLoc, &F, 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
StoredSize, StoredModTime, StoredSignature,
Revert changes from r170428, 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: 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;
}
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
case KNOWN_MODULE_FILES:
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 LANGUAGE_OPTIONS: {
bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch) == 0;
[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
// FIXME: The &F == *ModuleMgr.begin() check is wrong for modules.
Revert changes from r170428, 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 (Listener && &F == *ModuleMgr.begin() &&
[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
ParseLanguageOptions(Record, Complain, *Listener,
AllowCompatibleConfigurationMismatch) &&
Add a CC1 option -verify-pch This option will: - load the given pch file - verify it is not out of date by stat'ing dependencies, and - return 0 on success and non-zero on error llvm-svn: 200884
2014-02-06 06:21:15 +08:00
!DisableValidation && !AllowConfigurationMismatch)
Revert changes from r170428, 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 ConfigurationMismatch;
break;
}
case TARGET_OPTIONS: {
bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch)==0;
if (Listener && &F == *ModuleMgr.begin() &&
[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
ParseTargetOptions(Record, Complain, *Listener,
AllowCompatibleConfigurationMismatch) &&
Add a CC1 option -verify-pch This option will: - load the given pch file - verify it is not out of date by stat'ing dependencies, and - return 0 on success and non-zero on error llvm-svn: 200884
2014-02-06 06:21:15 +08:00
!DisableValidation && !AllowConfigurationMismatch)
Revert changes from r170428, 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 ConfigurationMismatch;
break;
}
case DIAGNOSTIC_OPTIONS: {
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
bool Complain = (ClientLoadCapabilities & ARR_OutOfDate)==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
if (Listener && &F == *ModuleMgr.begin() &&
[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
!AllowCompatibleConfigurationMismatch &&
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
ParseDiagnosticOptions(Record, Complain, *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
!DisableValidation)
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 FILE_SYSTEM_OPTIONS: {
bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch)==0;
if (Listener && &F == *ModuleMgr.begin() &&
[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
!AllowCompatibleConfigurationMismatch &&
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
ParseFileSystemOptions(Record, Complain, *Listener) &&
Add a CC1 option -verify-pch This option will: - load the given pch file - verify it is not out of date by stat'ing dependencies, and - return 0 on success and non-zero on error llvm-svn: 200884
2014-02-06 06:21:15 +08:00
!DisableValidation && !AllowConfigurationMismatch)
Revert changes from r170428, 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 ConfigurationMismatch;
break;
}
case HEADER_SEARCH_OPTIONS: {
bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch)==0;
if (Listener && &F == *ModuleMgr.begin() &&
[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
!AllowCompatibleConfigurationMismatch &&
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
ParseHeaderSearchOptions(Record, Complain, *Listener) &&
Add a CC1 option -verify-pch This option will: - load the given pch file - verify it is not out of date by stat'ing dependencies, and - return 0 on success and non-zero on error llvm-svn: 200884
2014-02-06 06:21:15 +08:00
!DisableValidation && !AllowConfigurationMismatch)
Revert changes from r170428, 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 ConfigurationMismatch;
break;
}
case PREPROCESSOR_OPTIONS: {
bool Complain = (ClientLoadCapabilities & ARR_ConfigurationMismatch)==0;
if (Listener && &F == *ModuleMgr.begin() &&
[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
!AllowCompatibleConfigurationMismatch &&
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
ParsePreprocessorOptions(Record, Complain, *Listener,
SuggestedPredefines) &&
Add a CC1 option -verify-pch This option will: - load the given pch file - verify it is not out of date by stat'ing dependencies, and - return 0 on success and non-zero on error llvm-svn: 200884
2014-02-06 06:21:15 +08:00
!DisableValidation && !AllowConfigurationMismatch)
Revert changes from r170428, 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 ConfigurationMismatch;
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 changes from r170428, 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_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];
[modules] Improve llvm-bcanalyzer output on AST files a little. No functionality change. llvm-svn: 229145
2015-02-14 03:48:37 +08:00
F.InputFileOffsets = (const 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();
DeclContextInfo &Info = F.DeclContextInfos[TU];
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
Info.LexicalDecls = reinterpret_cast<const KindDeclIDPair *>(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
Info.NumLexicalDecls
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
= static_cast<unsigned int>(Blob.size() / sizeof(KindDeclIDPair));
Revert changes from r170428, 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);
ASTDeclContextNameLookupTable *Table =
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
ASTDeclContextNameLookupTable::Create(
(const unsigned char *)Blob.data() + Record[Idx++],
(const unsigned char *)Blob.data() + sizeof(uint32_t),
(const unsigned char *)Blob.data(),
ASTDeclContextNameLookupTrait(*this, F));
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
if (Decl *D = GetExistingDecl(ID)) {
If a visibility update record is found for a DeclContext after that Decl has already been loaded, apply that update record to the Decl immediately, rather than adding it to a pending list and never applying it. llvm-svn: 203534
2014-03-11 11:10:46 +08:00
auto *DC = cast<DeclContext>(D);
DC->getPrimaryContext()->setHasExternalVisibleStorage(true);
Revert C++11ification in r203534 and r203536. Apparently our toolchains aren't ready for this yet. llvm-svn: 203548
2014-03-11 15:17:35 +08:00
auto *&LookupTable = F.DeclContextInfos[DC].NameLookupTableData;
delete LookupTable;
LookupTable = Table;
Revert changes from r170428, 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
PendingVisibleUpdates[ID].push_back(std::make_pair(Table, &F));
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;
}
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);
// 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
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 LOCAL_REDECLARATIONS: {
F.RedeclarationChains.swap(Record);
break;
}
case LOCAL_REDECLARATIONS_MAP: {
if (F.LocalNumRedeclarationsInMap != 0) {
Error("duplicate LOCAL_REDECLARATIONS_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.LocalNumRedeclarationsInMap = 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.RedeclarationsMap = (const LocalRedeclarationsInfo *)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 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");
if ((ClientLoadCapabilities & ARR_Missing) == 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
Diag(diag::err_imported_module_not_found) << F.ModuleName << F.FileName
<< ImportedBy->FileName
<< F.ModuleMapPath;
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
return 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
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";
}
Revert changes from r170428, 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
// 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);
}
}
<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());
}
// 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 (IdentifierTable::iterator Id = PP.getIdentifierTable().begin(),
IdEnd = PP.getIdentifierTable().end();
Id != IdEnd; ++Id)
Id->second->setOutOfDate(true);
// 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();
if (!PrimaryModule.OriginalSourceFileID.isInvalid()) {
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';
}
Revert changes from r170428, 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.
{
std::string Msg = "Unable to load module \"" + FileName.str() + "\": "
+ ErrorStr;
Error(Msg);
}
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.
{
std::string Msg = "Unable to load module \"" + FileName.str() + "\": "
+ ErrorStr;
Error(Msg);
}
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;
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)) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
Diag(diag::err_not_a_pch_file) << FileName;
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::EndBlock:
case 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("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
}
// We only know the control subblock ID.
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 llvm::bitc::BLOCKINFO_BLOCK_ID:
if (Stream.ReadBlockInfoBlock()) {
Error("malformed BlockInfoBlock in AST file");
return Failure;
}
break;
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:
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;
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;
}
}
return Success;
}
[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
}
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
/// \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) {
finish converting the normal cases in ASTReader to use the new BitstreamCursor APIs. llvm-svn: 172937
2013-01-20 08:56:42 +08:00
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:
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 (Entry.ID == BlockID) {
if (Cursor.EnterSubBlock(BlockID))
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;
// Found it!
return false;
}
if (Cursor.SkipBlock())
return true;
}
}
}
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.
std::string ASTReader::getOriginalSourceFile(const std::string &ASTFileName,
FileManager &FileMgr,
DiagnosticsEngine &Diags) {
// 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;
Revert "Wrap clang module files in a Mach-O, ELF, or COFF container." llvm-svn: 230454
2015-02-25 10:44:04 +08:00
StreamFile.init((const unsigned char *)(*Buffer)->getBufferStart(),
(const unsigned char *)(*Buffer)->getBufferEnd());
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
}
};
}
bool ASTReader::readASTFileControlBlock(StringRef Filename,
FileManager &FileMgr,
ASTReaderListener &Listener) {
// 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;
Revert "Wrap clang module files in a Mach-O, ELF, or COFF container." llvm-svn: 230454
2015-02-25 10:44:04 +08:00
StreamFile.init((const unsigned char *)(*Buffer)->getBufferStart(),
(const unsigned char *)(*Buffer)->getBufferEnd());
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;
if (NeedsInputFiles) {
InputFilesCursor = Stream;
if (SkipCursorToBlock(InputFilesCursor, INPUT_FILES_BLOCK_ID))
return true;
// Read the abbreviations
while (true) {
uint64_t Offset = InputFilesCursor.GetCurrentBitNo();
unsigned Code = InputFilesCursor.ReadCode();
// We expect all abbrevs to be at the start of the block.
if (Code != llvm::bitc::DEFINE_ABBREV) {
InputFilesCursor.JumpToBit(Offset);
break;
}
InputFilesCursor.ReadAbbrevRecord();
}
}
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.
Revert changes from r170428, 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;
[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 ModuleDir;
finish converting the normal cases in ASTReader to use the new BitstreamCursor APIs. llvm-svn: 172937
2013-01-20 08:56:42 +08:00
while (1) {
llvm::BitstreamEntry Entry = Stream.advanceSkippingSubblocks();
if (Entry.Kind == llvm::BitstreamEntry::EndBlock)
return false;
if (Entry.Kind != llvm::BitstreamEntry::Record)
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
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
}
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 LANGUAGE_OPTIONS:
[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
if (ParseLanguageOptions(Record, false, Listener,
/*AllowCompatibleConfigurationMismatch*/false))
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;
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
case TARGET_OPTIONS:
[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 (ParseTargetOptions(Record, false, Listener,
/*AllowCompatibleConfigurationMismatch*/ false))
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;
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
case DIAGNOSTIC_OPTIONS:
if (ParseDiagnosticOptions(Record, false, Listener))
return true;
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
case FILE_SYSTEM_OPTIONS:
if (ParseFileSystemOptions(Record, false, Listener))
return true;
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
case HEADER_SEARCH_OPTIONS:
if (ParseHeaderSearchOptions(Record, false, Listener))
return true;
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
case PREPROCESSOR_OPTIONS: {
std::string IgnoredSuggestedPredefines;
if (ParsePreprocessorOptions(Record, false, Listener,
IgnoredSuggestedPredefines))
return true;
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
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);
shouldContinue =
Listener.visitInputFile(Filename, isSystemFile, Overridden);
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);
[modules] Load .pcm files specified by -fmodule-file lazily. llvm-svn: 220731
2014-10-28 07:01:16 +08:00
}
break;
}
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
case KNOWN_MODULE_FILES: {
// Known-but-not-technically-used module files are treated as imports.
if (!NeedsImports)
break;
unsigned Idx = 0, N = Record.size();
while (Idx < N) {
std::string Filename = ReadString(Record, Idx);
ResolveImportedPath(Filename, ModuleDir);
Listener.visitImport(Filename);
}
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
}
}
}
bool ASTReader::isAcceptableASTFile(StringRef Filename,
FileManager &FileMgr,
const LangOptions &LangOpts,
const TargetOptions &TargetOpts,
[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 PreprocessorOptions &PPOpts,
std::string ExistingModuleCachePath) {
SimplePCHValidator validator(LangOpts, TargetOpts, PPOpts,
ExistingModuleCachePath, FileMgr);
Revert changes from r170428, 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 !readASTFileControlBlock(Filename, FileMgr, validator);
}
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
Revert changes from r170428, 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
ObjCRuntime::Kind runtimeKind = (ObjCRuntime::Kind) Record[Idx++];
VersionTuple runtimeVersion = ReadVersionTuple(Record, Idx);
LangOpts.ObjCRuntime = ObjCRuntime(runtimeKind, runtimeVersion);
unsigned Length = Record[Idx++];
LangOpts.CurrentModule.assign(Record.begin() + Idx,
Record.begin() + Idx + Length);
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
Idx += Length;
// 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
[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);
}
};
}
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) { }
Revert changes from r170428, 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 bool visit(ModuleFile &M, void *UserData) {
HeaderFileInfoVisitor *This
= static_cast<HeaderFileInfoVisitor *>(UserData);
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.
[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
HeaderFileInfoLookupTable::iterator Pos = Table->find(This->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;
This->HFI = *Pos;
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
};
}
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);
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
ModuleMgr.visit(&HeaderFileInfoVisitor::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);
bool IsDecltypeAuto = 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;
Revert "Implement a rudimentary form of generic lambdas." This reverts commit 606f5d7a99b11957e057e4cd1f55f931f66a42c7. llvm-svn: 189004
2013-08-22 20:12:24 +08:00
return Context.getAutoType(Deduced, IsDecltypeAuto, 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);
unsigned NumProtos = Record[Idx++];
SmallVector<ObjCProtocolDecl*, 4> Protos;
for (unsigned I = 0; I != NumProtos; ++I)
Protos.push_back(ReadDeclAs<ObjCProtocolDecl>(*Loc.F, Record, Idx));
return Context.getObjCObjectType(Base, Protos.data(), NumProtos);
}
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);
const IdentifierInfo *Name = this->GetIdentifierInfo(*Loc.F, Record, Idx);
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);
const IdentifierInfo *Name = this->GetIdentifierInfo(*Loc.F, Record, Idx);
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);
}
}
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++]);
TL.setLAngleLoc(ReadSourceLocation(Record, Idx));
TL.setRAngleLoc(ReadSourceLocation(Record, Idx));
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));
}
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) {
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;
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;
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;
Re-commit r170428 changes with Linux style file endings. Add OpenCL images as clang builtin types. llvm-svn: 170432
2012-12-18 22:38:23 +08:00
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;
case PREDEF_TYPE_IMAGE3D_ID: T = Context.OCLImage3dTy; break;
Add OpenCL samplers as Clang builtin types and check sampler related restrictions. llvm-svn: 174601
2013-02-07 18:55:47 +08:00
case PREDEF_TYPE_SAMPLER_ID: T = Context.OCLSamplerTy; break;
Implement OpenCL event_t as Clang builtin type, including event_t related OpenCL restrictions (OpenCL 1.2 spec 6.9) llvm-svn: 172973
2013-01-20 20:31:11 +08:00
case PREDEF_TYPE_EVENT_ID: T = Context.OCLEventTy; 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_AUTO_DEDUCT: T = Context.getAutoDeductType(); break;
case PREDEF_TYPE_AUTO_RREF_DEDUCT:
T = Context.getAutoRRefDeductType();
break;
case PREDEF_TYPE_ARC_UNBRIDGED_CAST:
T = Context.ARCUnbridgedCastTy;
break;
case PREDEF_TYPE_VA_LIST_TAG:
T = Context.getVaListTagType();
break;
case PREDEF_TYPE_BUILTIN_FN:
T = Context.BuiltinFnTy;
break;
}
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()) {
auto *II = Name.getAsIdentifierInfo();
if (isa<TranslationUnitDecl>(DC) && II) {
// Outside of C++, we don't have a lookup table for the TU, so update
// the identifier instead. In C++, either way should work fine.
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))) {
// FIXME: It'd be nice to do something a bit more targeted here.
D->getDeclContext()->decls_begin();
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;
Revert changes from r170428, 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(ID);
assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
return &M == I->second;
}
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
case PREDEF_DECL_EXTERN_C_CONTEXT_ID:
return Context.getExternCContextDecl();
[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.
auto &Merged = MergedDecls[D->getCanonicalDecl()];
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);
}
namespace {
class FindExternalLexicalDeclsVisitor {
ASTReader &Reader;
const DeclContext *DC;
bool (*isKindWeWant)(Decl::Kind);
SmallVectorImpl<Decl*> &Decls;
bool PredefsVisited[NUM_PREDEF_DECL_IDS];
public:
FindExternalLexicalDeclsVisitor(ASTReader &Reader, const DeclContext *DC,
bool (*isKindWeWant)(Decl::Kind),
SmallVectorImpl<Decl*> &Decls)
: Reader(Reader), DC(DC), isKindWeWant(isKindWeWant), Decls(Decls)
{
for (unsigned I = 0; I != NUM_PREDEF_DECL_IDS; ++I)
PredefsVisited[I] = false;
}
Allow skipping imports in the module visitor. Skip imports when we know that we do not need to visit any imports because we've already deserialized the redecls from a module. llvm-svn: 237782
2015-05-20 18:29:23 +08:00
static bool visitPostorder(ModuleFile &M, void *UserData) {
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
FindExternalLexicalDeclsVisitor *This
= static_cast<FindExternalLexicalDeclsVisitor *>(UserData);
ModuleFile::DeclContextInfosMap::iterator Info
= M.DeclContextInfos.find(This->DC);
if (Info == M.DeclContextInfos.end() || !Info->second.LexicalDecls)
return false;
// Load all of the declaration IDs
for (const KindDeclIDPair *ID = Info->second.LexicalDecls,
*IDE = ID + Info->second.NumLexicalDecls;
ID != IDE; ++ID) {
if (This->isKindWeWant && !This->isKindWeWant((Decl::Kind)ID->first))
continue;
// Don't add predefined declarations to the lexical context more
// than once.
if (ID->second < NUM_PREDEF_DECL_IDS) {
if (This->PredefsVisited[ID->second])
continue;
This->PredefsVisited[ID->second] = true;
}
if (Decl *D = This->Reader.GetLocalDecl(M, ID->second)) {
if (!This->DC->isDeclInLexicalTraversal(D))
This->Decls.push_back(D);
}
}
return false;
}
};
}
ExternalLoadResult ASTReader::FindExternalLexicalDecls(const DeclContext *DC,
bool (*isKindWeWant)(Decl::Kind),
SmallVectorImpl<Decl*> &Decls) {
// There might be lexical decls in multiple modules, for the TU at
// least. Walk all of the modules in the order they were loaded.
FindExternalLexicalDeclsVisitor Visitor(*this, DC, isKindWeWant, Decls);
Allow skipping imports in the module visitor. Skip imports when we know that we do not need to visit any imports because we've already deserialized the redecls from a module. llvm-svn: 237782
2015-05-20 18:29:23 +08:00
ModuleMgr.visitDepthFirst(
nullptr, &FindExternalLexicalDeclsVisitor::visitPostorder, &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
++NumLexicalDeclContextsRead;
return ELR_Success;
}
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)));
}
};
}
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)));
}
namespace {
/// \brief ModuleFile visitor used to perform name lookup into a
/// declaration context.
class DeclContextNameLookupVisitor {
ASTReader &Reader;
[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
ArrayRef<const DeclContext *> Contexts;
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
DeclarationName Name;
SmallVectorImpl<NamedDecl *> &Decls;
[modules] Don't produce duplicate lookup results if the same declaration is visible through multiple imported modules. No functionality change. llvm-svn: 229147
2015-02-14 04:17:14 +08:00
llvm::SmallPtrSetImpl<NamedDecl *> &DeclSet;
Revert changes from r170428, 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:
[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
DeclContextNameLookupVisitor(ASTReader &Reader,
ArrayRef<const DeclContext *> Contexts,
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
DeclarationName Name,
[modules] Don't produce duplicate lookup results if the same declaration is visible through multiple imported modules. No functionality change. llvm-svn: 229147
2015-02-14 04:17:14 +08:00
SmallVectorImpl<NamedDecl *> &Decls,
llvm::SmallPtrSetImpl<NamedDecl *> &DeclSet)
: Reader(Reader), Contexts(Contexts), Name(Name), Decls(Decls),
DeclSet(DeclSet) { }
Revert changes from r170428, 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 bool visit(ModuleFile &M, void *UserData) {
DeclContextNameLookupVisitor *This
= static_cast<DeclContextNameLookupVisitor *>(UserData);
// Check whether we have any visible declaration information for
// this context in this module.
ModuleFile::DeclContextInfosMap::iterator Info;
bool FoundInfo = 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
for (auto *DC : This->Contexts) {
Info = M.DeclContextInfos.find(DC);
if (Info != M.DeclContextInfos.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
Info->second.NameLookupTableData) {
FoundInfo = true;
break;
}
}
if (!FoundInfo)
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
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
// Look for this name within this module.
Revert C++11ification in r203534 and r203536. Apparently our toolchains aren't ready for this yet. llvm-svn: 203548
2014-03-11 15:17:35 +08:00
ASTDeclContextNameLookupTable *LookupTable =
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
Info->second.NameLookupTableData;
ASTDeclContextNameLookupTable::iterator Pos
= LookupTable->find(This->Name);
if (Pos == LookupTable->end())
return false;
bool FoundAnything = false;
ASTDeclContextNameLookupTrait::data_type Data = *Pos;
for (; Data.first != Data.second; ++Data.first) {
NamedDecl *ND = This->Reader.GetLocalDeclAs<NamedDecl>(M, *Data.first);
if (!ND)
continue;
if (ND->getDeclName() != This->Name) {
// A name might be null because the decl's redeclarable part is
// currently read before reading its name. The lookup is triggered by
// building that decl (likely indirectly), and so it is later in the
// sense of "already existing" and can be ignored here.
[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
// FIXME: This should not happen; deserializing declarations should
// not perform lookups since that can lead to deserialization cycles.
Revert changes from r170428, 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] 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
// Record this declaration.
FoundAnything = true;
[modules] Don't produce duplicate lookup results if the same declaration is visible through multiple imported modules. No functionality change. llvm-svn: 229147
2015-02-14 04:17:14 +08:00
if (This->DeclSet.insert(ND).second)
This->Decls.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
}
return FoundAnything;
}
};
}
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
/// \brief Retrieve the "definitive" module file for the definition of the
/// given declaration context, if there is one.
///
/// The "definitive" module file is the only place where we need to look to
/// find information about the declarations within the given declaration
/// context. For example, C++ and Objective-C classes, C structs/unions, and
/// Objective-C protocols, categories, and extensions are all defined in a
/// single place in the source code, so they have definitive module files
/// associated with them. C++ namespaces, on the other hand, can have
/// definitions in multiple different module files.
///
/// Note: this needs to be kept in sync with ASTWriter::AddedVisibleDecl's
/// NDEBUG checking.
static ModuleFile *getDefinitiveModuleFileFor(const DeclContext *DC,
ASTReader &Reader) {
Make getDefinitiveDeclContext() actually return a DeclContext, as one would expect, and clean up the return/break inconsistencies. Thanks, Sebastian! llvm-svn: 173171
2013-01-23 01:08:30 +08:00
if (const DeclContext *DefDC = getDefinitiveDeclContext(DC))
return Reader.getOwningModuleFile(cast<Decl>(DefDC));
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
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
return nullptr;
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
}
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) {
assert(DC->hasExternalVisibleStorage() &&
"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
[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);
Revert changes from r170428, 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;
[modules] Don't produce duplicate lookup results if the same declaration is visible through multiple imported modules. No functionality change. llvm-svn: 229147
2015-02-14 04:17:14 +08:00
llvm::SmallPtrSet<NamedDecl*, 64> DeclSet;
[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
// Compute the declaration contexts we need to look into. Multiple such
// declaration contexts occur when two declaration contexts from disjoint
// modules get merged, e.g., when two namespaces with the same name are
// independently defined in separate modules.
SmallVector<const DeclContext *, 2> Contexts;
Contexts.push_back(DC);
[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
if (DC->isNamespace()) {
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
auto Merged = MergedDecls.find(const_cast<Decl *>(cast<Decl>(DC)));
Revert changes from r170428, 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 (Merged != MergedDecls.end()) {
for (unsigned I = 0, N = Merged->second.size(); I != N; ++I)
Contexts.push_back(cast<DeclContext>(GetDecl(Merged->second[I])));
}
}
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] 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
auto LookUpInContexts = [&](ArrayRef<const DeclContext*> Contexts) {
[modules] Don't produce duplicate lookup results if the same declaration is visible through multiple imported modules. No functionality change. llvm-svn: 229147
2015-02-14 04:17:14 +08:00
DeclContextNameLookupVisitor Visitor(*this, Contexts, Name, Decls, DeclSet);
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
[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
// If we can definitively determine which module file to look into,
// only look there. Otherwise, look in all module files.
ModuleFile *Definitive;
if (Contexts.size() == 1 &&
(Definitive = getDefinitiveModuleFileFor(Contexts[0], *this))) {
DeclContextNameLookupVisitor::visit(*Definitive, &Visitor);
} else {
ModuleMgr.visit(&DeclContextNameLookupVisitor::visit, &Visitor);
}
};
LookUpInContexts(Contexts);
// If this might be an implicit special member function, then also search
// all merged definitions of the surrounding class. We need to search them
// individually, because finding an entity in one of them doesn't imply that
// we can't find a different entity in another one.
if (isa<CXXRecordDecl>(DC)) {
[modules] When merging class definitions, make the retained definition visible if the merged definition is visible, and perform lookups into all merged copies of the definition (not just for special members) so that we can complete the redecl chains for members of the class. llvm-svn: 233420
2015-03-28 05:16:39 +08:00
auto Merged = MergedLookups.find(DC);
if (Merged != MergedLookups.end()) {
for (unsigned I = 0; I != Merged->second.size(); ++I) {
const DeclContext *Context = Merged->second[I];
LookUpInContexts(Context);
// We might have just added some more merged lookups. If so, our
// iterator is now invalid, so grab a fresh one before continuing.
Merged = MergedLookups.find(DC);
PR21323: Fix iterator invalidation issue when looking for redeclarations of a special member function. No test yet: the only testcases we have for this issue are extremely complex. Testcase will be added once I get a reasonable reduction. llvm-svn: 222506
2014-11-21 13:16:13 +08:00
}
[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
}
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
}
[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
}
namespace {
/// \brief ModuleFile visitor used to retrieve all visible names in a
/// declaration context.
class DeclContextAllNamesVisitor {
ASTReader &Reader;
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<const DeclContext *> &Contexts;
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
DeclsMap &Decls;
[modules] Don't produce duplicate lookup results if the same declaration is visible through multiple imported modules. No functionality change. llvm-svn: 229147
2015-02-14 04:17:14 +08:00
llvm::SmallPtrSet<NamedDecl *, 256> DeclSet;
[PCH/Modules] In ASTReader::completeVisibleDeclsMap, make sure to visit all modules when getting the decls for a namespace or translation unit. Otherwise the code-completion results will not be complete. rdar://12889089 llvm-svn: 170596
2012-12-20 06:21:18 +08:00
bool VisitAll;
Revert changes from r170428, 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:
DeclContextAllNamesVisitor(ASTReader &Reader,
SmallVectorImpl<const DeclContext *> &Contexts,
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
DeclsMap &Decls, bool VisitAll)
[PCH/Modules] In ASTReader::completeVisibleDeclsMap, make sure to visit all modules when getting the decls for a namespace or translation unit. Otherwise the code-completion results will not be complete. rdar://12889089 llvm-svn: 170596
2012-12-20 06:21:18 +08:00
: Reader(Reader), Contexts(Contexts), Decls(Decls), VisitAll(VisitAll) { }
Revert changes from r170428, 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 bool visit(ModuleFile &M, void *UserData) {
DeclContextAllNamesVisitor *This
= static_cast<DeclContextAllNamesVisitor *>(UserData);
// Check whether we have any visible declaration information for
// this context in this module.
ModuleFile::DeclContextInfosMap::iterator Info;
bool FoundInfo = false;
for (unsigned I = 0, N = This->Contexts.size(); I != N; ++I) {
Info = M.DeclContextInfos.find(This->Contexts[I]);
if (Info != M.DeclContextInfos.end() &&
Info->second.NameLookupTableData) {
FoundInfo = true;
break;
}
}
if (!FoundInfo)
return false;
Revert C++11ification in r203534 and r203536. Apparently our toolchains aren't ready for this yet. llvm-svn: 203548
2014-03-11 15:17:35 +08:00
ASTDeclContextNameLookupTable *LookupTable =
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
Info->second.NameLookupTableData;
bool FoundAnything = false;
for (ASTDeclContextNameLookupTable::data_iterator
Implement the writer side of the global module index. The global module index is a "global" index for all of the module files within a particular subdirectory in the module cache, which keeps track of all of the "interesting" identifiers and selectors known in each of the module files. One can perform a fast lookup in the index to determine which module files will have more information about entities with a particular name/selector. This information can help eliminate redundant lookups into module files (a serious performance problem) and help with creating auto-import/auto-include Fix-Its. The global module index is created or updated at the end of a translation unit that has triggered a (re)build of a module by scraping all of the .pcm files out of the module cache subdirectory, so it catches everything. As with module rebuilds, we use the file system's atomicity to synchronize. llvm-svn: 173301
2013-01-24 06:38:11 +08:00
I = LookupTable->data_begin(), E = LookupTable->data_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
ASTDeclContextNameLookupTrait::data_type Data = *I;
for (; Data.first != Data.second; ++Data.first) {
NamedDecl *ND = This->Reader.GetLocalDeclAs<NamedDecl>(M,
*Data.first);
if (!ND)
continue;
// Record this declaration.
FoundAnything = true;
[modules] Don't produce duplicate lookup results if the same declaration is visible through multiple imported modules. No functionality change. llvm-svn: 229147
2015-02-14 04:17:14 +08:00
if (This->DeclSet.insert(ND).second)
This->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
}
}
[PCH/Modules] In ASTReader::completeVisibleDeclsMap, make sure to visit all modules when getting the decls for a namespace or translation unit. Otherwise the code-completion results will not be complete. rdar://12889089 llvm-svn: 170596
2012-12-20 06:21:18 +08:00
return FoundAnything && !This->VisitAll;
Revert changes from r170428, 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;
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
DeclsMap Decls;
Revert changes from r170428, 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 declaration contexts we need to look into. Multiple such
// declaration contexts occur when two declaration contexts from disjoint
// modules get merged, e.g., when two namespaces with the same name are
// independently defined in separate modules.
SmallVector<const DeclContext *, 2> Contexts;
Contexts.push_back(DC);
if (DC->isNamespace()) {
MergedDeclsMap::iterator Merged
= MergedDecls.find(const_cast<Decl *>(cast<Decl>(DC)));
if (Merged != MergedDecls.end()) {
for (unsigned I = 0, N = Merged->second.size(); I != N; ++I)
Contexts.push_back(cast<DeclContext>(GetDecl(Merged->second[I])));
}
}
[PCH/Modules] In ASTReader::completeVisibleDeclsMap, make sure to visit all modules when getting the decls for a namespace or translation unit. Otherwise the code-completion results will not be complete. rdar://12889089 llvm-svn: 170596
2012-12-20 06:21:18 +08:00
DeclContextAllNamesVisitor Visitor(*this, Contexts, Decls,
/*VisitAll=*/DC->isFileContext());
Revert changes from r170428, as I accidentally changed the line endings of these files to Windows style. llvm-svn: 170431
2012-12-18 22:30:41 +08:00
ModuleMgr.visit(&DeclContextAllNamesVisitor::visit, &Visitor);
++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);
}
/// \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";
}
}
void ASTReader::dump() {
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
}
IdentifierInfo* ASTReader::get(const char *NameStart, const char *NameEnd) {
// 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
StringRef Name(NameStart, NameEnd - NameStart);
// 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(Name, 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(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);
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.visit(IdentifierLookupVisitor::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
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
};
}
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
Revert changes from r170428, 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 bool visit(ModuleFile &M, void *UserData) {
ReadMethodPoolVisitor *This
= static_cast<ReadMethodPoolVisitor *>(UserData);
if (!M.SelectorLookupTable)
return false;
// If we've already searched this module file, skip it now.
if (M.Generation <= This->PriorGeneration)
return true;
Add some more ASTReader statistics for global method pool lookups. llvm-svn: 173702
2013-01-29 01:54:36 +08:00
++This->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;
ASTSelectorLookupTable::iterator Pos = PoolTable->find(This->Sel);
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
++This->Reader.NumMethodPoolTableHits;
Revert changes from r170428, 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->Reader.NumSelectorsRead;
// 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?
++This->Reader.NumMethodPoolEntriesRead;
ASTSelectorLookupTrait::data_type Data = *Pos;
if (This->Reader.DeserializationListener)
This->Reader.DeserializationListener->SelectorRead(Data.ID,
This->Sel);
This->InstanceMethods.append(Data.Instance.begin(), Data.Instance.end());
This->FactoryMethods.append(Data.Factory.begin(), Data.Factory.end());
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
This->InstanceBits = Data.InstanceBits;
This->FactoryBits = Data.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
This->InstanceHasMoreThanOneDecl = Data.InstanceHasMoreThanOneDecl;
This->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
};
} } // end namespace clang::serialization
/// \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);
ModuleMgr.visit(&ReadMethodPoolVisitor::visit, &Visitor);
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);
}
Revert changes from r170428, 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!");
}
TemplateArgument
ASTReader::ReadTemplateArgument(ModuleFile &F,
const RecordData &Record, unsigned &Idx) {
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);
return TemplateArgument(Args, NumArgs);
}
}
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,
Params.data(), Params.size(), RAngleLoc);
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,
unsigned &Idx) {
unsigned NumTemplateArgs = Record[Idx++];
TemplArgs.reserve(NumTemplateArgs);
while (NumTemplateArgs--)
TemplArgs.push_back(ReadTemplateArgument(F, Record, Idx));
}
/// \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
}
}
[ASTReader] Add a convenience function to retrieve all the input files of a module file. llvm-svn: 222224
2014-11-18 13:24:18 +08:00
void ASTReader::getInputFiles(ModuleFile &F,
SmallVectorImpl<serialization::InputFile> &Files) {
for (unsigned I = 0, E = F.InputFilesLoaded.size(); I != E; ++I) {
unsigned ID = I+1;
Files.push_back(getInputFile(F, ID));
}
}
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] 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
for (unsigned I = 0; I != PendingDeclChains.size(); ++I) {
PendingDeclChainsKnown.erase(PendingDeclChains[I]);
[modules] If we find more formerly-canonical declarations of an entity while building its redecl chains, make sure we pull in the redeclarations of those canonical declarations. It's pretty difficult to reach a situation where we can find more canonical declarations of an entity while building its redecl chains; I think the provided testcase (4 modules and 7 declarations) cannot be reduced further. llvm-svn: 232411
2015-03-17 04:54:07 +08:00
loadPendingDeclChain(PendingDeclChains[I]);
[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
}
assert(PendingDeclChainsKnown.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
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
// have been fully wired up.
[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
// FIXME: There seems to be no point in delaying this, it does not depend
// on the redecl chains having been wired up.
Revert changes from r170428, 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] 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] 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
DeclContext::lookup_result R = CanonDef->lookup(D->getDeclName());
[modules] Factor out ODR checking, to avoid unnecessary repeated work in finishPendingActions loop. llvm-svn: 214246
2014-07-30 07:23:27 +08:00
for (DeclContext::lookup_iterator I = R.begin(), E = R.end();
!Found && I != E; ++I) {
for (auto RI : (*I)->redecls()) {
if (RI->getLexicalDeclContext() == CanonDef) {
// This declaration is present in the canonical definition. If it's
// in the same redecl chain, it's the one we're looking for.
if (RI->getCanonicalDecl() == DCanon)
Found = true;
else
Candidates.push_back(cast<NamedDecl>(RI));
break;
}
}
}
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
}
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>();
SemaObj->UpdateExceptionSpec(Update.second,
FPT->getExtProtoInfo().ExceptionSpec);
}
[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] Factor out ODR checking, to avoid unnecessary repeated work in finishPendingActions loop. llvm-svn: 214246
2014-07-30 07:23:27 +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()) {
for (auto *ND : PendingFakeLookupResults[II])
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);
}
}
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
ASTReader::ASTReader(Preprocessor &PP, ASTContext &Context, StringRef isysroot,
bool DisableValidation, bool AllowASTWithCompilerErrors,
bool AllowConfigurationMismatch, bool ValidateSystemInputs,
Add a CC1 option -verify-pch This option will: - load the given pch file - verify it is not out of date by stat'ing dependencies, and - return 0 on success and non-zero on error llvm-svn: 200884
2014-02-06 06:21:15 +08:00
bool UseGlobalIndex)
[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()),
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
FileMgr(PP.getFileManager()), Diags(PP.getDiagnostics()),
SemaObj(nullptr), PP(PP), Context(Context), Consumer(nullptr),
ModuleMgr(PP.getFileManager()), 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),
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
CurrSwitchCaseStmts(&SwitchCaseStmts),
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
NumSLocEntriesRead(0), TotalNumSLocEntries(0), NumStatementsRead(0),
TotalNumStatements(0), NumMacrosRead(0), TotalNumMacros(0),
NumIdentifierLookups(0), NumIdentifierLookupHits(0), NumSelectorsRead(0),
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);
}
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
for (DeclContextVisibleUpdatesPending::iterator
I = PendingVisibleUpdates.begin(),
E = PendingVisibleUpdates.end();
I != E; ++I) {
for (DeclContextVisibleUpdates::iterator J = I->second.begin(),
F = I->second.end();
J != F; ++J)
delete J->first;
}
}