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

3234 lines
123 KiB
C++
Raw Normal View History

Rename the ASTReader implementation files. llvm-svn: 111473
2010-08-19 07:57:11 +08:00
//===--- ASTReaderDecl.cpp - Decl Deserialization ---------------*- C++ -*-===//
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
// This file implements the ASTReader::ReadDeclRecord method, which is the
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
// entrypoint for loading a decl.
//
//===----------------------------------------------------------------------===//
Sort all of Clang's files under 'lib', and fix up the broken headers uncovered. This required manually correcting all of the incorrect main-module headers I could find, and running the new llvm/utils/sort_includes.py script over the files. I also manually added quite a few missing headers that were uncovered by shuffling the order or moving headers up to be main-module-headers. llvm-svn: 169237
2012-12-04 17:13:33 +08:00
#include "clang/Serialization/ASTReader.h"
Put the mechanism in place to track modifications in an AST entity that were committed after its initial creation/deserialization and store the changes in a chained PCH. The idea is that the AST entities call methods on the ASTMutationListener to give notifications of changes; the PCHWriter implements the ASTMutationListener interface and stores the incremental changes of the updated entity. WIP llvm-svn: 117235
2010-10-25 01:26:36 +08:00
#include "ASTCommon.h"
Use forward declarations for ASTDeclContextNameLookupTable and add a missing delete. It would be nice to use OwningPtr here, but DeclContextInfo is stored in a DenseMap. llvm-svn: 154763
2012-04-15 20:36:49 +08:00
#include "ASTReaderInternals.h"
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
#include "clang/AST/ASTConsumer.h"
#include "clang/AST/ASTContext.h"
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
#include "clang/AST/DeclCXX.h"
Sort all of Clang's files under 'lib', and fix up the broken headers uncovered. This required manually correcting all of the incorrect main-module headers I could find, and running the new llvm/utils/sort_includes.py script over the files. I also manually added quite a few missing headers that were uncovered by shuffling the order or moving headers up to be main-module-headers. llvm-svn: 169237
2012-12-04 17:13:33 +08:00
#include "clang/AST/DeclGroup.h"
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
#include "clang/AST/DeclTemplate.h"
Sort all of Clang's files under 'lib', and fix up the broken headers uncovered. This required manually correcting all of the incorrect main-module headers I could find, and running the new llvm/utils/sort_includes.py script over the files. I also manually added quite a few missing headers that were uncovered by shuffling the order or moving headers up to be main-module-headers. llvm-svn: 169237
2012-12-04 17:13:33 +08:00
#include "clang/AST/DeclVisitor.h"
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
#include "clang/AST/Expr.h"
Sort all of Clang's files under 'lib', and fix up the broken headers uncovered. This required manually correcting all of the incorrect main-module headers I could find, and running the new llvm/utils/sort_includes.py script over the files. I also manually added quite a few missing headers that were uncovered by shuffling the order or moving headers up to be main-module-headers. llvm-svn: 169237
2012-12-04 17:13:33 +08:00
#include "clang/Sema/IdentifierResolver.h"
#include "clang/Sema/Sema.h"
#include "clang/Sema/SemaDiagnostic.h"
[PCH] Really, pinky swear, fix for PR12689 rdar://11353109 llvm-svn: 156145
2012-05-04 09:49:36 +08:00
#include "llvm/Support/SaveAndRestore.h"
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
using namespace clang;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
using namespace clang::serialization;
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
//===----------------------------------------------------------------------===//
// Declaration deserialization
//===----------------------------------------------------------------------===//
Support C++ friend declarations for PCH. This commit 'introduces' a slightly different way to restore the state of the AST object. It makes PCHDeclReader/PCHDeclWriter friends and gives them access to the private members of the object. The rationale is to avoid using/modifying the AST interfaces for PCH read/write so that to: -Avoid complications with objects that have side-effects during creation or when using some setters. -Not 'pollute' the AST interface with methods only used by the PCH reader/writer -Allow AST objects to be read-only. llvm-svn: 107219
2010-06-30 06:47:00 +08:00
namespace clang {
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
class ASTDeclReader : public DeclVisitor<ASTDeclReader, void> {
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
ASTReader &Reader;
Promote ModuleMap::Module to a namespace-scope class in the Basic library, since modules cut across all of the libraries. Rename serialization::Module to serialization::ModuleFile to side-step the annoying naming conflict. Prune a bunch of ModuleMap.h includes that are no longer needed (most files only needed the Module type). llvm-svn: 145538
2011-12-01 07:21:26 +08:00
ModuleFile &F;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
const DeclID ThisDeclID;
[PCH] Pull the location out of the serialized declarations and put it in the array of decl bit offsets. This allows us to easily get at the location of a decl without deserializing it. It increases size of Cocoa PCH by only 0.2%. llvm-svn: 143123
2011-10-28 02:47:35 +08:00
const unsigned RawLocation;
Minor refactoring; Pull reading/writing DefinitionData out into a function. llvm-svn: 117233
2010-10-25 01:26:27 +08:00
typedef ASTReader::RecordData RecordData;
const RecordData &Record;
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
unsigned &Idx;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
TypeID TypeIDForTypeDecl;
When we're deserializing a template parameter declaration, temporarily use the translation unit as its declaration context, then deserialize the actual lexical and semantic DeclContexts after the template parameter is complete. This avoids problems when the DeclContext itself (e.g., a class template) is dependent on the template parameter (e.g., for the injected-class-name). llvm-svn: 127056
2011-03-05 09:35:54 +08:00
When we load a function or method body from an AST file, we check whether that function/method already has a body (loaded from some other AST file), as introduced in r165137. Delay this check until after the redeclaration chains have been wired up. While I'm here, make the loading of method bodies lazy. llvm-svn: 165513
2012-10-10 01:21:28 +08:00
bool HasPendingBody;
Thread bitstream cursors all the way through the AST reading stuff. This way, reading a trivial 2-element chained file actually works. llvm-svn: 109191
2010-07-23 06:43:28 +08:00
uint64_t GetCurrentCursorOffset();
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
Minor refactoring; Pull reading/writing DefinitionData out into a function. llvm-svn: 117233
2010-10-25 01:26:27 +08:00
SourceLocation ReadSourceLocation(const RecordData &R, unsigned &I) {
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
return Reader.ReadSourceLocation(F, R, I);
}
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
Minor refactoring; Pull reading/writing DefinitionData out into a function. llvm-svn: 117233
2010-10-25 01:26:27 +08:00
SourceRange ReadSourceRange(const RecordData &R, unsigned &I) {
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
return Reader.ReadSourceRange(F, R, I);
}
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
Minor refactoring; Pull reading/writing DefinitionData out into a function. llvm-svn: 117233
2010-10-25 01:26:27 +08:00
TypeSourceInfo *GetTypeSourceInfo(const RecordData &R, unsigned &I) {
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
return Reader.GetTypeSourceInfo(F, R, I);
}
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
serialization::DeclID ReadDeclID(const RecordData &R, unsigned &I) {
return Reader.ReadDeclID(F, R, I);
}
Decl *ReadDecl(const RecordData &R, unsigned &I) {
return Reader.ReadDecl(F, R, I);
}
template<typename T>
T *ReadDeclAs(const RecordData &R, unsigned &I) {
return Reader.ReadDeclAs<T>(F, R, I);
}
Read/write to/from PCH DeclarationNameLocs, DeclarationNameInfos and QualifierInfos (rdar://8513756). llvm-svn: 116598
2010-10-16 02:21:24 +08:00
void ReadQualifierInfo(QualifierInfo &Info,
Minor refactoring; Pull reading/writing DefinitionData out into a function. llvm-svn: 117233
2010-10-25 01:26:27 +08:00
const RecordData &R, unsigned &I) {
Read/write to/from PCH DeclarationNameLocs, DeclarationNameInfos and QualifierInfos (rdar://8513756). llvm-svn: 116598
2010-10-16 02:21:24 +08:00
Reader.ReadQualifierInfo(F, Info, R, I);
}
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
Read/write to/from PCH DeclarationNameLocs, DeclarationNameInfos and QualifierInfos (rdar://8513756). llvm-svn: 116598
2010-10-16 02:21:24 +08:00
void ReadDeclarationNameLoc(DeclarationNameLoc &DNLoc, DeclarationName Name,
Minor refactoring; Pull reading/writing DefinitionData out into a function. llvm-svn: 117233
2010-10-25 01:26:27 +08:00
const RecordData &R, unsigned &I) {
Read/write to/from PCH DeclarationNameLocs, DeclarationNameInfos and QualifierInfos (rdar://8513756). llvm-svn: 116598
2010-10-16 02:21:24 +08:00
Reader.ReadDeclarationNameLoc(F, DNLoc, Name, R, I);
}
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
Read/write to/from PCH DeclarationNameLocs, DeclarationNameInfos and QualifierInfos (rdar://8513756). llvm-svn: 116598
2010-10-16 02:21:24 +08:00
void ReadDeclarationNameInfo(DeclarationNameInfo &NameInfo,
Minor refactoring; Pull reading/writing DefinitionData out into a function. llvm-svn: 117233
2010-10-25 01:26:27 +08:00
const RecordData &R, unsigned &I) {
Read/write to/from PCH DeclarationNameLocs, DeclarationNameInfos and QualifierInfos (rdar://8513756). llvm-svn: 116598
2010-10-16 02:21:24 +08:00
Reader.ReadDeclarationNameInfo(F, NameInfo, R, I);
}
Thread bitstream cursors all the way through the AST reading stuff. This way, reading a trivial 2-element chained file actually works. llvm-svn: 109191
2010-07-23 06:43:28 +08:00
Implement name hiding for declarations deserialized from a non-visible module. When that module becomes visible, so do those declarations. llvm-svn: 145640
2011-12-02 06:20:10 +08:00
serialization::SubmoduleID readSubmoduleID(const RecordData &R,
unsigned &I) {
if (I >= R.size())
return 0;
return Reader.getGlobalSubmoduleID(F, R[I++]);
}
Introduce a module import declaration, so that we properly represent, e.g., __import_module__ std.vector; in the AST. llvm-svn: 145725
2011-12-03 07:23:56 +08:00
Module *readModule(const RecordData &R, unsigned &I) {
return Reader.getSubmodule(readSubmoduleID(R, 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
void ReadCXXRecordDefinition(CXXRecordDecl *D);
Refactoring. - Pass around RecordDataImpl instead of the concrete RecordData so that any SmallVector can be used. - Move ASTDeclWriter::WriteCXXDefinitionData to ASTWriter::AddCXXDefinitionData. llvm-svn: 117236
2010-10-25 01:26:40 +08:00
void ReadCXXDefinitionData(struct CXXRecordDecl::DefinitionData &Data,
const RecordData &R, unsigned &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
void MergeDefinitionData(CXXRecordDecl *D,
struct CXXRecordDecl::DefinitionData &NewDD);
Refactoring. - Pass around RecordDataImpl instead of the concrete RecordData so that any SmallVector can be used. - Move ASTDeclWriter::WriteCXXDefinitionData to ASTWriter::AddCXXDefinitionData. llvm-svn: 117236
2010-10-25 01:26:40 +08:00
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
/// \brief RAII class used to capture the first ID within a redeclaration
/// chain and to introduce it into the list of pending redeclaration chains
/// on destruction.
///
/// The caller can choose not to introduce this ID into the redeclaration
/// chain by calling \c suppress().
class RedeclarableResult {
ASTReader &Reader;
GlobalDeclID FirstID;
mutable bool Owning;
When deserializing a declaration, don't look for redeclarations if its kind indicates that it can never be redeclared. Good for a 1% speedup, and redeclaration searching drops off the profile. llvm-svn: 173054
2013-01-22 00:16:40 +08:00
Decl::Kind DeclKind;
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
Use LLVM_DELETED_FUNCTION in place of 'DO NOT IMPLEMENT' comments. llvm-svn: 163983
2012-09-16 04:20:27 +08:00
void operator=(RedeclarableResult &) LLVM_DELETED_FUNCTION;
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
public:
When deserializing a declaration, don't look for redeclarations if its kind indicates that it can never be redeclared. Good for a 1% speedup, and redeclaration searching drops off the profile. llvm-svn: 173054
2013-01-22 00:16:40 +08:00
RedeclarableResult(ASTReader &Reader, GlobalDeclID FirstID,
Decl::Kind DeclKind)
: Reader(Reader), FirstID(FirstID), Owning(true), DeclKind(DeclKind) { }
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
RedeclarableResult(const RedeclarableResult &Other)
When deserializing a declaration, don't look for redeclarations if its kind indicates that it can never be redeclared. Good for a 1% speedup, and redeclaration searching drops off the profile. llvm-svn: 173054
2013-01-22 00:16:40 +08:00
: Reader(Other.Reader), FirstID(Other.FirstID), Owning(Other.Owning) ,
DeclKind(Other.DeclKind)
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
{
Other.Owning = false;
}
~RedeclarableResult() {
When deserializing a declaration, don't look for redeclarations if its kind indicates that it can never be redeclared. Good for a 1% speedup, and redeclaration searching drops off the profile. llvm-svn: 173054
2013-01-22 00:16:40 +08:00
if (FirstID && Owning && isRedeclarableDeclKind(DeclKind) &&
Reader.PendingDeclChainsKnown.insert(FirstID))
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
Reader.PendingDeclChains.push_back(FirstID);
}
/// \brief Retrieve the first ID.
GlobalDeclID getFirstID() const { return FirstID; }
/// \brief Do not introduce this declaration ID into the set of pending
/// declaration chains.
void suppress() {
Owning = false;
}
};
When deserializing a declaration, don't look for redeclarations if its kind indicates that it can never be redeclared. Good for a 1% speedup, and redeclaration searching drops off the profile. llvm-svn: 173054
2013-01-22 00:16:40 +08:00
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
/// \brief Class used to capture the result of searching for an existing
/// declaration of a specific kind and name, along with the ability
/// to update the place where this result was found (the declaration
/// chain hanging off an identifier or the DeclContext we searched in)
/// if requested.
class FindExistingResult {
ASTReader &Reader;
NamedDecl *New;
NamedDecl *Existing;
mutable bool AddResult;
Use LLVM_DELETED_FUNCTION in place of 'DO NOT IMPLEMENT' comments. llvm-svn: 163983
2012-09-16 04:20:27 +08:00
void operator=(FindExistingResult&) LLVM_DELETED_FUNCTION;
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
public:
FindExistingResult(ASTReader &Reader)
: Reader(Reader), New(0), Existing(0), AddResult(false) { }
FindExistingResult(ASTReader &Reader, NamedDecl *New, NamedDecl *Existing)
: Reader(Reader), New(New), Existing(Existing), AddResult(true) { }
FindExistingResult(const FindExistingResult &Other)
: Reader(Other.Reader), New(Other.New), Existing(Other.Existing),
AddResult(Other.AddResult)
{
Other.AddResult = false;
}
~FindExistingResult();
Implement cross-module declaration merging for tag declarations, so that if two modules A and B both contain a declaration of a tag such as struct X; and those two modules are unrelated, the two declarations of X will be merged into a single redeclaration chain. llvm-svn: 147488
2012-01-04 06:46:00 +08:00
/// \brief Suppress the addition of this result into the known set of
/// names.
void suppress() { AddResult = false; }
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
operator NamedDecl*() const { return Existing; }
template<typename T>
operator T*() const { return dyn_cast_or_null<T>(Existing); }
};
FindExistingResult findExisting(NamedDecl *D);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
public:
Promote ModuleMap::Module to a namespace-scope class in the Basic library, since modules cut across all of the libraries. Rename serialization::Module to serialization::ModuleFile to side-step the annoying naming conflict. Prune a bunch of ModuleMap.h includes that are no longer needed (most files only needed the Module type). llvm-svn: 145538
2011-12-01 07:21:26 +08:00
ASTDeclReader(ASTReader &Reader, ModuleFile &F,
Remove an unused private field exposed by the recent LLVM_DELETED_FUNCTION changes. llvm-svn: 164106
2012-09-18 13:34:55 +08:00
DeclID thisDeclID,
[PCH] Pull the location out of the serialized declarations and put it in the array of decl bit offsets. This allows us to easily get at the location of a decl without deserializing it. It increases size of Cocoa PCH by only 0.2%. llvm-svn: 143123
2011-10-28 02:47:35 +08:00
unsigned RawLocation,
Minor refactoring; Pull reading/writing DefinitionData out into a function. llvm-svn: 117233
2010-10-25 01:26:27 +08:00
const RecordData &Record, unsigned &Idx)
Remove an unused private field exposed by the recent LLVM_DELETED_FUNCTION changes. llvm-svn: 164106
2012-09-18 13:34:55 +08:00
: Reader(Reader), F(F), ThisDeclID(thisDeclID),
[PCH] Pull the location out of the serialized declarations and put it in the array of decl bit offsets. This allows us to easily get at the location of a decl without deserializing it. It increases size of Cocoa PCH by only 0.2%. llvm-svn: 143123
2011-10-28 02:47:35 +08:00
RawLocation(RawLocation), Record(Record), Idx(Idx),
When we load a function or method body from an AST file, we check whether that function/method already has a body (loaded from some other AST file), as introduced in r165137. Delay this check until after the redeclaration chains have been wired up. While I'm here, make the loading of method bodies lazy. llvm-svn: 165513
2012-10-10 01:21:28 +08:00
TypeIDForTypeDecl(0), HasPendingBody(false) { }
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
When reading the AST, delay loading of the redeclaration chain to avoid deeply nested calls. Temporarily set the first (canonical) declaration as the previous one, which is the one that matters, and mark the real previous DeclID to be loaded & attached later on. Fixes rdar://8956193. llvm-svn: 125434
2011-02-12 15:50:47 +08:00
static void attachPreviousDecl(Decl *D, Decl *previous);
Completely re-implement (de-)serialization of declaration chains. The previous implementation relied heavily on the declaration chain being stored as a (circular) linked list on disk, as it is in memory. However, when deserializing from multiple modules, the different chains could get mixed up, leading to broken declaration chains. The new solution keeps track of the first and last declarations in the chain for each module file. When we load a declaration, we search all of the module files for redeclarations of that declaration, then splice together all of the lists into a coherent whole (along with any redeclarations that were actually parsed). As a drive-by fix, (de-)serialize the redeclaration chains of TypedefNameDecls, which had somehow gotten missed previously. Add a test of this serialization. This new scheme creates a redeclaration table that is fairly large in the PCH file (on the order of 400k for Cocoa.h's 12MB PCH file). The table is mmap'd in and searched via a binary search, but it's still quite large. A future tweak will eliminate entries for declarations that have no redeclarations anywhere, and should drastically reduce the size of this table. llvm-svn: 146841
2011-12-18 07:38:30 +08:00
static void attachLatestDecl(Decl *D, Decl *latest);
When reading the AST, delay loading of the redeclaration chain to avoid deeply nested calls. Temporarily set the first (canonical) declaration as the previous one, which is the one that matters, and mark the real previous DeclID to be loaded & attached later on. Fixes rdar://8956193. llvm-svn: 125434
2011-02-12 15:50:47 +08:00
When we load a function or method body from an AST file, we check whether that function/method already has a body (loaded from some other AST file), as introduced in r165137. Delay this check until after the redeclaration chains have been wired up. While I'm here, make the loading of method bodies lazy. llvm-svn: 165513
2012-10-10 01:21:28 +08:00
/// \brief Determine whether this declaration has a pending body.
bool hasPendingBody() const { return HasPendingBody; }
Generally types expect an initialized TypeDecl; its safer and less complicated to delay PCH reading the type of a TypeDecl. llvm-svn: 107469
2010-07-02 19:55:01 +08:00
void Visit(Decl *D);
Promote ModuleMap::Module to a namespace-scope class in the Basic library, since modules cut across all of the libraries. Rename serialization::Module to serialization::ModuleFile to side-step the annoying naming conflict. Prune a bunch of ModuleMap.h includes that are no longer needed (most files only needed the Module type). llvm-svn: 145538
2011-12-01 07:21:26 +08:00
void UpdateDecl(Decl *D, ModuleFile &ModuleFile,
Add a decl update when a static data member of a class template is instantiated in a different PCH than its containing class. Otherwise we get double definition errors. Fixes a Boost.MPL problem that affects Boost.Accumulators and probably a lot more of Boost. llvm-svn: 130488
2011-04-29 16:19:30 +08:00
const RecordData &Record);
Put the mechanism in place to track modifications in an AST entity that were committed after its initial creation/deserialization and store the changes in a chained PCH. The idea is that the AST entities call methods on the ASTMutationListener to give notifications of changes; the PCHWriter implements the ASTMutationListener interface and stores the incremental changes of the updated entity. WIP llvm-svn: 117235
2010-10-25 01:26:36 +08:00
Support importing of ObjC categories from modules. The initial incentive was to fix a crash when PCH chaining categories to an interface, but the fix was done in the "modules way" that I hear is popular with the kids these days. Each module stores the local chain of categories and we combine them when the interface is loaded. We also warn if non-dependent modules introduce duplicate named categories. llvm-svn: 138926
2011-09-01 08:58:55 +08:00
static void setNextObjCCategory(ObjCCategoryDecl *Cat,
ObjCCategoryDecl *Next) {
Cat->NextClassCategory = Next;
}
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
void VisitDecl(Decl *D);
void VisitTranslationUnitDecl(TranslationUnitDecl *TU);
void VisitNamedDecl(NamedDecl *ND);
Step #1/N of implementing support for __label__: split labels into LabelDecl and LabelStmt. There is a 1-1 correspondence between the two, but this simplifies a bunch of code by itself. This is because labels are the only place where we previously had references to random other statements, causing grief for AST serialization and other stuff. This does cause one regression (attr(unused) doesn't silence unused label warnings) which I'll address next. This does fix some minor bugs: 1. "The only valid attribute " diagnostic was capitalized. 2. Various diagnostics printed as ''labelname'' instead of 'labelname' 3. This reduces duplication of label checking between functions and blocks. Review appreciated, particularly for the cindex and template bits. llvm-svn: 125733
2011-02-17 15:39:24 +08:00
void VisitLabelDecl(LabelDecl *LD);
Implement PCH support for C++ namespaces. llvm-svn: 96738
2010-02-22 02:22:14 +08:00
void VisitNamespaceDecl(NamespaceDecl *D);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
void VisitUsingDirectiveDecl(UsingDirectiveDecl *D);
void VisitNamespaceAliasDecl(NamespaceAliasDecl *D);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
void VisitTypeDecl(TypeDecl *TD);
Combine common (de-)serialization logic for typedefs and type aliases into operations on TypedefNameDecl. No functionality change. llvm-svn: 146866
2011-12-19 22:40:25 +08:00
void VisitTypedefNameDecl(TypedefNameDecl *TD);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
void VisitTypedefDecl(TypedefDecl *TD);
Support for C++11 (non-template) alias declarations. llvm-svn: 129567
2011-04-15 22:24:37 +08:00
void VisitTypeAliasDecl(TypeAliasDecl *TD);
Fix PCH support for UnresolvedUsingTypenameDecl and UnresolvedUsingValueDecl. llvm-svn: 107268
2010-06-30 16:49:30 +08:00
void VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
Fix bitcode desynchronization when loading a PCH containing a class template specialization with modules enabled. Just don't merge them at all for now; we'll revisit this when support for template merging is added. In passing, make Decl::dump() a little safer to use with PCH/modules, by making it not deserialize any additional declarations. From a debugger you can call decls_begin() or similar first if you want to dump all child decls. llvm-svn: 182544
2013-05-23 09:49:11 +08:00
RedeclarableResult VisitTagDecl(TagDecl *TD);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
void VisitEnumDecl(EnumDecl *ED);
Fix bitcode desynchronization when loading a PCH containing a class template specialization with modules enabled. Just don't merge them at all for now; we'll revisit this when support for template merging is added. In passing, make Decl::dump() a little safer to use with PCH/modules, by making it not deserialize any additional declarations. From a debugger you can call decls_begin() or similar first if you want to dump all child decls. llvm-svn: 182544
2013-05-23 09:49:11 +08:00
RedeclarableResult VisitRecordDeclImpl(RecordDecl *RD);
void VisitRecordDecl(RecordDecl *RD) { VisitRecordDeclImpl(RD); }
RedeclarableResult VisitCXXRecordDeclImpl(CXXRecordDecl *D);
void VisitCXXRecordDecl(CXXRecordDecl *D) { VisitCXXRecordDeclImpl(D); }
RedeclarableResult VisitClassTemplateSpecializationDeclImpl(
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
ClassTemplateSpecializationDecl *D);
Fix bitcode desynchronization when loading a PCH containing a class template specialization with modules enabled. Just don't merge them at all for now; we'll revisit this when support for template merging is added. In passing, make Decl::dump() a little safer to use with PCH/modules, by making it not deserialize any additional declarations. From a debugger you can call decls_begin() or similar first if you want to dump all child decls. llvm-svn: 182544
2013-05-23 09:49:11 +08:00
void VisitClassTemplateSpecializationDecl(
ClassTemplateSpecializationDecl *D) {
VisitClassTemplateSpecializationDeclImpl(D);
}
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
void VisitClassTemplatePartialSpecializationDecl(
ClassTemplatePartialSpecializationDecl *D);
Serialize the new bits in CXXRecordDecl::DefinitionData. llvm-svn: 138855
2011-08-31 21:59:56 +08:00
void VisitClassScopeFunctionSpecializationDecl(
ClassScopeFunctionSpecializationDecl *D);
Started implementing variable templates. Top level declarations should be fully supported, up to some limitations documented as FIXMEs or TODO. Static data member templates work very partially. Static data member templates of class templates need particular attention... llvm-svn: 187762
2013-08-06 09:03:05 +08:00
RedeclarableResult
VisitVarTemplateSpecializationDeclImpl(VarTemplateSpecializationDecl *D);
void VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D) {
VisitVarTemplateSpecializationDeclImpl(D);
}
void VisitVarTemplatePartialSpecializationDecl(
VarTemplatePartialSpecializationDecl *D);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
void VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
void VisitValueDecl(ValueDecl *VD);
void VisitEnumConstantDecl(EnumConstantDecl *ECD);
Fix PCH support for UnresolvedUsingTypenameDecl and UnresolvedUsingValueDecl. llvm-svn: 107268
2010-06-30 16:49:30 +08:00
void VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
Store/load type source info from/to PCH files. llvm-svn: 79396
2009-08-19 09:28:35 +08:00
void VisitDeclaratorDecl(DeclaratorDecl *DD);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
void VisitFunctionDecl(FunctionDecl *FD);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
void VisitCXXMethodDecl(CXXMethodDecl *D);
void VisitCXXConstructorDecl(CXXConstructorDecl *D);
void VisitCXXDestructorDecl(CXXDestructorDecl *D);
void VisitCXXConversionDecl(CXXConversionDecl *D);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
void VisitFieldDecl(FieldDecl *FD);
Basic support for Microsoft property declarations and references thereto. Patch by Tong Shen! llvm-svn: 179585
2013-04-16 15:28:30 +08:00
void VisitMSPropertyDecl(MSPropertyDecl *FD);
Major anonymous union/struct redesign. A new AST node is introduced: def IndirectField : DDecl<Value>; IndirectFields are injected into the anonymous's parent scope and chain back to the original field. Name lookup for anonymous entities now result in an IndirectFieldDecl instead of a FieldDecl. There is no functionality change, the code generated should be the same. llvm-svn: 119919
2010-11-21 14:08:52 +08:00
void VisitIndirectFieldDecl(IndirectFieldDecl *FD);
Started implementing variable templates. Top level declarations should be fully supported, up to some limitations documented as FIXMEs or TODO. Static data member templates work very partially. Static data member templates of class templates need particular attention... llvm-svn: 187762
2013-08-06 09:03:05 +08:00
RedeclarableResult VisitVarDeclImpl(VarDecl *D);
void VisitVarDecl(VarDecl *VD) { VisitVarDeclImpl(VD); }
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
void VisitImplicitParamDecl(ImplicitParamDecl *PD);
void VisitParmVarDecl(ParmVarDecl *PD);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
void VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
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
DeclID VisitTemplateDecl(TemplateDecl *D);
During name lookup, use redecl_iterator to walk over the redeclaration chain to determine whether any declaration of the given entity is visible, eliminating the redundant (and less efficient) getPreviousDeclaration() implementation. This tweak uncovered an omission in the handling of RedeclarableTemplateDecl, where we weren't making sure to search for additional redeclarations of a template in other module files. Things would be cleaner if RedeclarableTemplateDecl actually used Redeclarable. llvm-svn: 147687
2012-01-07 06:05:37 +08:00
RedeclarableResult VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
void VisitClassTemplateDecl(ClassTemplateDecl *D);
Started implementing variable templates. Top level declarations should be fully supported, up to some limitations documented as FIXMEs or TODO. Static data member templates work very partially. Static data member templates of class templates need particular attention... llvm-svn: 187762
2013-08-06 09:03:05 +08:00
void VisitVarTemplateDecl(VarTemplateDecl *D);
Support emitting/reading function templates to/from PCH. llvm-svn: 106534
2010-06-22 17:55:07 +08:00
void VisitFunctionTemplateDecl(FunctionTemplateDecl *D);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
void VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
Implement support for C++0x alias templates. llvm-svn: 130953
2011-05-06 05:57:07 +08:00
void VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D);
Support PCH emitting/reading of using declarations. llvm-svn: 106404
2010-06-20 22:40:59 +08:00
void VisitUsingDecl(UsingDecl *D);
void VisitUsingShadowDecl(UsingShadowDecl *D);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
void VisitLinkageSpecDecl(LinkageSpecDecl *D);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
void VisitFileScopeAsmDecl(FileScopeAsmDecl *AD);
Introduce a module import declaration, so that we properly represent, e.g., __import_module__ std.vector; in the AST. llvm-svn: 145725
2011-12-03 07:23:56 +08:00
void VisitImportDecl(ImportDecl *D);
Added AccessSpecDecl node. llvm-svn: 105525
2010-06-05 13:09:32 +08:00
void VisitAccessSpecDecl(AccessSpecDecl *D);
Support C++ friend declarations for PCH. This commit 'introduces' a slightly different way to restore the state of the AST object. It makes PCHDeclReader/PCHDeclWriter friends and gives them access to the private members of the object. The rationale is to avoid using/modifying the AST interfaces for PCH read/write so that to: -Avoid complications with objects that have side-effects during creation or when using some setters. -Not 'pollute' the AST interface with methods only used by the PCH reader/writer -Allow AST objects to be read-only. llvm-svn: 107219
2010-06-30 06:47:00 +08:00
void VisitFriendDecl(FriendDecl *D);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
void VisitFriendTemplateDecl(FriendTemplateDecl *D);
void VisitStaticAssertDecl(StaticAssertDecl *D);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
void VisitBlockDecl(BlockDecl *BD);
Sema for Captured Statements Add CapturedDecl to be the DeclContext for CapturedStmt, and perform semantic analysis. Currently captures all variables by reference. TODO: templates Author: Ben Langmuir <ben.langmuir@intel.com> Differential Revision: http://llvm-reviews.chandlerc.com/D433 llvm-svn: 179618
2013-04-17 03:37:38 +08:00
void VisitCapturedDecl(CapturedDecl *CD);
[Sema] Semantic analysis for empty-declaration and attribute-declaration. Introduce a new AST Decl node "EmptyDecl" to model empty-declaration. Have attributes from attribute-declaration appertain to the EmptyDecl node by creating the AST representations of these attributes and attach them to the EmptyDecl node so these attributes can be sema checked just as attributes attached to "normal" declarations. llvm-svn: 175900
2013-02-23 01:15:32 +08:00
void VisitEmptyDecl(EmptyDecl *D);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
std::pair<uint64_t, uint64_t> VisitDeclContext(DeclContext *DC);
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
template<typename T>
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
RedeclarableResult VisitRedeclarable(Redeclarable<T> *D);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
Factor the merging of declarations in the AST reader out to a separate member function template, since the behavior is identical for ObjCInterfaceDecl and ObjCProtocolDecl. It's expected that all redeclarable entities will have the same behavior. llvm-svn: 147450
2012-01-04 01:27:13 +08:00
template<typename 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
void mergeRedeclarable(Redeclarable<T> *D, RedeclarableResult &Redecl,
DeclID TemplatePatternID = 0);
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
template<typename T>
void mergeRedeclarable(Redeclarable<T> *D, T *Existing,
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
RedeclarableResult &Redecl,
DeclID TemplatePatternID = 0);
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
When merging class definitions across modules in C++, merge together fields. This change doesn't go all the way to making fields redeclarable; instead, it makes them 'mergeable', which means we can find the canonical declaration, but not much else (and for a declaration that's not from a module, the canonical declaration is always that declaration). llvm-svn: 192092
2013-10-07 16:02:11 +08:00
template<typename T>
void mergeMergeable(Mergeable<T> *D);
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
void mergeTemplatePattern(RedeclarableTemplateDecl *D,
RedeclarableTemplateDecl *Existing,
DeclID DsID);
Convert DeclNodes to use TableGen. The macros required for DeclNodes use have changed to match the use of StmtNodes. The FooFirst enumerator constants have been named firstFoo to match usage elsewhere. llvm-svn: 105165
2010-05-30 15:21:58 +08:00
// FIXME: Reorder according to DeclNodes.td?
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
void VisitObjCMethodDecl(ObjCMethodDecl *D);
void VisitObjCContainerDecl(ObjCContainerDecl *D);
void VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
void VisitObjCIvarDecl(ObjCIvarDecl *D);
void VisitObjCProtocolDecl(ObjCProtocolDecl *D);
void VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D);
void VisitObjCCategoryDecl(ObjCCategoryDecl *D);
void VisitObjCImplDecl(ObjCImplDecl *D);
void VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
void VisitObjCImplementationDecl(ObjCImplementationDecl *D);
void VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D);
void VisitObjCPropertyDecl(ObjCPropertyDecl *D);
void VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
OpenMP threadprivate directive parsing and semantic analysis llvm-svn: 177705
2013-03-22 14:34:35 +08:00
void VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
};
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
uint64_t ASTDeclReader::GetCurrentCursorOffset() {
Introduce a global bit-offset continuous range map into the ASTReader, so that we have one, simple way to map from global bit offsets to local bit offsets. Eliminates a number of loops over the chain, and generalizes for more interesting bit remappings. Also, as an amusing oddity, we were computing global bit offsets *backwards* for preprocessed entities (e.g., the directly included PCH file in the chain would start at offset zero, rather than the original PCH that occurs first in translation unit). Even more amusingly, it made precompiled preambles work, because we were forgetting to adjust the local bit offset to a global bit offset when storing preprocessed entity offsets in the ASTUnit. Two wrongs made a right, and now they're both right. llvm-svn: 135750
2011-07-22 14:10:01 +08:00
return F.DeclsCursor.GetCurrentBitNo() + F.GlobalBitOffset;
Thread bitstream cursors all the way through the AST reading stuff. This way, reading a trivial 2-element chained file actually works. llvm-svn: 109191
2010-07-23 06:43:28 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::Visit(Decl *D) {
DeclVisitor<ASTDeclReader, void>::Visit(D);
Generally types expect an initialized TypeDecl; its safer and less complicated to delay PCH reading the type of a TypeDecl. llvm-svn: 107469
2010-07-02 19:55:01 +08:00
Improvements to abbreviations for PCH which add support for EnumDecl, ObjCIvarDecl, TypedefDecl, VarDecl and FieldDecl and improve support for ParmVarDecl. llvm-svn: 132604
2011-06-04 07:11:16 +08:00
if (DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)) {
if (DD->DeclInfo) {
DeclaratorDecl::ExtInfo *Info =
DD->DeclInfo.get<DeclaratorDecl::ExtInfo *>();
Info->TInfo =
GetTypeSourceInfo(Record, Idx);
}
else {
DD->DeclInfo = GetTypeSourceInfo(Record, Idx);
}
}
Handle CXXConstructorDecl, CXXDestructorDecl, and CXXConversionDecl for PCH. <vector> header can be used correctly through PCH now. llvm-svn: 107483
2010-07-02 23:58:43 +08:00
if (TypeDecl *TD = dyn_cast<TypeDecl>(D)) {
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
// We have a fully initialized TypeDecl. Read its type now.
Eliminate the branching in QualType::getTypePtr() by providing a common base for ExtQuals and Type that stores the underlying type pointer. This results in a 2% performance win for -emit-llvm on a typical C file, with 1% memory growth in the AST. Note that there is an API change in this optimization: QualType::getTypePtr() can no longer be invoked on a NULL QualType. If the QualType might be NULL, use QualType::getTypePtrOrNull(). I've audited all uses of getTypePtr() in the code base and changed the appropriate uses over to getTypePtrOrNull(). A future optimization opportunity would be to distinguish between cast/dyn_cast and cast_or_null/dyn_cast_or_null; for the former, we could use getTypePtr() rather than getTypePtrOrNull(), to take another branch out of the cast/dyn_cast implementation. llvm-svn: 121489
2010-12-11 01:03:06 +08:00
TD->setTypeForDecl(Reader.GetType(TypeIDForTypeDecl).getTypePtrOrNull());
Fix chaining of ObjCInterfaceDecl redeclarations llvm-svn: 146722
2011-12-16 11:12:41 +08:00
} else if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
// if we have a fully initialized TypeDecl, we can safely read its type now.
ID->TypeForDecl = Reader.GetType(TypeIDForTypeDecl).getTypePtrOrNull();
Handle CXXConstructorDecl, CXXDestructorDecl, and CXXConversionDecl for PCH. <vector> header can be used correctly through PCH now. llvm-svn: 107483
2010-07-02 23:58:43 +08:00
} else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
// FunctionDecl's body was written last after all other Stmts/Exprs.
Revert most of the functionality in r165001. Instead, make sure that the ASTReader doesn't attach a body to a function that is already defined elsewhere. llvm-svn: 165137
2012-10-04 02:34:48 +08:00
// We only read it if FD doesn't already have a body (e.g., from another
// module).
Add some FIXMEs to the ASTReader code llvm-svn: 165138
2012-10-04 02:36:10 +08:00
// FIXME: Also consider = default and = delete.
// FIXME: Can we diagnose ODR violations somehow?
When we load a function or method body from an AST file, we check whether that function/method already has a body (loaded from some other AST file), as introduced in r165137. Delay this check until after the redeclaration chains have been wired up. While I'm here, make the loading of method bodies lazy. llvm-svn: 165513
2012-10-10 01:21:28 +08:00
if (Record[Idx++]) {
Reader.PendingBodies[FD] = GetCurrentCursorOffset();
HasPendingBody = true;
}
Handle CXXConstructorDecl, CXXDestructorDecl, and CXXConversionDecl for PCH. <vector> header can be used correctly through PCH now. llvm-svn: 107483
2010-07-02 23:58:43 +08:00
}
Generally types expect an initialized TypeDecl; its safer and less complicated to delay PCH reading the type of a TypeDecl. llvm-svn: 107469
2010-07-02 19:55:01 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitDecl(Decl *D) {
PCH: fix a crash caused by a circular deserialization dependency We started by trying to deserialize decltype(func-param) in a trailing return type, which causes the function parameter decl to be deserialized, which pulls in the function decl, which pulls the function type, which pulls the same decltype() in the return type, and then we crashed. llvm-svn: 197644
2013-12-19 10:05:20 +08:00
if (D->isTemplateParameter() || D->isTemplateParameterPack() ||
isa<ParmVarDecl>(D)) {
When we're deserializing a template parameter declaration, temporarily use the translation unit as its declaration context, then deserialize the actual lexical and semantic DeclContexts after the template parameter is complete. This avoids problems when the DeclContext itself (e.g., a class template) is dependent on the template parameter (e.g., for the injected-class-name). llvm-svn: 127056
2011-03-05 09:35:54 +08:00
// We don't want to deserialize the DeclContext of a template
PCH: fix a crash caused by a circular deserialization dependency We started by trying to deserialize decltype(func-param) in a trailing return type, which causes the function parameter decl to be deserialized, which pulls in the function decl, which pulls the function type, which pulls the same decltype() in the return type, and then we crashed. llvm-svn: 197644
2013-12-19 10:05:20 +08:00
// parameter or of a parameter of a function template immediately. These
// entities might be used in the formulation of its DeclContext (for
// example, a function parameter can be used in decltype() in trailing
// return type of the function). Use the translation unit DeclContext as a
// placeholder.
[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
GlobalDeclID SemaDCIDForTemplateParmDecl = ReadDeclID(Record, Idx);
GlobalDeclID LexicalDCIDForTemplateParmDecl = ReadDeclID(Record, Idx);
Reader.addPendingDeclContextInfo(D,
SemaDCIDForTemplateParmDecl,
LexicalDCIDForTemplateParmDecl);
In ASTReader, replace the never-NULL ASTContext pointer with an ASTContext reference. Remove all of the extra checking and logic that was used to cope with a NULL ASTContext. No effective functionality change. llvm-svn: 139413
2011-09-10 05:34:22 +08:00
D->setDeclContext(Reader.getContext().getTranslationUnitDecl());
When we're deserializing a template parameter declaration, temporarily use the translation unit as its declaration context, then deserialize the actual lexical and semantic DeclContexts after the template parameter is complete. This avoids problems when the DeclContext itself (e.g., a class template) is dependent on the template parameter (e.g., for the injected-class-name). llvm-svn: 127056
2011-03-05 09:35:54 +08:00
} else {
[PCH] Avoid using Decl::setAttrs() and Decl::setLexicalDeclContext() from the ASTReaderDecl directly; they internally call Decl::getASTContext() which may crash if a declaration context parent is still deserializing. llvm-svn: 150137
2012-02-09 10:44:08 +08:00
DeclContext *SemaDC = ReadDeclAs<DeclContext>(Record, Idx);
DeclContext *LexicalDC = ReadDeclAs<DeclContext>(Record, Idx);
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
DeclContext *MergedSemaDC = Reader.MergedDeclContexts.lookup(SemaDC);
[PCH] Add some comments, per Ted's request. llvm-svn: 150162
2012-02-09 15:46:54 +08:00
// Avoid calling setLexicalDeclContext() directly because it uses
// Decl::getASTContext() internally which is unsafe during derialization.
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
D->setDeclContextsImpl(MergedSemaDC ? MergedSemaDC : SemaDC, LexicalDC,
Reader.getContext());
When we're deserializing a template parameter declaration, temporarily use the translation unit as its declaration context, then deserialize the actual lexical and semantic DeclContexts after the template parameter is complete. This avoids problems when the DeclContext itself (e.g., a class template) is dependent on the template parameter (e.g., for the injected-class-name). llvm-svn: 127056
2011-03-05 09:35:54 +08:00
}
[PCH] Pull the location out of the serialized declarations and put it in the array of decl bit offsets. This allows us to easily get at the location of a decl without deserializing it. It increases size of Cocoa PCH by only 0.2%. llvm-svn: 143123
2011-10-28 02:47:35 +08:00
D->setLocation(Reader.ReadSourceLocation(F, RawLocation));
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
D->setInvalidDecl(Record[Idx++]);
Read/write declaration attributes from/to PCH properly. Embed them in the declaration block instead of trying to create another block. The new block was messing with the assumption that after decls block comes the stmts block. Fixes http://llvm.org/PR8406 llvm-svn: 116737
2010-10-19 03:20:11 +08:00
if (Record[Idx++]) { // hasAttrs
Generate Attr subclasses with TableGen. Now all classes derived from Attr are generated from TableGen. Additionally, Attr* is no longer its own linked list; SmallVectors or Attr* are used. The accompanying LLVM commit contains the updates to TableGen necessary for this. Some other notes about newly-generated attribute classes: - The constructor arguments are a SourceLocation and a Context&, followed by the attributes arguments in the order that they were defined in Attr.td - Every argument in Attr.td has an appropriate accessor named getFoo, and there are sometimes a few extra ones (such as to get the length of a variadic argument). Additionally, specific_attr_iterator has been introduced, which will iterate over an AttrVec, but only over attributes of a certain type. It can be accessed through either Decl::specific_attr_begin/end or the global functions of the same name. llvm-svn: 111455
2010-08-19 07:23:40 +08:00
AttrVec Attrs;
Read/write declaration attributes from/to PCH properly. Embed them in the declaration block instead of trying to create another block. The new block was messing with the assumption that after decls block comes the stmts block. Fixes http://llvm.org/PR8406 llvm-svn: 116737
2010-10-19 03:20:11 +08:00
Reader.ReadAttributes(F, Attrs, Record, Idx);
[PCH] Add some comments, per Ted's request. llvm-svn: 150162
2012-02-09 15:46:54 +08:00
// Avoid calling setAttrs() directly because it uses Decl::getASTContext()
// internally which is unsafe during derialization.
[PCH] Avoid using Decl::setAttrs() and Decl::setLexicalDeclContext() from the ASTReaderDecl directly; they internally call Decl::getASTContext() which may crash if a declaration context parent is still deserializing. llvm-svn: 150137
2012-02-09 10:44:08 +08:00
D->setAttrsImpl(Attrs, Reader.getContext());
Generate Attr subclasses with TableGen. Now all classes derived from Attr are generated from TableGen. Additionally, Attr* is no longer its own linked list; SmallVectors or Attr* are used. The accompanying LLVM commit contains the updates to TableGen necessary for this. Some other notes about newly-generated attribute classes: - The constructor arguments are a SourceLocation and a Context&, followed by the attributes arguments in the order that they were defined in Attr.td - Every argument in Attr.td has an appropriate accessor named getFoo, and there are sometimes a few extra ones (such as to get the length of a variadic argument). Additionally, specific_attr_iterator has been introduced, which will iterate over an AttrVec, but only over attributes of a certain type. It can be accessed through either Decl::specific_attr_begin/end or the global functions of the same name. llvm-svn: 111455
2010-08-19 07:23:40 +08:00
}
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
D->setImplicit(Record[Idx++]);
A decl never becomes unused. Make that explicit in the API. llvm-svn: 193248
2013-10-24 00:46:34 +08:00
D->Used = Record[Idx++];
We regard a function as 'unused' from the codegen perspective, so our warnings diverge from gcc's unused warnings which don't get emitted if the function is referenced even in an unevaluated context (e.g. in templates, sizeof, etc.). Also, saying that a function is 'unused' because it won't get codegen'ed is somewhat misleading. - Don't emit 'unused' warnings for functions that are referenced in any part of the user's code. - A warning that an internal function/variable won't get emitted is useful though, so introduce -Wunneeded-internal-declaration which will warn if a function/variable with internal linkage is not "needed" ('used' from the codegen perspective), e.g: static void foo() { } template <int> void bar() { foo(); } test.cpp:1:13: warning: function 'foo' is not needed and will not be emitted static void foo() { } ^ Addresses rdar://8733476. llvm-svn: 129794
2011-04-20 03:51:10 +08:00
D->setReferenced(Record[Idx++]);
Stash Decl's TopLevelDeclInObjCContainer and ModulePrivate bits into the two unused lower bits of the NextDeclInContext link, dropping the number of bits in Decl down to 32, and saving 8 bytes per declaration on x86-64. llvm-svn: 147660
2012-01-07 00:59:53 +08:00
D->setTopLevelDeclInObjCContainer(Record[Idx++]);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
D->setAccess((AccessSpecifier)Record[Idx++]);
Kill of the Decl::PCHLevel field entirely. We now only need to know whether a Decl was deserialized from an AST file (any AST file). llvm-svn: 139438
2011-09-10 08:09:20 +08:00
D->FromASTFile = true;
Stash Decl's TopLevelDeclInObjCContainer and ModulePrivate bits into the two unused lower bits of the NextDeclInContext link, dropping the number of bits in Decl down to 32, and saving 8 bytes per declaration on x86-64. llvm-svn: 147660
2012-01-07 00:59:53 +08:00
D->setModulePrivate(Record[Idx++]);
D->Hidden = D->isModulePrivate();
Introduce a "Hidden" bit into Decl, to track whether that declaration is hidden from name lookup. The previous hack of tweaking the ModulePrivate bit when loading a declaration from a hidden submodule was brittle. Note that we now have 34 bits in Decl. I'll fix that next. llvm-svn: 147658
2012-01-07 00:22:39 +08:00
Implement name hiding for declarations deserialized from a non-visible module. When that module becomes visible, so do those declarations. llvm-svn: 145640
2011-12-02 06:20:10 +08:00
// Determine whether this declaration is part of a (sub)module. If so, it
// may not yet be visible.
if (unsigned SubmoduleID = readSubmoduleID(Record, Idx)) {
Implement redeclaration merging for namespaces defined in distinct modules. Teach name lookup into namespaces to search in each of the merged DeclContexts as well as the (now-primary) DeclContext. This supports the common case where two different modules put something into the same namespace. llvm-svn: 147778
2012-01-10 01:30:44 +08:00
// Store the owning submodule ID in the declaration.
D->setOwningModuleID(SubmoduleID);
Implement name hiding for declarations deserialized from a non-visible module. When that module becomes visible, so do those declarations. llvm-svn: 145640
2011-12-02 06:20:10 +08:00
// Module-private declarations are never visible, so there is no work to do.
Stash Decl's TopLevelDeclInObjCContainer and ModulePrivate bits into the two unused lower bits of the NextDeclInContext link, dropping the number of bits in Decl down to 32, and saving 8 bytes per declaration on x86-64. llvm-svn: 147660
2012-01-07 00:59:53 +08:00
if (!D->isModulePrivate()) {
Implement name hiding for declarations deserialized from a non-visible module. When that module becomes visible, so do those declarations. llvm-svn: 145640
2011-12-02 06:20:10 +08:00
if (Module *Owner = Reader.getSubmodule(SubmoduleID)) {
if (Owner->NameVisibility != Module::AllVisible) {
Introduce a "Hidden" bit into Decl, to track whether that declaration is hidden from name lookup. The previous hack of tweaking the ModulePrivate bit when loading a declaration from a hidden submodule was brittle. Note that we now have 34 bits in Decl. I'll fix that next. llvm-svn: 147658
2012-01-07 00:22:39 +08:00
// The owning module is not visible. Mark this declaration as hidden.
D->Hidden = true;
Implement name hiding for declarations deserialized from a non-visible module. When that module becomes visible, so do those declarations. llvm-svn: 145640
2011-12-02 06:20:10 +08:00
// Note that this declaration was hidden because its owning module is
// not yet visible.
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
Reader.HiddenNamesMap[Owner].HiddenDecls.push_back(D);
Implement name hiding for declarations deserialized from a non-visible module. When that module becomes visible, so do those declarations. llvm-svn: 145640
2011-12-02 06:20:10 +08:00
}
}
}
}
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitTranslationUnitDecl(TranslationUnitDecl *TU) {
In the serialized AST format, make the translation unit a "predefined" declaration that never actually gets serialized. Instead, serialize the various kinds of update records (lexical decls, visible decls, the addition of an anonymous namespace) for the translation unit, even if we're not chaining. This way, we won't have to deal with multiple loaded translation unit declarations. llvm-svn: 137395
2011-08-12 08:15:20 +08:00
llvm_unreachable("Translation units are not serialized");
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitNamedDecl(NamedDecl *ND) {
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
VisitDecl(ND);
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
ND->setDeclName(Reader.ReadDeclarationName(F, Record, Idx));
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitTypeDecl(TypeDecl *TD) {
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
VisitNamedDecl(TD);
Fixed TypedefDecl and TemplateTypeParameter source range. llvm-svn: 127119
2011-03-06 23:48:19 +08:00
TD->setLocStart(ReadSourceLocation(Record, Idx));
Generally types expect an initialized TypeDecl; its safer and less complicated to delay PCH reading the type of a TypeDecl. llvm-svn: 107469
2010-07-02 19:55:01 +08:00
// Delay type reading until after we have fully initialized the decl.
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
TypeIDForTypeDecl = Reader.getGlobalTypeID(F, Record[Idx++]);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Combine common (de-)serialization logic for typedefs and type aliases into operations on TypedefNameDecl. No functionality change. llvm-svn: 146866
2011-12-19 22:40:25 +08:00
void ASTDeclReader::VisitTypedefNameDecl(TypedefNameDecl *TD) {
Implement declaration merging for typedefs loaded from disjoint modules, so long as the typedefs refer to the same underlying type. This ensures that the typedefs end up in the same redeclaration chain. To test this, fix name lookup for C/Objective-C to properly deal with multiple declarations with the same name in the same scope. llvm-svn: 147533
2012-01-05 00:44:10 +08:00
RedeclarableResult Redecl = VisitRedeclarable(TD);
Generally types expect an initialized TypeDecl; its safer and less complicated to delay PCH reading the type of a TypeDecl. llvm-svn: 107469
2010-07-02 19:55:01 +08:00
VisitTypeDecl(TD);
Improved source code fidelity for gcc mode attribute. llvm-svn: 184417
2013-06-20 20:46:19 +08:00
TypeSourceInfo *TInfo = GetTypeSourceInfo(Record, Idx);
if (Record[Idx++]) { // isModed
QualType modedT = Reader.readType(F, Record, Idx);
TD->setModedTypeSourceInfo(TInfo, modedT);
} else
TD->setTypeSourceInfo(TInfo);
Implement declaration merging for typedefs loaded from disjoint modules, so long as the typedefs refer to the same underlying type. This ensures that the typedefs end up in the same redeclaration chain. To test this, fix name lookup for C/Objective-C to properly deal with multiple declarations with the same name in the same scope. llvm-svn: 147533
2012-01-05 00:44:10 +08:00
mergeRedeclarable(TD, Redecl);
Combine common (de-)serialization logic for typedefs and type aliases into operations on TypedefNameDecl. No functionality change. llvm-svn: 146866
2011-12-19 22:40:25 +08:00
}
void ASTDeclReader::VisitTypedefDecl(TypedefDecl *TD) {
VisitTypedefNameDecl(TD);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Support for C++11 (non-template) alias declarations. llvm-svn: 129567
2011-04-15 22:24:37 +08:00
void ASTDeclReader::VisitTypeAliasDecl(TypeAliasDecl *TD) {
Combine common (de-)serialization logic for typedefs and type aliases into operations on TypedefNameDecl. No functionality change. llvm-svn: 146866
2011-12-19 22:40:25 +08:00
VisitTypedefNameDecl(TD);
Support for C++11 (non-template) alias declarations. llvm-svn: 129567
2011-04-15 22:24:37 +08:00
}
Fix bitcode desynchronization when loading a PCH containing a class template specialization with modules enabled. Just don't merge them at all for now; we'll revisit this when support for template merging is added. In passing, make Decl::dump() a little safer to use with PCH/modules, by making it not deserialize any additional declarations. From a debugger you can call decls_begin() or similar first if you want to dump all child decls. llvm-svn: 182544
2013-05-23 09:49:11 +08:00
ASTDeclReader::RedeclarableResult ASTDeclReader::VisitTagDecl(TagDecl *TD) {
Implement cross-module declaration merging for tag declarations, so that if two modules A and B both contain a declaration of a tag such as struct X; and those two modules are unrelated, the two declarations of X will be merged into a single redeclaration chain. llvm-svn: 147488
2012-01-04 06:46:00 +08:00
RedeclarableResult Redecl = VisitRedeclarable(TD);
Eliminate a hang while loading a sequence of redeclarable entities. In essence, the redeclaration chain for a class could end up in an inconsistent state while deserializing multiple declarations in that chain, where the circular linked list was not, in fact, circular. Since only two redeclarations of the same entity will get loaded when we're in this state, restore circularity when both have been loaded. Fixes <rdar://problem/10324940> / PR11195. llvm-svn: 143037
2011-10-27 01:53:41 +08:00
VisitTypeDecl(TD);
Implement cross-module declaration merging for tag declarations, so that if two modules A and B both contain a declaration of a tag such as struct X; and those two modules are unrelated, the two declarations of X will be merged into a single redeclaration chain. llvm-svn: 147488
2012-01-04 06:46:00 +08:00
Fix C++ PCH issues. PCH got a severe beating by the boost-using test case reported here: http://llvm.org/PR8099 Fix issues like: -When PCH reading, make sure Decl's getASTContext() doesn't get called since a Decl in the parent hierarchy may be initializing. -In ASTDeclReader::VisitFunctionDecl VisitRedeclarable should be called before using FunctionDecl's isCanonicalDecl() -In ASTDeclReader::VisitRedeclarableTemplateDecl CommonOrPrev must be initialized before anything else. llvm-svn: 113391
2010-09-09 03:31:22 +08:00
TD->IdentifierNamespace = Record[Idx++];
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
TD->setTagKind((TagDecl::TagKind)Record[Idx++]);
Rename TagDecl::isDefinition -> isCompleteDefinition for better self-documenting code, since the semantics are subtly different from getDefinition(). llvm-svn: 141355
2011-10-07 14:10:15 +08:00
TD->setCompleteDefinition(Record[Idx++]);
Improve representation of tag declarations first declared or defined within the declarator of another declaration, from Enea Zaffanella! llvm-svn: 95991
2010-02-13 01:40:34 +08:00
TD->setEmbeddedInDeclarator(Record[Idx++]);
Mark a TagDecl when it is free standing (e.g. "struct foo;") llvm-svn: 140894
2011-10-01 06:11:31 +08:00
TD->setFreeStanding(Record[Idx++]);
Serialization support for TagDecl::IsCompleteDefinitionRequired Requested by Richard Smith in post-commit review of r186262 llvm-svn: 186266
2013-07-14 09:07:41 +08:00
TD->setCompleteDefinitionRequired(Record[Idx++]);
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
TD->setRBraceLoc(ReadSourceLocation(Record, Idx));
Implement cross-module declaration merging for tag declarations, so that if two modules A and B both contain a declaration of a tag such as struct X; and those two modules are unrelated, the two declarations of X will be merged into a single redeclaration chain. llvm-svn: 147488
2012-01-04 06:46:00 +08:00
Read/write to/from PCH DeclarationNameLocs, DeclarationNameInfos and QualifierInfos (rdar://8513756). llvm-svn: 116598
2010-10-16 02:21:24 +08:00
if (Record[Idx++]) { // hasExtInfo
In ASTReader, replace the never-NULL ASTContext pointer with an ASTContext reference. Remove all of the extra checking and logic that was used to cope with a NULL ASTContext. No effective functionality change. llvm-svn: 139413
2011-09-10 05:34:22 +08:00
TagDecl::ExtInfo *Info = new (Reader.getContext()) TagDecl::ExtInfo();
Read/write to/from PCH DeclarationNameLocs, DeclarationNameInfos and QualifierInfos (rdar://8513756). llvm-svn: 116598
2010-10-16 02:21:24 +08:00
ReadQualifierInfo(*Info, Record, Idx);
Revert "Revert "[-cxx-abi microsoft] Mangle local TagDecls appropriately"" This reverts commit r190895 which reverted r190892. llvm-svn: 190904
2013-09-18 07:57:10 +08:00
TD->NamedDeclOrQualifier = Info;
Read/write to/from PCH DeclarationNameLocs, DeclarationNameInfos and QualifierInfos (rdar://8513756). llvm-svn: 116598
2010-10-16 02:21:24 +08:00
} else
Revert "Revert "[-cxx-abi microsoft] Mangle local TagDecls appropriately"" This reverts commit r190895 which reverted r190892. llvm-svn: 190904
2013-09-18 07:57:10 +08:00
TD->NamedDeclOrQualifier = ReadDeclAs<NamedDecl>(Record, Idx);
Implement cross-module declaration merging for tag declarations, so that if two modules A and B both contain a declaration of a tag such as struct X; and those two modules are unrelated, the two declarations of X will be merged into a single redeclaration chain. llvm-svn: 147488
2012-01-04 06:46:00 +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
if (!isa<CXXRecordDecl>(TD))
mergeRedeclarable(TD, Redecl);
Fix bitcode desynchronization when loading a PCH containing a class template specialization with modules enabled. Just don't merge them at all for now; we'll revisit this when support for template merging is added. In passing, make Decl::dump() a little safer to use with PCH/modules, by making it not deserialize any additional declarations. From a debugger you can call decls_begin() or similar first if you want to dump all child decls. llvm-svn: 182544
2013-05-23 09:49:11 +08:00
return Redecl;
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitEnumDecl(EnumDecl *ED) {
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
VisitTagDecl(ED);
Implement C++0x scoped enumerations, from Daniel Wallin! (and tweaked a bit by me). llvm-svn: 116122
2010-10-09 07:50:27 +08:00
if (TypeSourceInfo *TI = Reader.GetTypeSourceInfo(F, Record, Idx))
ED->setIntegerTypeSourceInfo(TI);
else
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
ED->setIntegerType(Reader.readType(F, Record, Idx));
ED->setPromotionType(Reader.readType(F, Record, Idx));
Remember the number of positive and negative bits used by the enumerators of an enum in the enum decl itself. Use some spare bits from TagDecl for this purpose. llvm-svn: 103173
2010-05-06 16:49:23 +08:00
ED->setNumPositiveBits(Record[Idx++]);
ED->setNumNegativeBits(Record[Idx++]);
Implement C++0x scoped enumerations, from Daniel Wallin! (and tweaked a bit by me). llvm-svn: 116122
2010-10-09 07:50:27 +08:00
ED->IsScoped = Record[Idx++];
Added struct/class syntactic info for c++0x scoped enum. llvm-svn: 120828
2010-12-04 02:54:17 +08:00
ED->IsScopedUsingClassTag = Record[Idx++];
Implement C++0x scoped enumerations, from Daniel Wallin! (and tweaked a bit by me). llvm-svn: 116122
2010-10-09 07:50:27 +08:00
ED->IsFixed = Record[Idx++];
Instantiating a class template should not instantiate the definition of any scoped enumeration members. Later uses of an enumeration temploid as a nested name specifier should cause its instantiation. Plus some groundwork for explicit specialization of member enumerations of class templates. llvm-svn: 152750
2012-03-15 07:13:10 +08:00
C++ modules: merging for enumerations and enumerators with multiple definitions (eg through template instantiations in multiple modules). llvm-svn: 192740
2013-10-16 06:02:41 +08:00
// If this is a definition subject to the ODR, and we already have a
// definition, merge this one into it.
if (ED->IsCompleteDefinition &&
Reader.getContext().getLangOpts().Modules &&
Reader.getContext().getLangOpts().CPlusPlus) {
if (EnumDecl *&OldDef = Reader.EnumDefinitions[ED->getCanonicalDecl()]) {
Reader.MergedDeclContexts.insert(std::make_pair(ED, OldDef));
ED->IsCompleteDefinition = false;
} else {
OldDef = ED;
}
}
Instantiating a class template should not instantiate the definition of any scoped enumeration members. Later uses of an enumeration temploid as a nested name specifier should cause its instantiation. Plus some groundwork for explicit specialization of member enumerations of class templates. llvm-svn: 152750
2012-03-15 07:13:10 +08:00
if (EnumDecl *InstED = ReadDeclAs<EnumDecl>(Record, Idx)) {
TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
SourceLocation POI = ReadSourceLocation(Record, Idx);
ED->setInstantiationOfMemberEnum(Reader.getContext(), InstED, TSK);
ED->getMemberSpecializationInfo()->setPointOfInstantiation(POI);
}
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Fix bitcode desynchronization when loading a PCH containing a class template specialization with modules enabled. Just don't merge them at all for now; we'll revisit this when support for template merging is added. In passing, make Decl::dump() a little safer to use with PCH/modules, by making it not deserialize any additional declarations. From a debugger you can call decls_begin() or similar first if you want to dump all child decls. llvm-svn: 182544
2013-05-23 09:49:11 +08:00
ASTDeclReader::RedeclarableResult
ASTDeclReader::VisitRecordDeclImpl(RecordDecl *RD) {
RedeclarableResult Redecl = VisitTagDecl(RD);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
RD->setHasFlexibleArrayMember(Record[Idx++]);
RD->setAnonymousStructOrUnion(Record[Idx++]);
Patch adds test to my previous patch for assigning to gc'able structs in the Next runtime and adds missing PCH info. llvm-svn: 75014
2009-07-09 00:37:44 +08:00
RD->setHasObjectMember(Record[Idx++]);
patch for PR9027 and // rdar://11861085 Title: [PR9027] volatile struct bug: member is not loaded at -O; This is caused by last flag passed to @llvm.memcpy being false, not honoring that aggregate has at least one 'volatile' data member (even though aggregate itself has not been qualified as 'volatile'. As a result, optimization optimizes away the memcpy altogether. Patch review by John MaCall (I still need to fix up a test though). llvm-svn: 173535
2013-01-26 07:57:05 +08:00
RD->setHasVolatileMember(Record[Idx++]);
Fix bitcode desynchronization when loading a PCH containing a class template specialization with modules enabled. Just don't merge them at all for now; we'll revisit this when support for template merging is added. In passing, make Decl::dump() a little safer to use with PCH/modules, by making it not deserialize any additional declarations. From a debugger you can call decls_begin() or similar first if you want to dump all child decls. llvm-svn: 182544
2013-05-23 09:49:11 +08:00
return Redecl;
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitValueDecl(ValueDecl *VD) {
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
VisitNamedDecl(VD);
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
VD->setType(Reader.readType(F, Record, Idx));
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitEnumConstantDecl(EnumConstantDecl *ECD) {
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
VisitValueDecl(ECD);
if (Record[Idx++])
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
ECD->setInitExpr(Reader.ReadExpr(F));
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
ECD->setInitVal(Reader.ReadAPSInt(Record, Idx));
C++ modules: merging for enumerations and enumerators with multiple definitions (eg through template instantiations in multiple modules). llvm-svn: 192740
2013-10-16 06:02:41 +08:00
mergeMergeable(ECD);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitDeclaratorDecl(DeclaratorDecl *DD) {
Store/load type source info from/to PCH files. llvm-svn: 79396
2009-08-19 09:28:35 +08:00
VisitValueDecl(DD);
Fixed source range for all DeclaratorDecl's. llvm-svn: 127225
2011-03-08 16:55:46 +08:00
DD->setInnerLocStart(ReadSourceLocation(Record, Idx));
Read/write to/from PCH DeclarationNameLocs, DeclarationNameInfos and QualifierInfos (rdar://8513756). llvm-svn: 116598
2010-10-16 02:21:24 +08:00
if (Record[Idx++]) { // hasExtInfo
DeclaratorDecl::ExtInfo *Info
In ASTReader, replace the never-NULL ASTContext pointer with an ASTContext reference. Remove all of the extra checking and logic that was used to cope with a NULL ASTContext. No effective functionality change. llvm-svn: 139413
2011-09-10 05:34:22 +08:00
= new (Reader.getContext()) DeclaratorDecl::ExtInfo();
Read/write to/from PCH DeclarationNameLocs, DeclarationNameInfos and QualifierInfos (rdar://8513756). llvm-svn: 116598
2010-10-16 02:21:24 +08:00
ReadQualifierInfo(*Info, Record, Idx);
DD->DeclInfo = Info;
Improvements to abbreviations for PCH which add support for EnumDecl, ObjCIvarDecl, TypedefDecl, VarDecl and FieldDecl and improve support for ParmVarDecl. llvm-svn: 132604
2011-06-04 07:11:16 +08:00
}
Store/load type source info from/to PCH files. llvm-svn: 79396
2009-08-19 09:28:35 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitFunctionDecl(FunctionDecl *FD) {
Implement declaration merging for non-template functions from different modules. This implementation is a first approximation of what we want, using only the function type to determine equivalence. Later, we'll want to deal with some of the more subtle issues, including: - C allows a prototyped declaration and a non-prototyped declaration to be merged, which we should support - We may want to ignore the return type when merging, then complain if the return types differ. Or, we may want to leave it as it us, so that we only complain if overload resolution eventually fails. - C++ non-static member functions need to consider cv-qualifiers and ref-qualifiers. - Function templates need to consider the template parameters and return type. - Function template specializations will have special rules. - We can now (accidentally!) end up overloading in C, even without the "overloadable" attribute, and will need to detect this at some point. The actual detection of "is this an overload?" is implemented by Sema::IsOverload(), which will need to be moved into the AST library for re-use here. That will be a future refactor. llvm-svn: 147534
2012-01-05 01:13:46 +08:00
RedeclarableResult Redecl = VisitRedeclarable(FD);
Eliminate a hang while loading a sequence of redeclarable entities. In essence, the redeclaration chain for a class could end up in an inconsistent state while deserializing multiple declarations in that chain, where the circular linked list was not, in fact, circular. Since only two redeclarations of the same entity will get loaded when we're in this state, restore circularity when both have been loaded. Fixes <rdar://problem/10324940> / PR11195. llvm-svn: 143037
2011-10-27 01:53:41 +08:00
VisitDeclaratorDecl(FD);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
Read/write to/from PCH DeclarationNameLocs, DeclarationNameInfos and QualifierInfos (rdar://8513756). llvm-svn: 116598
2010-10-16 02:21:24 +08:00
ReadDeclarationNameLoc(FD->DNLoc, FD->getDeclName(), Record, Idx);
Read/write the identifier namespace in PCH for decls that may modify it. We can now use a PCH'ed <map>. llvm-svn: 107617
2010-07-05 18:38:01 +08:00
FD->IdentifierNamespace = Record[Idx++];
Implement declaration merging for non-template functions from different modules. This implementation is a first approximation of what we want, using only the function type to determine equivalence. Later, we'll want to deal with some of the more subtle issues, including: - C allows a prototyped declaration and a non-prototyped declaration to be merged, which we should support - We may want to ignore the return type when merging, then complain if the return types differ. Or, we may want to leave it as it us, so that we only complain if overload resolution eventually fails. - C++ non-static member functions need to consider cv-qualifiers and ref-qualifiers. - Function templates need to consider the template parameters and return type. - Function template specializations will have special rules. - We can now (accidentally!) end up overloading in C, even without the "overloadable" attribute, and will need to detect this at some point. The actual detection of "is this an overload?" is implemented by Sema::IsOverload(), which will need to be moved into the AST library for re-use here. That will be a future refactor. llvm-svn: 147534
2012-01-05 01:13:46 +08:00
// FunctionDecl's body is handled last at ASTDeclReader::Visit,
// after everything else is read.
Add 178663 back. http://lab.llvm.org:8011/builders/clang-x86_64-darwin10-gdb went back green before it processed the reverted 178663, so it could not have been the culprit. Revert "Revert 178663." This reverts commit 4f8a3eb2ce5d4ba422483439e20c8cbb4d953a41. llvm-svn: 178682
2013-04-04 03:27:57 +08:00
Implement declaration merging for non-template functions from different modules. This implementation is a first approximation of what we want, using only the function type to determine equivalence. Later, we'll want to deal with some of the more subtle issues, including: - C allows a prototyped declaration and a non-prototyped declaration to be merged, which we should support - We may want to ignore the return type when merging, then complain if the return types differ. Or, we may want to leave it as it us, so that we only complain if overload resolution eventually fails. - C++ non-static member functions need to consider cv-qualifiers and ref-qualifiers. - Function templates need to consider the template parameters and return type. - Function template specializations will have special rules. - We can now (accidentally!) end up overloading in C, even without the "overloadable" attribute, and will need to detect this at some point. The actual detection of "is this an overload?" is implemented by Sema::IsOverload(), which will need to be moved into the AST library for re-use here. That will be a future refactor. llvm-svn: 147534
2012-01-05 01:13:46 +08:00
FD->SClass = (StorageClass)Record[Idx++];
FD->IsInline = Record[Idx++];
FD->IsInlineSpecified = Record[Idx++];
FD->IsVirtualAsWritten = Record[Idx++];
FD->IsPure = Record[Idx++];
FD->HasInheritedPrototype = Record[Idx++];
FD->HasWrittenPrototype = Record[Idx++];
FD->IsDeleted = Record[Idx++];
FD->IsTrivial = Record[Idx++];
FD->IsDefaulted = Record[Idx++];
FD->IsExplicitlyDefaulted = Record[Idx++];
FD->HasImplicitReturnZero = Record[Idx++];
FD->IsConstexpr = Record[Idx++];
Add a bit on FunctionDecl/ObjCMethodDecl to indicate if there was a body that was skipped by the parser. llvm-svn: 169531
2012-12-07 02:59:10 +08:00
FD->HasSkippedBody = Record[Idx++];
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
FD->IsLateTemplateParsed = Record[Idx++];
Fix linkage computation for derived types in inline functions. John noticed that the fix for pr15930 (r181981) didn't handle indirect uses of local types. For example, a pointer to local struct, or a function that returns it. One way to implement this would be to recursively look for local types. This would look a lot like the linkage computation itself for types. To avoid code duplication and utilize the existing linkage cache, this patch just makes the computation of "type with no linkage but externally visible because it is from an inline function" part of the linkage computation itself. llvm-svn: 182711
2013-05-26 01:16:20 +08:00
FD->setCachedLinkage(Linkage(Record[Idx++]));
Implement declaration merging for non-template functions from different modules. This implementation is a first approximation of what we want, using only the function type to determine equivalence. Later, we'll want to deal with some of the more subtle issues, including: - C allows a prototyped declaration and a non-prototyped declaration to be merged, which we should support - We may want to ignore the return type when merging, then complain if the return types differ. Or, we may want to leave it as it us, so that we only complain if overload resolution eventually fails. - C++ non-static member functions need to consider cv-qualifiers and ref-qualifiers. - Function templates need to consider the template parameters and return type. - Function template specializations will have special rules. - We can now (accidentally!) end up overloading in C, even without the "overloadable" attribute, and will need to detect this at some point. The actual detection of "is this an overload?" is implemented by Sema::IsOverload(), which will need to be moved into the AST library for re-use here. That will be a future refactor. llvm-svn: 147534
2012-01-05 01:13:46 +08:00
FD->EndRangeLoc = ReadSourceLocation(Record, Idx);
Support emitting/reading function templates to/from PCH. llvm-svn: 106534
2010-06-22 17:55:07 +08:00
switch ((FunctionDecl::TemplatedKind)Record[Idx++]) {
case FunctionDecl::TK_NonTemplate:
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
mergeRedeclarable(FD, Redecl);
Support emitting/reading function templates to/from PCH. llvm-svn: 106534
2010-06-22 17:55:07 +08:00
break;
case FunctionDecl::TK_FunctionTemplate:
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
// Merged when we merge the template.
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
FD->setDescribedFunctionTemplate(ReadDeclAs<FunctionTemplateDecl>(Record,
Idx));
Support emitting/reading function templates to/from PCH. llvm-svn: 106534
2010-06-22 17:55:07 +08:00
break;
case FunctionDecl::TK_MemberSpecialization: {
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
FunctionDecl *InstFD = ReadDeclAs<FunctionDecl>(Record, Idx);
Support emitting/reading function templates to/from PCH. llvm-svn: 106534
2010-06-22 17:55:07 +08:00
TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
SourceLocation POI = ReadSourceLocation(Record, Idx);
In ASTReader, replace the never-NULL ASTContext pointer with an ASTContext reference. Remove all of the extra checking and logic that was used to cope with a NULL ASTContext. No effective functionality change. llvm-svn: 139413
2011-09-10 05:34:22 +08:00
FD->setInstantiationOfMemberFunction(Reader.getContext(), InstFD, TSK);
Support emitting/reading function templates to/from PCH. llvm-svn: 106534
2010-06-22 17:55:07 +08:00
FD->getMemberSpecializationInfo()->setPointOfInstantiation(POI);
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
mergeRedeclarable(FD, Redecl);
Support emitting/reading function templates to/from PCH. llvm-svn: 106534
2010-06-22 17:55:07 +08:00
break;
}
case FunctionDecl::TK_FunctionTemplateSpecialization: {
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
FunctionTemplateDecl *Template = ReadDeclAs<FunctionTemplateDecl>(Record,
Idx);
Support emitting/reading function templates to/from PCH. llvm-svn: 106534
2010-06-22 17:55:07 +08:00
TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
// Template arguments.
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<TemplateArgument, 8> TemplArgs;
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
Support emitting/reading function templates to/from PCH. llvm-svn: 106534
2010-06-22 17:55:07 +08:00
// Template args as written.
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<TemplateArgumentLoc, 8> TemplArgLocs;
Support emitting/reading function templates to/from PCH. llvm-svn: 106534
2010-06-22 17:55:07 +08:00
SourceLocation LAngleLoc, RAngleLoc;
Don't use TemplateArgumentListInfo inside AST nodes because it may leak. Use ASTTemplateArgumentListInfo instead. llvm-svn: 140331
2011-09-23 04:07:09 +08:00
bool HasTemplateArgumentsAsWritten = Record[Idx++];
if (HasTemplateArgumentsAsWritten) {
Fix reading FunctionDecls from PCH. llvm-svn: 107477
2010-07-02 19:55:40 +08:00
unsigned NumTemplateArgLocs = Record[Idx++];
TemplArgLocs.reserve(NumTemplateArgLocs);
for (unsigned i=0; i != NumTemplateArgLocs; ++i)
Thread bitstream cursors all the way through the AST reading stuff. This way, reading a trivial 2-element chained file actually works. llvm-svn: 109191
2010-07-23 06:43:28 +08:00
TemplArgLocs.push_back(
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
Reader.ReadTemplateArgumentLoc(F, Record, Idx));
Fix reading FunctionDecls from PCH. llvm-svn: 107477
2010-07-02 19:55:40 +08:00
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
LAngleLoc = ReadSourceLocation(Record, Idx);
RAngleLoc = ReadSourceLocation(Record, Idx);
Support emitting/reading function templates to/from PCH. llvm-svn: 106534
2010-06-22 17:55:07 +08:00
}
Read/write some source location for PCH. llvm-svn: 107616
2010-07-05 18:37:55 +08:00
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
SourceLocation POI = ReadSourceLocation(Record, Idx);
Support emitting/reading function templates to/from PCH. llvm-svn: 106534
2010-06-22 17:55:07 +08:00
In ASTReader, replace the never-NULL ASTContext pointer with an ASTContext reference. Remove all of the extra checking and logic that was used to cope with a NULL ASTContext. No effective functionality change. llvm-svn: 139413
2011-09-10 05:34:22 +08:00
ASTContext &C = Reader.getContext();
Fix C++ PCH issue. Another beating by boost in this test case: http://llvm.org/PR8117 A function specialization wasn't properly initialized if it wasn't canonical. I wish there was a nice little test case but this was boost. llvm-svn: 113481
2010-09-09 19:28:23 +08:00
TemplateArgumentList *TemplArgList
Remove broken support for variadic templates, along with the various abstractions (e.g., TemplateArgumentListBuilder) that were designed to support variadic templates. Only a few remnants of variadic templates remain, in the parser (parsing template type parameter packs), AST (template type parameter pack bits and TemplateArgument::Pack), and Sema; these are expected to be used in a future implementation of variadic templates. But don't get too excited about that happening now. llvm-svn: 118385
2010-11-08 07:05:16 +08:00
= TemplateArgumentList::CreateCopy(C, TemplArgs.data(), TemplArgs.size());
Don't use TemplateArgumentListInfo inside AST nodes because it may leak. Use ASTTemplateArgumentListInfo instead. llvm-svn: 140331
2011-09-23 04:07:09 +08:00
TemplateArgumentListInfo TemplArgsInfo(LAngleLoc, RAngleLoc);
Fix C++ PCH issue. Another beating by boost in this test case: http://llvm.org/PR8117 A function specialization wasn't properly initialized if it wasn't canonical. I wish there was a nice little test case but this was boost. llvm-svn: 113481
2010-09-09 19:28:23 +08:00
for (unsigned i=0, e = TemplArgLocs.size(); i != e; ++i)
Don't use TemplateArgumentListInfo inside AST nodes because it may leak. Use ASTTemplateArgumentListInfo instead. llvm-svn: 140331
2011-09-23 04:07:09 +08:00
TemplArgsInfo.addArgument(TemplArgLocs[i]);
Fix C++ PCH issue. Another beating by boost in this test case: http://llvm.org/PR8117 A function specialization wasn't properly initialized if it wasn't canonical. I wish there was a nice little test case but this was boost. llvm-svn: 113481
2010-09-09 19:28:23 +08:00
FunctionTemplateSpecializationInfo *FTInfo
= FunctionTemplateSpecializationInfo::Create(C, FD, Template, TSK,
TemplArgList,
Don't use TemplateArgumentListInfo inside AST nodes because it may leak. Use ASTTemplateArgumentListInfo instead. llvm-svn: 140331
2011-09-23 04:07:09 +08:00
HasTemplateArgumentsAsWritten ? &TemplArgsInfo : 0,
POI);
Fix C++ PCH issue. Another beating by boost in this test case: http://llvm.org/PR8117 A function specialization wasn't properly initialized if it wasn't canonical. I wish there was a nice little test case but this was boost. llvm-svn: 113481
2010-09-09 19:28:23 +08:00
FD->TemplateOrSpecialization = FTInfo;
Fix C++ PCH issues. PCH got a severe beating by the boost-using test case reported here: http://llvm.org/PR8099 Fix issues like: -When PCH reading, make sure Decl's getASTContext() doesn't get called since a Decl in the parent hierarchy may be initializing. -In ASTDeclReader::VisitFunctionDecl VisitRedeclarable should be called before using FunctionDecl's isCanonicalDecl() -In ASTDeclReader::VisitRedeclarableTemplateDecl CommonOrPrev must be initialized before anything else. llvm-svn: 113391
2010-09-09 03:31:22 +08:00
Fix C++ PCH issue. Another beating by boost in this test case: http://llvm.org/PR8117 A function specialization wasn't properly initialized if it wasn't canonical. I wish there was a nice little test case but this was boost. llvm-svn: 113481
2010-09-09 19:28:23 +08:00
if (FD->isCanonicalDecl()) { // if canonical add to template's set.
Fix C++ PCH issue. The canonical FunctionTemplateDecl contains the specializations but we cannot use getCanonicalDecl on Template because it may still be initializing. Write and read it from PCH. Fixes http://llvm.org/PR8134 llvm-svn: 113744
2010-09-13 19:45:48 +08:00
// The template that contains the specializations set. It's not safe to
// use getCanonicalDecl on Template since it may still be initializing.
FunctionTemplateDecl *CanonTemplate
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
= ReadDeclAs<FunctionTemplateDecl>(Record, Idx);
Fix C++ PCH issue. Another beating by boost in this test case: http://llvm.org/PR8117 A function specialization wasn't properly initialized if it wasn't canonical. I wish there was a nice little test case but this was boost. llvm-svn: 113481
2010-09-09 19:28:23 +08:00
// Get the InsertPos by FindNodeOrInsertPos() instead of calling
// InsertNode(FTInfo) directly to avoid the getASTContext() call in
// FunctionTemplateSpecializationInfo's Profile().
// We avoid getASTContext because a decl in the parent hierarchy may
// be initializing.
Fix C++ PCH issues. PCH got a severe beating by the boost-using test case reported here: http://llvm.org/PR8099 Fix issues like: -When PCH reading, make sure Decl's getASTContext() doesn't get called since a Decl in the parent hierarchy may be initializing. -In ASTDeclReader::VisitFunctionDecl VisitRedeclarable should be called before using FunctionDecl's isCanonicalDecl() -In ASTDeclReader::VisitRedeclarableTemplateDecl CommonOrPrev must be initialized before anything else. llvm-svn: 113391
2010-09-09 03:31:22 +08:00
llvm::FoldingSetNodeID ID;
FunctionTemplateSpecializationInfo::Profile(ID, TemplArgs.data(),
TemplArgs.size(), C);
void *InsertPos = 0;
Lazily deserialize function template specializations. This fixes a cycle in module deserialization / merging, and more laziness here is general goodness. llvm-svn: 185132
2013-06-28 12:37:53 +08:00
FunctionTemplateDecl::Common *CommonPtr = CanonTemplate->getCommonPtr();
CommonPtr->Specializations.FindNodeOrInsertPos(ID, InsertPos);
[PCH] Add a null check to avoid crashing. Unfortunately, no test case. rdar://11960120 llvm-svn: 163566
2012-09-11 07:28:22 +08:00
if (InsertPos)
Lazily deserialize function template specializations. This fixes a cycle in module deserialization / merging, and more laziness here is general goodness. llvm-svn: 185132
2013-06-28 12:37:53 +08:00
CommonPtr->Specializations.InsertNode(FTInfo, InsertPos);
else {
assert(Reader.getContext().getLangOpts().Modules &&
"already deserialized this template specialization");
// FIXME: This specialization is a redeclaration of one from another
// module. Merge it.
}
Fix C++ PCH issues. PCH got a severe beating by the boost-using test case reported here: http://llvm.org/PR8099 Fix issues like: -When PCH reading, make sure Decl's getASTContext() doesn't get called since a Decl in the parent hierarchy may be initializing. -In ASTDeclReader::VisitFunctionDecl VisitRedeclarable should be called before using FunctionDecl's isCanonicalDecl() -In ASTDeclReader::VisitRedeclarableTemplateDecl CommonOrPrev must be initialized before anything else. llvm-svn: 113391
2010-09-09 03:31:22 +08:00
}
Fix various bugs in recent commits for C++ PCH. llvm-svn: 106995
2010-06-28 17:31:34 +08:00
break;
Support emitting/reading function templates to/from PCH. llvm-svn: 106534
2010-06-22 17:55:07 +08:00
}
case FunctionDecl::TK_DependentFunctionTemplateSpecialization: {
// Templates.
UnresolvedSet<8> TemplDecls;
unsigned NumTemplates = Record[Idx++];
while (NumTemplates--)
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
TemplDecls.addDecl(ReadDeclAs<NamedDecl>(Record, Idx));
Support emitting/reading function templates to/from PCH. llvm-svn: 106534
2010-06-22 17:55:07 +08:00
// Templates args.
TemplateArgumentListInfo TemplArgs;
unsigned NumArgs = Record[Idx++];
while (NumArgs--)
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
TemplArgs.addArgument(Reader.ReadTemplateArgumentLoc(F, Record, Idx));
TemplArgs.setLAngleLoc(ReadSourceLocation(Record, Idx));
TemplArgs.setRAngleLoc(ReadSourceLocation(Record, Idx));
Support emitting/reading function templates to/from PCH. llvm-svn: 106534
2010-06-22 17:55:07 +08:00
In ASTReader, replace the never-NULL ASTContext pointer with an ASTContext reference. Remove all of the extra checking and logic that was used to cope with a NULL ASTContext. No effective functionality change. llvm-svn: 139413
2011-09-10 05:34:22 +08:00
FD->setDependentTemplateSpecialization(Reader.getContext(),
Support emitting/reading function templates to/from PCH. llvm-svn: 106534
2010-06-22 17:55:07 +08:00
TemplDecls, TemplArgs);
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
// FIXME: Merging.
Fix various bugs in recent commits for C++ PCH. llvm-svn: 106995
2010-06-28 17:31:34 +08:00
break;
Support emitting/reading function templates to/from PCH. llvm-svn: 106534
2010-06-22 17:55:07 +08:00
}
}
Fix reading FunctionDecls from PCH. llvm-svn: 107477
2010-07-02 19:55:40 +08:00
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
// Read in the parameters.
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
unsigned NumParams = Record[Idx++];
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<ParmVarDecl *, 16> Params;
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
Params.reserve(NumParams);
for (unsigned I = 0; I != NumParams; ++I)
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
Params.push_back(ReadDeclAs<ParmVarDecl>(Record, Idx));
ArrayRef-ifying Function/BlockDecl's setParams llvm-svn: 140268
2011-09-22 02:16:56 +08:00
FD->setParams(Reader.getContext(), Params);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitObjCMethodDecl(ObjCMethodDecl *MD) {
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
VisitNamedDecl(MD);
if (Record[Idx++]) {
When we load a function or method body from an AST file, we check whether that function/method already has a body (loaded from some other AST file), as introduced in r165137. Delay this check until after the redeclaration chains have been wired up. While I'm here, make the loading of method bodies lazy. llvm-svn: 165513
2012-10-10 01:21:28 +08:00
// Load the body on-demand. Most clients won't care, because method
// definitions rarely show up in headers.
Reader.PendingBodies[MD] = GetCurrentCursorOffset();
HasPendingBody = true;
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
MD->setSelfDecl(ReadDeclAs<ImplicitParamDecl>(Record, Idx));
MD->setCmdDecl(ReadDeclAs<ImplicitParamDecl>(Record, Idx));
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
MD->setInstanceMethod(Record[Idx++]);
MD->setVariadic(Record[Idx++]);
Rename ObjCMethodDecl::isSynthesized to isPropertyAccessor. This more accurately reflects its use: this flag is set when a method matches the getter or setter name for a property in the same class, and does not actually specify whether or not the definition of the method will be synthesized (either implicitly or explicitly with @synthesize). This renames the setter and backing field as well, and changes the (soon-to-be-obsolete?) XML dump format to use 'property_accessor' instead of 'synthesized'. llvm-svn: 165626
2012-10-11 00:42:25 +08:00
MD->setPropertyAccessor(Record[Idx++]);
atch for implementation of objective-c's -Wselector warning flag in clang. Little more to do for a PCH issue. Radar 6507158. llvm-svn: 109129
2010-07-23 02:24:20 +08:00
MD->setDefined(Record[Idx++]);
[AST/libclang] Speed up clang_getOverriddenCursors() considerably by reserving a bit in ObjCMethodDecl to indicate whether the method does not override any other method, which is the majority of cases. That way we can avoid unnecessary work doing lookups, especially when PCH is involved. rdar://11360082 llvm-svn: 156476
2012-05-10 00:12:57 +08:00
MD->IsOverriding = Record[Idx++];
Add a bit on FunctionDecl/ObjCMethodDecl to indicate if there was a body that was skipped by the parser. llvm-svn: 169531
2012-12-07 02:59:10 +08:00
MD->HasSkippedBody = Record[Idx++];
[PCH] Serialize info about redeclared objc methods. llvm-svn: 141964
2011-10-15 01:41:52 +08:00
MD->IsRedeclaration = Record[Idx++];
MD->HasRedeclaration = Record[Idx++];
if (MD->HasRedeclaration)
Reader.getContext().setObjCMethodRedeclaration(MD,
ReadDeclAs<ObjCMethodDecl>(Record, Idx));
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
MD->setDeclImplementation((ObjCMethodDecl::ImplementationControl)Record[Idx++]);
MD->setObjCDeclQualifier((Decl::ObjCDeclQualifier)Record[Idx++]);
Implement Objective-C Related Result Type semantics. Related result types apply Cocoa conventions to the type of message sends and property accesses to Objective-C methods that are known to always return objects whose type is the same as the type of the receiving class (or a subclass thereof), such as +alloc and -init. This tightens up static type safety for Objective-C, so that we now diagnose mistakes like this: t.m:4:10: warning: incompatible pointer types initializing 'NSSet *' with an expression of type 'NSArray *' [-Wincompatible-pointer-types] NSSet *array = [[NSArray alloc] init]; ^ ~~~~~~~~~~~~~~~~~~~~~~ /System/Library/Frameworks/Foundation.framework/Headers/NSObject.h:72:1: note: instance method 'init' is assumed to return an instance of its receiver type ('NSArray *') - (id)init; ^ It also means that we get decent type inference when writing code in Objective-C++0x: auto array = [[NSMutableArray alloc] initWithObjects:@"one", @"two",nil]; // ^ now infers NSMutableArray* rather than id llvm-svn: 132868
2011-06-11 09:09:30 +08:00
MD->SetRelatedResultType(Record[Idx++]);
Rename getResultType() on function and method declarations to getReturnType() A return type is the declared or deduced part of the function type specified in the declaration. A result type is the (potentially adjusted) type of the value of an expression that calls the function. Rule of thumb: * Declarations have return types and parameters. * Expressions have result types and arguments. llvm-svn: 200082
2014-01-26 00:55:45 +08:00
MD->setReturnType(Reader.readType(F, Record, Idx));
MD->setReturnTypeSourceInfo(GetTypeSourceInfo(Record, Idx));
[AST/libclang] Fix the selector locations that are reported for a method definition that has its '{' attached to the method name without a space. With a method like: -(id)meth{ ..... } the logic in ObjCMethodDecl that determined the selector locations got confused because it was initialized based on an end location for '{' but that end location changed to '}' after the method was finished. Fix this by having an immutable end location for the declarator and for getLocEnd() get the end location from the body itself. Fixes rdar://11659739. llvm-svn: 158583
2012-06-16 08:46:02 +08:00
MD->DeclEndLoc = ReadSourceLocation(Record, Idx);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
unsigned NumParams = Record[Idx++];
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<ParmVarDecl *, 16> Params;
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
Params.reserve(NumParams);
for (unsigned I = 0; I != NumParams; ++I)
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
Params.push_back(ReadDeclAs<ParmVarDecl>(Record, Idx));
Allow getting all source locations of selector identifiers in a ObjCMethodDecl. Instead of always storing all source locations for the selector identifiers we check whether all the identifiers are in a "standard" position; "standard" position is -Immediately before the arguments: -(id)first:(int)x second:(int)y; -With a space between the arguments: -(id)first: (int)x second: (int)y; -For nullary selectors, immediately before ';': -(void)release; In such cases we infer the locations instead of storing them. llvm-svn: 140989
2011-10-03 14:37:04 +08:00
MD->SelLocsKind = Record[Idx++];
unsigned NumStoredSelLocs = Record[Idx++];
SmallVector<SourceLocation, 16> SelLocs;
SelLocs.reserve(NumStoredSelLocs);
for (unsigned i = 0; i != NumStoredSelLocs; ++i)
SelLocs.push_back(ReadSourceLocation(Record, Idx));
MD->setParamsAndSelLocs(Reader.getContext(), Params, SelLocs);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitObjCContainerDecl(ObjCContainerDecl *CD) {
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
VisitNamedDecl(CD);
Improve location fidelity of objc decls. -Add the location of the class name to all objc container decls, not just ObjCInterfaceDecl. -Make objc decls consistent with the rest of the NamedDecls and have getLocation() point to the class name, not the location of '@'. llvm-svn: 141061
2011-10-04 12:48:02 +08:00
CD->setAtStartLoc(ReadSourceLocation(Record, Idx));
CD->setAtEndRange(ReadSourceRange(Record, Idx));
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitObjCInterfaceDecl(ObjCInterfaceDecl *ID) {
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
RedeclarableResult Redecl = VisitRedeclarable(ID);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
VisitObjCContainerDecl(ID);
Fix chaining of ObjCInterfaceDecl redeclarations llvm-svn: 146722
2011-12-16 11:12:41 +08:00
TypeIDForTypeDecl = Reader.getGlobalTypeID(F, Record[Idx++]);
Factor the merging of declarations in the AST reader out to a separate member function template, since the behavior is identical for ObjCInterfaceDecl and ObjCProtocolDecl. It's expected that all redeclarable entities will have the same behavior. llvm-svn: 147450
2012-01-04 01:27:13 +08:00
mergeRedeclarable(ID, Redecl);
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
Now that deserializing a definition of a C++ class/Objective-C class/Objective-C protocol suffices get all of the redeclarations of that declaration wired to the definition, we no longer need to record the identity of the definition in every declaration. Instead, just record a bit to indicate whether a particular declaration is the definition. llvm-svn: 148224
2012-01-16 02:17:48 +08:00
if (Record[Idx++]) {
Move the definition-specific data of ObjCInterfaceDecl into a separately-allocated DefinitionData structure, which we manage the same way as CXXRecordDecl::DefinitionData. This prepares the way for making ObjCInterfaceDecls redeclarable, to more accurately model forward declarations of Objective-C classes and eliminate the mutation of ObjCInterfaceDecl that causes us serious trouble in the AST reader. Note that ObjCInterfaceDecl's accessors are fairly robust against being applied to forward declarations, because Clang (and Sema in particular) doesn't perform RequireCompleteType/hasDefinition() checks everywhere it has to. Each of these overly-robust cases is marked with a FIXME, which we can tackle over time. llvm-svn: 146644
2011-12-15 13:27:12 +08:00
// Read the definition.
ID->allocateDefinitionData();
When deserializing the definition of a C++ class/ObjC class/ObjC protocol, record the definition pointer in the canonical declaration for that entity, and then propagate that definition pointer from the canonical declaration to all other deserialized declarations. This approach works well even when deserializing declarations that didn't know about the original definition, which can occur with modules. A nice bonus from this definition-deserialization approach is that we no longer need update records when a definition is added, because the redeclaration chains ensure that the if any declaration is loaded, the definition will also get loaded. llvm-svn: 148223
2012-01-16 02:08:05 +08:00
// Set the definition data of the canonical declaration, so other
// redeclarations will see it.
ID->getCanonicalDecl()->Data = ID->Data;
Move the definition-specific data of ObjCInterfaceDecl into a separately-allocated DefinitionData structure, which we manage the same way as CXXRecordDecl::DefinitionData. This prepares the way for making ObjCInterfaceDecls redeclarable, to more accurately model forward declarations of Objective-C classes and eliminate the mutation of ObjCInterfaceDecl that causes us serious trouble in the AST reader. Note that ObjCInterfaceDecl's accessors are fairly robust against being applied to forward declarations, because Clang (and Sema in particular) doesn't perform RequireCompleteType/hasDefinition() checks everywhere it has to. Each of these overly-robust cases is marked with a FIXME, which we can tackle over time. llvm-svn: 146644
2011-12-15 13:27:12 +08:00
ObjCInterfaceDecl::DefinitionData &Data = ID->data();
// Read the superclass.
Data.SuperClass = ReadDeclAs<ObjCInterfaceDecl>(Record, Idx);
Data.SuperClassLoc = ReadSourceLocation(Record, Idx);
Move ObjCInterfaceDecl's "EndLoc" into DefinitionData, since it only applies to an actual definition. Plus, clarify the purpose of this field and give the accessor a different name, since getLocEnd() is supposed to be the same as getSourceRange().getEnd(). llvm-svn: 146694
2011-12-16 06:34:59 +08:00
Data.EndLoc = ReadSourceLocation(Record, Idx);
[objc] Introduce ObjCInterfaceDecl::getDesignatedInitializers() to get the designated initializers of an interface. If the interface declaration does not have methods marked as designated initializers then the interface inherits the designated initializers of its super class. llvm-svn: 196315
2013-12-04 05:11:30 +08:00
Data.HasDesignatedInitializers = Record[Idx++];
Move ObjCInterfaceDecl's "EndLoc" into DefinitionData, since it only applies to an actual definition. Plus, clarify the purpose of this field and give the accessor a different name, since getLocEnd() is supposed to be the same as getSourceRange().getEnd(). llvm-svn: 146694
2011-12-16 06:34:59 +08:00
Move the definition-specific data of ObjCInterfaceDecl into a separately-allocated DefinitionData structure, which we manage the same way as CXXRecordDecl::DefinitionData. This prepares the way for making ObjCInterfaceDecls redeclarable, to more accurately model forward declarations of Objective-C classes and eliminate the mutation of ObjCInterfaceDecl that causes us serious trouble in the AST reader. Note that ObjCInterfaceDecl's accessors are fairly robust against being applied to forward declarations, because Clang (and Sema in particular) doesn't perform RequireCompleteType/hasDefinition() checks everywhere it has to. Each of these overly-robust cases is marked with a FIXME, which we can tackle over time. llvm-svn: 146644
2011-12-15 13:27:12 +08:00
// Read the directly referenced protocols and their SourceLocations.
unsigned NumProtocols = Record[Idx++];
SmallVector<ObjCProtocolDecl *, 16> Protocols;
Protocols.reserve(NumProtocols);
for (unsigned I = 0; I != NumProtocols; ++I)
Protocols.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
SmallVector<SourceLocation, 16> ProtoLocs;
ProtoLocs.reserve(NumProtocols);
for (unsigned I = 0; I != NumProtocols; ++I)
ProtoLocs.push_back(ReadSourceLocation(Record, Idx));
ID->setProtocolList(Protocols.data(), NumProtocols, ProtoLocs.data(),
Reader.getContext());
Split ObjCInterfaceDecl::ReferencedProtocols into two lists: ReferencedProtocols and AllReferencedProtocols. ReferencedProtocols (and thus protocol_begin(), protocol_end()) now only contains the list of protocols that were directly referenced in an @interface declaration. 'all_referenced_protocol_[begin,end]()' now returns the set of protocols that were referenced in both the @interface and class extensions. The latter is needed for semantic analysis/codegen, while the former is needed to maintain the lexical information of the original source. Fixes <rdar://problem/8380046>. llvm-svn: 112691
2010-09-01 09:21:15 +08:00
Move the definition-specific data of ObjCInterfaceDecl into a separately-allocated DefinitionData structure, which we manage the same way as CXXRecordDecl::DefinitionData. This prepares the way for making ObjCInterfaceDecls redeclarable, to more accurately model forward declarations of Objective-C classes and eliminate the mutation of ObjCInterfaceDecl that causes us serious trouble in the AST reader. Note that ObjCInterfaceDecl's accessors are fairly robust against being applied to forward declarations, because Clang (and Sema in particular) doesn't perform RequireCompleteType/hasDefinition() checks everywhere it has to. Each of these overly-robust cases is marked with a FIXME, which we can tackle over time. llvm-svn: 146644
2011-12-15 13:27:12 +08:00
// Read the transitive closure of protocols referenced by this class.
NumProtocols = Record[Idx++];
Protocols.clear();
Protocols.reserve(NumProtocols);
for (unsigned I = 0; I != NumProtocols; ++I)
Protocols.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
ID->data().AllReferencedProtocols.set(Protocols.data(), NumProtocols,
Reader.getContext());
Split ObjCInterfaceDecl::ReferencedProtocols into two lists: ReferencedProtocols and AllReferencedProtocols. ReferencedProtocols (and thus protocol_begin(), protocol_end()) now only contains the list of protocols that were directly referenced in an @interface declaration. 'all_referenced_protocol_[begin,end]()' now returns the set of protocols that were referenced in both the @interface and class extensions. The latter is needed for semantic analysis/codegen, while the former is needed to maintain the lexical information of the original source. Fixes <rdar://problem/8380046>. llvm-svn: 112691
2010-09-01 09:21:15 +08:00
Move the definition-specific data of ObjCInterfaceDecl into a separately-allocated DefinitionData structure, which we manage the same way as CXXRecordDecl::DefinitionData. This prepares the way for making ObjCInterfaceDecls redeclarable, to more accurately model forward declarations of Objective-C classes and eliminate the mutation of ObjCInterfaceDecl that causes us serious trouble in the AST reader. Note that ObjCInterfaceDecl's accessors are fairly robust against being applied to forward declarations, because Clang (and Sema in particular) doesn't perform RequireCompleteType/hasDefinition() checks everywhere it has to. Each of these overly-robust cases is marked with a FIXME, which we can tackle over time. llvm-svn: 146644
2011-12-15 13:27:12 +08:00
// We will rebuild this list lazily.
ID->setIvarList(0);
Remove ASTReader's PendingForwardRefs, which is now handled by the (more general) fix-up of definition data pointers. llvm-svn: 146903
2011-12-20 04:51:16 +08:00
// Note that we have deserialized a definition.
Reader.PendingDefinitions.insert(ID);
Reimplement (de-)serialization of Objective-C categories to eliminate the direct serialization of the linked-list structure. Instead, use a scheme similar to how we handle redeclarations, with redeclaration lists on the side. This addresses several issues: - In cases involving mixing and matching of many categories across many modules, the linked-list structure would not be consistent across different modules, and categories would get lost. - If a module is loaded after the class definition and its other categories have already been loaded, we wouldn't see any categories in the newly-loaded module. llvm-svn: 149112
2012-01-27 09:47:08 +08:00
// Note that we've loaded this Objective-C class.
Reader.ObjCClassesLoaded.push_back(ID);
When deserializing the definition of a C++ class/ObjC class/ObjC protocol, record the definition pointer in the canonical declaration for that entity, and then propagate that definition pointer from the canonical declaration to all other deserialized declarations. This approach works well even when deserializing declarations that didn't know about the original definition, which can occur with modules. A nice bonus from this definition-deserialization approach is that we no longer need update records when a definition is added, because the redeclaration chains ensure that the if any declaration is loaded, the definition will also get loaded. llvm-svn: 148223
2012-01-16 02:08:05 +08:00
} else {
ID->Data = ID->getCanonicalDecl()->Data;
Move the definition-specific data of ObjCInterfaceDecl into a separately-allocated DefinitionData structure, which we manage the same way as CXXRecordDecl::DefinitionData. This prepares the way for making ObjCInterfaceDecls redeclarable, to more accurately model forward declarations of Objective-C classes and eliminate the mutation of ObjCInterfaceDecl that causes us serious trouble in the AST reader. Note that ObjCInterfaceDecl's accessors are fairly robust against being applied to forward declarations, because Clang (and Sema in particular) doesn't perform RequireCompleteType/hasDefinition() checks everywhere it has to. Each of these overly-robust cases is marked with a FIXME, which we can tackle over time. llvm-svn: 146644
2011-12-15 13:27:12 +08:00
}
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitObjCIvarDecl(ObjCIvarDecl *IVD) {
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
VisitFieldDecl(IVD);
IVD->setAccessControl((ObjCIvarDecl::AccessControl)Record[Idx++]);
objective-c ivar refactoring patch. Iterations over ivars for a varienty of puposes is now consolidated into two small routines; DeepCollectObjCIvars and ShallowCollectObjCIvars. llvm-svn: 111679
2010-08-21 05:21:08 +08:00
// This field will be built lazily.
IVD->setNextIvar(0);
Added PCH/ASTImporter code for ObjCIvarDecl's field. llvm-svn: 108627
2010-07-18 02:35:47 +08:00
bool synth = Record[Idx++];
IVD->setSynthesize(synth);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitObjCProtocolDecl(ObjCProtocolDecl *PD) {
Implement declaration merging for Objective-C protocols across multiple, disjoint modules. There is far too much duplicating with the ObjCInterfaceDecl case here, which I'll eliminate shortly. llvm-svn: 147417
2012-01-02 05:47:52 +08:00
RedeclarableResult Redecl = VisitRedeclarable(PD);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
VisitObjCContainerDecl(PD);
Factor the merging of declarations in the AST reader out to a separate member function template, since the behavior is identical for ObjCInterfaceDecl and ObjCProtocolDecl. It's expected that all redeclarable entities will have the same behavior. llvm-svn: 147450
2012-01-04 01:27:13 +08:00
mergeRedeclarable(PD, Redecl);
Implement declaration merging for Objective-C protocols across multiple, disjoint modules. There is far too much duplicating with the ObjCInterfaceDecl case here, which I'll eliminate shortly. llvm-svn: 147417
2012-01-02 05:47:52 +08:00
Now that deserializing a definition of a C++ class/Objective-C class/Objective-C protocol suffices get all of the redeclarations of that declaration wired to the definition, we no longer need to record the identity of the definition in every declaration. Instead, just record a bit to indicate whether a particular declaration is the definition. llvm-svn: 148224
2012-01-16 02:17:48 +08:00
if (Record[Idx++]) {
Move the data that corresponds to the definition of a protocol into a separately-allocated DefinitionData structure. Introduce various functions that will help with the separation of declarations from definitions (isThisDeclarationADefinition(), hasDefinition(), getDefinition()). llvm-svn: 147408
2012-01-02 03:29:29 +08:00
// Read the definition.
PD->allocateDefinitionData();
When deserializing the definition of a C++ class/ObjC class/ObjC protocol, record the definition pointer in the canonical declaration for that entity, and then propagate that definition pointer from the canonical declaration to all other deserialized declarations. This approach works well even when deserializing declarations that didn't know about the original definition, which can occur with modules. A nice bonus from this definition-deserialization approach is that we no longer need update records when a definition is added, because the redeclaration chains ensure that the if any declaration is loaded, the definition will also get loaded. llvm-svn: 148223
2012-01-16 02:08:05 +08:00
// Set the definition data of the canonical declaration, so other
// redeclarations will see it.
PD->getCanonicalDecl()->Data = PD->Data;
Move the data that corresponds to the definition of a protocol into a separately-allocated DefinitionData structure. Introduce various functions that will help with the separation of declarations from definitions (isThisDeclarationADefinition(), hasDefinition(), getDefinition()). llvm-svn: 147408
2012-01-02 03:29:29 +08:00
unsigned NumProtoRefs = Record[Idx++];
SmallVector<ObjCProtocolDecl *, 16> ProtoRefs;
ProtoRefs.reserve(NumProtoRefs);
for (unsigned I = 0; I != NumProtoRefs; ++I)
ProtoRefs.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
SmallVector<SourceLocation, 16> ProtoLocs;
ProtoLocs.reserve(NumProtoRefs);
for (unsigned I = 0; I != NumProtoRefs; ++I)
ProtoLocs.push_back(ReadSourceLocation(Record, Idx));
PD->setProtocolList(ProtoRefs.data(), NumProtoRefs, ProtoLocs.data(),
Reader.getContext());
Introduce the core infrastructure needed to model redeclaration chains for Objective-C protocols, including: - Using the first declaration as the canonical declaration - Using the definition as the primary DeclContext - Making sure that all declarations have a pointer to the definition data, and that we know which declaration is the definition - Serialization support for redeclaration chains and for adding definitions to already-serialized declarations. However, note that we're not taking advantage of much of this code yet, because we're still re-using ObjCProtocolDecls. llvm-svn: 147410
2012-01-02 03:51:50 +08:00
// Note that we have deserialized a definition.
Reader.PendingDefinitions.insert(PD);
When deserializing the definition of a C++ class/ObjC class/ObjC protocol, record the definition pointer in the canonical declaration for that entity, and then propagate that definition pointer from the canonical declaration to all other deserialized declarations. This approach works well even when deserializing declarations that didn't know about the original definition, which can occur with modules. A nice bonus from this definition-deserialization approach is that we no longer need update records when a definition is added, because the redeclaration chains ensure that the if any declaration is loaded, the definition will also get loaded. llvm-svn: 148223
2012-01-16 02:08:05 +08:00
} else {
PD->Data = PD->getCanonicalDecl()->Data;
Move the data that corresponds to the definition of a protocol into a separately-allocated DefinitionData structure. Introduce various functions that will help with the separation of declarations from definitions (isThisDeclarationADefinition(), hasDefinition(), getDefinition()). llvm-svn: 147408
2012-01-02 03:29:29 +08:00
}
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *FD) {
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
VisitFieldDecl(FD);
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitObjCCategoryDecl(ObjCCategoryDecl *CD) {
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
VisitObjCContainerDecl(CD);
Reimplement (de-)serialization of Objective-C categories to eliminate the direct serialization of the linked-list structure. Instead, use a scheme similar to how we handle redeclarations, with redeclaration lists on the side. This addresses several issues: - In cases involving mixing and matching of many categories across many modules, the linked-list structure would not be consistent across different modules, and categories would get lost. - If a module is loaded after the class definition and its other categories have already been loaded, we wouldn't see any categories in the newly-loaded module. llvm-svn: 149112
2012-01-27 09:47:08 +08:00
CD->setCategoryNameLoc(ReadSourceLocation(Record, Idx));
modern objc translator. Finish off first cut of the modern meta-data translation by commenting out private ivar declarations in user source. Also, added several tests. llvm-svn: 150985
2012-02-21 04:09:20 +08:00
CD->setIvarLBraceLoc(ReadSourceLocation(Record, Idx));
CD->setIvarRBraceLoc(ReadSourceLocation(Record, Idx));
Reimplement (de-)serialization of Objective-C categories to eliminate the direct serialization of the linked-list structure. Instead, use a scheme similar to how we handle redeclarations, with redeclaration lists on the side. This addresses several issues: - In cases involving mixing and matching of many categories across many modules, the linked-list structure would not be consistent across different modules, and categories would get lost. - If a module is loaded after the class definition and its other categories have already been loaded, we wouldn't see any categories in the newly-loaded module. llvm-svn: 149112
2012-01-27 09:47:08 +08:00
// Note that this category has been deserialized. We do this before
// deserializing the interface declaration, so that it will consider this
/// category.
Reader.CategoriesDeserialized.insert(CD);
Remove a few mutating ObjCCategoryDecl methods. Remove -setClassInterface -setNextClassCategory -insertNextClassCategory and combine them in the Create function. llvm-svn: 138817
2011-08-31 03:43:26 +08:00
CD->ClassInterface = ReadDeclAs<ObjCInterfaceDecl>(Record, Idx);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
unsigned NumProtoRefs = Record[Idx++];
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<ObjCProtocolDecl *, 16> ProtoRefs;
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
ProtoRefs.reserve(NumProtoRefs);
for (unsigned I = 0; I != NumProtoRefs; ++I)
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
ProtoRefs.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<SourceLocation, 16> ProtoLocs;
Keep track of the source locations for each protocol reference in Objective-C classes, protocol definitions, forward protocol declarations, and categories. This information isn't actually used yet; that's coming next. llvm-svn: 93636
2010-01-16 23:02:53 +08:00
ProtoLocs.reserve(NumProtoRefs);
for (unsigned I = 0; I != NumProtoRefs; ++I)
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
ProtoLocs.push_back(ReadSourceLocation(Record, Idx));
Keep track of the source locations for each protocol reference in Objective-C classes, protocol definitions, forward protocol declarations, and categories. This information isn't actually used yet; that's coming next. llvm-svn: 93636
2010-01-16 23:02:53 +08:00
CD->setProtocolList(ProtoRefs.data(), NumProtoRefs, ProtoLocs.data(),
In ASTReader, replace the never-NULL ASTContext pointer with an ASTContext reference. Remove all of the extra checking and logic that was used to cope with a NULL ASTContext. No effective functionality change. llvm-svn: 139413
2011-09-10 05:34:22 +08:00
Reader.getContext());
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *CAD) {
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
VisitNamedDecl(CAD);
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
CAD->setClassInterface(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx));
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
VisitNamedDecl(D);
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
D->setAtLoc(ReadSourceLocation(Record, Idx));
objective-c: provide fixit hint when atomic property does not have matching user defined setter/getter and a warning is issued. In this case, a fixit note is displayed. // rdar://10267155 llvm-svn: 151766
2012-03-01 06:18:55 +08:00
D->setLParenLoc(ReadSourceLocation(Record, Idx));
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
D->setType(GetTypeSourceInfo(Record, Idx));
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
// FIXME: stable encoding
D->setPropertyAttributes(
(ObjCPropertyDecl::PropertyAttributeKind)Record[Idx++]);
Patch to provide separate ASTs for multiple ObjC class extension declarations (implements radar 7928731). llvm-svn: 106597
2010-06-23 07:20:40 +08:00
D->setPropertyAttributesAsWritten(
(ObjCPropertyDecl::PropertyAttributeKind)Record[Idx++]);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
// FIXME: stable encoding
D->setPropertyImplementation(
(ObjCPropertyDecl::PropertyControl)Record[Idx++]);
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
D->setGetterName(Reader.ReadDeclarationName(F,Record, Idx).getObjCSelector());
D->setSetterName(Reader.ReadDeclarationName(F,Record, Idx).getObjCSelector());
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
D->setGetterMethodDecl(ReadDeclAs<ObjCMethodDecl>(Record, Idx));
D->setSetterMethodDecl(ReadDeclAs<ObjCMethodDecl>(Record, Idx));
D->setPropertyIvarDecl(ReadDeclAs<ObjCIvarDecl>(Record, Idx));
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitObjCImplDecl(ObjCImplDecl *D) {
Make ObjCImplDecl inherit from ObjCContainerDecl. ObjCContainerDecl now is the root class for objc decls that contain methods. llvm-svn: 77235
2009-07-28 03:04:32 +08:00
VisitObjCContainerDecl(D);
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
D->setClassInterface(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx));
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
VisitObjCImplDecl(D);
Teach the ASTReader to perform local and global mapping of identifier IDs properly, although the mapping itself is still trivial. llvm-svn: 136391
2011-07-29 04:55:49 +08:00
D->setIdentifier(Reader.GetIdentifierInfo(F, Record, Idx));
Save category name loc in ObjCCategoryImplDecl, patch by Jason Haslam! llvm-svn: 146213
2011-12-09 08:31:40 +08:00
D->CategoryNameLoc = ReadSourceLocation(Record, Idx);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
VisitObjCImplDecl(D);
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
D->setSuperClass(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx));
Keep track of an @implementation's super class name location, if one was provided. llvm-svn: 181039
2013-05-04 02:05:44 +08:00
D->SuperLoc = ReadSourceLocation(Record, Idx);
modern objc translator. Finish off first cut of the modern meta-data translation by commenting out private ivar declarations in user source. Also, added several tests. llvm-svn: 150985
2012-02-21 04:09:20 +08:00
D->setIvarLBraceLoc(ReadSourceLocation(Record, Idx));
D->setIvarRBraceLoc(ReadSourceLocation(Record, Idx));
Set a special flag in class metadata when an Objective-C class has ivars that require destruction, but none that require anything except zero-initialization. This is common in ARC and (when true throughout a class hierarchy) permits the elimination of an unnecessary message-send during allocation. llvm-svn: 166088
2012-10-17 12:53:31 +08:00
D->setHasNonZeroConstructors(Record[Idx++]);
D->setHasDestructors(Record[Idx++]);
[C++11] Replace llvm::tie with std::tie. llvm-svn: 202639
2014-03-02 21:01:17 +08:00
std::tie(D->IvarInitializers, D->NumIvarInitializers) =
Reader.ReadCXXCtorInitializers(F, Record, Idx);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
VisitDecl(D);
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
D->setAtLoc(ReadSourceLocation(Record, Idx));
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
D->setPropertyDecl(ReadDeclAs<ObjCPropertyDecl>(Record, Idx));
D->PropertyIvarDecl = ReadDeclAs<ObjCIvarDecl>(Record, Idx);
For an Objective-C @synthesize statement, e.g., @synthesize foo = _foo; keep track of the location of the ivar ("_foo"). Teach libclang to visit the ivar as a member reference. llvm-svn: 119447
2010-11-17 09:03:52 +08:00
D->IvarLoc = ReadSourceLocation(Record, Idx);
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
D->setGetterCXXConstructor(Reader.ReadExpr(F));
D->setSetterCXXAssignment(Reader.ReadExpr(F));
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitFieldDecl(FieldDecl *FD) {
Store/load type source info from/to PCH files. llvm-svn: 79396
2009-08-19 09:28:35 +08:00
VisitDeclaratorDecl(FD);
PR13064: Store whether an in-class initializer uses direct or copy initialization, and use that information to produce the right kind of initialization during template instantiation. llvm-svn: 158288
2012-06-10 11:12:00 +08:00
FD->Mutable = Record[Idx++];
if (int BitWidthOrInitializer = Record[Idx++]) {
FD->InitializerOrBitWidth.setInt(BitWidthOrInitializer - 1);
FD->InitializerOrBitWidth.setPointer(Reader.ReadExpr(F));
}
Read/write more information of ASTContext for PCH. Overriden methods and instantiated-from information. llvm-svn: 107597
2010-07-05 05:44:35 +08:00
if (!FD->getDeclName()) {
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
if (FieldDecl *Tmpl = ReadDeclAs<FieldDecl>(Record, Idx))
In ASTReader, replace the never-NULL ASTContext pointer with an ASTContext reference. Remove all of the extra checking and logic that was used to cope with a NULL ASTContext. No effective functionality change. llvm-svn: 139413
2011-09-10 05:34:22 +08:00
Reader.getContext().setInstantiatedFromUnnamedFieldDecl(FD, Tmpl);
Read/write more information of ASTContext for PCH. Overriden methods and instantiated-from information. llvm-svn: 107597
2010-07-05 05:44:35 +08:00
}
When merging class definitions across modules in C++, merge together fields. This change doesn't go all the way to making fields redeclarable; instead, it makes them 'mergeable', which means we can find the canonical declaration, but not much else (and for a declaration that's not from a module, the canonical declaration is always that declaration). llvm-svn: 192092
2013-10-07 16:02:11 +08:00
mergeMergeable(FD);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Basic support for Microsoft property declarations and references thereto. Patch by Tong Shen! llvm-svn: 179585
2013-04-16 15:28:30 +08:00
void ASTDeclReader::VisitMSPropertyDecl(MSPropertyDecl *PD) {
VisitDeclaratorDecl(PD);
PD->GetterId = Reader.GetIdentifierInfo(F, Record, Idx);
PD->SetterId = Reader.GetIdentifierInfo(F, Record, Idx);
}
Major anonymous union/struct redesign. A new AST node is introduced: def IndirectField : DDecl<Value>; IndirectFields are injected into the anonymous's parent scope and chain back to the original field. Name lookup for anonymous entities now result in an IndirectFieldDecl instead of a FieldDecl. There is no functionality change, the code generated should be the same. llvm-svn: 119919
2010-11-21 14:08:52 +08:00
void ASTDeclReader::VisitIndirectFieldDecl(IndirectFieldDecl *FD) {
VisitValueDecl(FD);
FD->ChainingSize = Record[Idx++];
assert(FD->ChainingSize >= 2 && "Anonymous chaining must be >= 2");
In ASTReader, replace the never-NULL ASTContext pointer with an ASTContext reference. Remove all of the extra checking and logic that was used to cope with a NULL ASTContext. No effective functionality change. llvm-svn: 139413
2011-09-10 05:34:22 +08:00
FD->Chaining = new (Reader.getContext())NamedDecl*[FD->ChainingSize];
Major anonymous union/struct redesign. A new AST node is introduced: def IndirectField : DDecl<Value>; IndirectFields are injected into the anonymous's parent scope and chain back to the original field. Name lookup for anonymous entities now result in an IndirectFieldDecl instead of a FieldDecl. There is no functionality change, the code generated should be the same. llvm-svn: 119919
2010-11-21 14:08:52 +08:00
for (unsigned I = 0; I != FD->ChainingSize; ++I)
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
FD->Chaining[I] = ReadDeclAs<NamedDecl>(Record, Idx);
Major anonymous union/struct redesign. A new AST node is introduced: def IndirectField : DDecl<Value>; IndirectFields are injected into the anonymous's parent scope and chain back to the original field. Name lookup for anonymous entities now result in an IndirectFieldDecl instead of a FieldDecl. There is no functionality change, the code generated should be the same. llvm-svn: 119919
2010-11-21 14:08:52 +08:00
}
Started implementing variable templates. Top level declarations should be fully supported, up to some limitations documented as FIXMEs or TODO. Static data member templates work very partially. Static data member templates of class templates need particular attention... llvm-svn: 187762
2013-08-06 09:03:05 +08:00
ASTDeclReader::RedeclarableResult ASTDeclReader::VisitVarDeclImpl(VarDecl *VD) {
Implement declaration merging for variables in disjoint modules. llvm-svn: 147535
2012-01-05 01:21:36 +08:00
RedeclarableResult Redecl = VisitRedeclarable(VD);
Eliminate a hang while loading a sequence of redeclarable entities. In essence, the redeclaration chain for a class could end up in an inconsistent state while deserializing multiple declarations in that chain, where the circular linked list was not, in fact, circular. Since only two redeclarations of the same entity will get loaded when we're in this state, restore circularity when both have been loaded. Fixes <rdar://problem/10324940> / PR11195. llvm-svn: 143037
2011-10-27 01:53:41 +08:00
VisitDeclaratorDecl(VD);
Add 178663 back. http://lab.llvm.org:8011/builders/clang-x86_64-darwin10-gdb went back green before it processed the reverted 178663, so it could not have been the culprit. Revert "Revert 178663." This reverts commit 4f8a3eb2ce5d4ba422483439e20c8cbb4d953a41. llvm-svn: 178682
2013-04-04 03:27:57 +08:00
Compress some bits. Only matters for MSVC, or if we ever devirtualize Decl (because bits can't get laid out in base classes if the base is POD). llvm-svn: 130632
2011-05-01 10:13:58 +08:00
VD->VarDeclBits.SClass = (StorageClass)Record[Idx++];
In VarDecl nodes, store the thread storage class specifier as written. llvm-svn: 181113
2013-05-04 16:27:07 +08:00
VD->VarDeclBits.TSCSpec = Record[Idx++];
Represent C++ direct initializers as ParenListExprs before semantic analysis instead of having a special-purpose function. - ActOnCXXDirectInitializer, which was mostly duplication of AddInitializerToDecl (leading e.g. to PR10620, which Eli fixed a few days ago), is dropped completely. - MultiInitializer, which was an ugly hack I added, is dropped again. - We now have the infrastructure in place to distinguish between int x = {1}; int x({1}); int x{1}; -- VarDecl now has getInitStyle(), which indicates which of the above was used. -- CXXConstructExpr now has a flag to indicate that it represents list- initialization, although this is not yet used. - InstantiateInitializer was renamed to SubstInitializer and simplified. - ActOnParenOrParenListExpr has been replaced by ActOnParenListExpr, which always produces a ParenListExpr. Placed that so far failed to convert that back to a ParenExpr containing comma operators have been fixed. I'm pretty sure I could have made a crashing test case before this. The end result is a (I hope) considerably cleaner design of initializers. More importantly, the fact that I can now distinguish between the various initialization kinds means that I can get the tricky generalized initializer test cases Johannes Schaub supplied to work. (This is not yet done.) This commit passed self-host, with the resulting compiler passing the tests. I hope it doesn't break more complicated code. It's a pretty big change, but one that I feel is necessary. llvm-svn: 150318
2012-02-12 07:51:47 +08:00
VD->VarDeclBits.InitStyle = Record[Idx++];
Compress some bits. Only matters for MSVC, or if we ever devirtualize Decl (because bits can't get laid out in base classes if the base is POD). llvm-svn: 130632
2011-05-01 10:13:58 +08:00
VD->VarDeclBits.ExceptionVar = Record[Idx++];
VD->VarDeclBits.NRVOVariable = Record[Idx++];
VD->VarDeclBits.CXXForRangeDecl = Record[Idx++];
Objective-C fast enumeration loop variables are not retained in ARC, but they should still be officially __strong for the purposes of errors, block capture, etc. Make a new bit on variables, isARCPseudoStrong(), and set this for 'self' and these enumeration-loop variables. Change the code that was looking for the old patterns to look for this bit, and change IR generation to find this bit and treat the resulting variable as __unsafe_unretained for the purposes of init/destroy in the two places it can come up. llvm-svn: 133243
2011-06-17 14:42:21 +08:00
VD->VarDeclBits.ARCPseudoStrong = Record[Idx++];
Serialize the 'IsConstexpr' bit of VarDecls. Fixes <rdar://problem/12328814>. llvm-svn: 164335
2012-09-21 07:43:29 +08:00
VD->VarDeclBits.IsConstexpr = Record[Idx++];
Per latest drafting, switch to implementing init-captures as if by declaring and capturing a variable declaration, and complete the implementation of them. llvm-svn: 191605
2013-09-28 12:02:39 +08:00
VD->VarDeclBits.IsInitCapture = Record[Idx++];
Fix implementation of C11 6.2.7/4 and C++11 [dcl.array]p3: When a local extern declaration redeclares some other entity, the type of that entity is merged with the prior type if the prior declaration is visible (in C) or is declared in the same scope (in C++). - Make LookupRedeclarationWithLinkage actually work in C++, use it in the right set of cases, and make it track whether it found a shadowed declaration. - Track whether we found a declaration in the same scope (for C++) including across serialization and template instantiation. llvm-svn: 188307
2013-08-14 02:18:50 +08:00
VD->VarDeclBits.PreviousDeclInSameBlockScope = Record[Idx++];
Switch the semantic DeclContext for a block-scope declaration of a function or variable from being the function to being the enclosing namespace scope (in C++) or the TU (in C). This allows us to fix a selection of related issues where we would build incorrect redeclaration chains for such declarations, and fail to notice type mismatches. Such declarations are put into a new IdentifierNamespace, IDNS_LocalExtern, which is only found when searching scopes, and not found when searching DeclContexts. Such a declaration is only made visible in its DeclContext if there are no non-LocalExtern declarations. llvm-svn: 191064
2013-09-20 09:15:31 +08:00
Linkage VarLinkage = Linkage(Record[Idx++]);
VD->setCachedLinkage(VarLinkage);
// Reconstruct the one piece of the IdentifierNamespace that we need.
Fix PCH deserialization bug with local static symbols being treated as local extern. This triggered a miscompilation of code using Boost's function_template.hpp when it was included inside a PCH file. A local static within that header would be treated as local extern, resulting in the wrong mangling. This only occurred during PCH deserialization. Fixes <rdar://problem/15975816> and <rdar://problem/15926311>. llvm-svn: 201130
2014-02-11 14:29:29 +08:00
if (VD->getStorageClass() == SC_Extern && VarLinkage != NoLinkage &&
Switch the semantic DeclContext for a block-scope declaration of a function or variable from being the function to being the enclosing namespace scope (in C++) or the TU (in C). This allows us to fix a selection of related issues where we would build incorrect redeclaration chains for such declarations, and fail to notice type mismatches. Such declarations are put into a new IdentifierNamespace, IDNS_LocalExtern, which is only found when searching scopes, and not found when searching DeclContexts. Such a declaration is only made visible in its DeclContext if there are no non-LocalExtern declarations. llvm-svn: 191064
2013-09-20 09:15:31 +08:00
VD->getLexicalDeclContext()->isFunctionOrMethod())
VD->setLocalExternDecl();
Fix linkage computation for derived types in inline functions. John noticed that the fix for pr15930 (r181981) didn't handle indirect uses of local types. For example, a pointer to local struct, or a function that returns it. One way to implement this would be to recursively look for local types. This would look a lot like the linkage computation itself for types. To avoid code duplication and utilize the existing linkage cache, this patch just makes the computation of "type with no linkage but externally visible because it is from an inline function" part of the linkage computation itself. llvm-svn: 182711
2013-05-26 01:16:20 +08:00
constexpr handling improvements. Produce detailed diagnostics when a 'constexpr' variable is initialized by a non-constant expression, and pass in the variable being declared so that earlier-initialized fields' values can be used. Rearrange VarDecl init evaluation to make this possible, and in so doing fix a long-standing issue in our C++ constant expression handling, where we would mishandle cases like: extern const int a; const int n = a; const int a = 5; int arr[n]; Here, n is not initialized by a constant expression, so can't be used in an ICE, even though the initialization expression would be an ICE if it appeared later in the TU. This requires computing whether the initializer is an ICE eagerly, and saving that information in PCH files. llvm-svn: 146856
2011-12-19 14:19:21 +08:00
if (uint64_t Val = Record[Idx++]) {
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
VD->setInit(Reader.ReadExpr(F));
constexpr handling improvements. Produce detailed diagnostics when a 'constexpr' variable is initialized by a non-constant expression, and pass in the variable being declared so that earlier-initialized fields' values can be used. Rearrange VarDecl init evaluation to make this possible, and in so doing fix a long-standing issue in our C++ constant expression handling, where we would mishandle cases like: extern const int a; const int n = a; const int a = 5; int arr[n]; Here, n is not initialized by a constant expression, so can't be used in an ICE, even though the initialization expression would be an ICE if it appeared later in the TU. This requires computing whether the initializer is an ICE eagerly, and saving that information in PCH files. llvm-svn: 146856
2011-12-19 14:19:21 +08:00
if (Val > 1) {
EvaluatedStmt *Eval = VD->ensureEvaluatedStmt();
Eval->CheckedICE = true;
Eval->IsICE = Val == 3;
}
}
Read/write specialization info of static data members for PCH. llvm-svn: 107593
2010-07-05 05:44:00 +08:00
Bug fix: disallow a variable template to be redeclared as a non-templated variable llvm-svn: 188350
2013-08-14 11:09:19 +08:00
enum VarKind {
VarNotTemplate = 0, VarTemplate, StaticDataMemberSpecialization
};
switch ((VarKind)Record[Idx++]) {
case VarNotTemplate:
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
// Only true variables (not parameters or implicit parameters) can be merged
if (VD->getKind() != Decl::ParmVar && VD->getKind() != Decl::ImplicitParam)
mergeRedeclarable(VD, Redecl);
Bug fix: disallow a variable template to be redeclared as a non-templated variable llvm-svn: 188350
2013-08-14 11:09:19 +08:00
break;
case VarTemplate:
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
// Merged when we merge the template.
Bug fix: disallow a variable template to be redeclared as a non-templated variable llvm-svn: 188350
2013-08-14 11:09:19 +08:00
VD->setDescribedVarTemplate(ReadDeclAs<VarTemplateDecl>(Record, Idx));
break;
case StaticDataMemberSpecialization: { // HasMemberSpecializationInfo.
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
VarDecl *Tmpl = ReadDeclAs<VarDecl>(Record, Idx);
Read/write specialization info of static data members for PCH. llvm-svn: 107593
2010-07-05 05:44:00 +08:00
TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
SourceLocation POI = ReadSourceLocation(Record, Idx);
In ASTReader, replace the never-NULL ASTContext pointer with an ASTContext reference. Remove all of the extra checking and logic that was used to cope with a NULL ASTContext. No effective functionality change. llvm-svn: 139413
2011-09-10 05:34:22 +08:00
Reader.getContext().setInstantiatedFromStaticDataMember(VD, Tmpl, TSK,POI);
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
mergeRedeclarable(VD, Redecl);
Bug fix: disallow a variable template to be redeclared as a non-templated variable llvm-svn: 188350
2013-08-14 11:09:19 +08:00
break;
}
Read/write specialization info of static data members for PCH. llvm-svn: 107593
2010-07-05 05:44:00 +08:00
}
Started implementing variable templates. Top level declarations should be fully supported, up to some limitations documented as FIXMEs or TODO. Static data member templates work very partially. Static data member templates of class templates need particular attention... llvm-svn: 187762
2013-08-06 09:03:05 +08:00
return Redecl;
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitImplicitParamDecl(ImplicitParamDecl *PD) {
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
VisitVarDecl(PD);
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitParmVarDecl(ParmVarDecl *PD) {
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
VisitVarDecl(PD);
Revise the representation of parameter scope data so that the scope depth overlaps with the ObjCDeclQualifier, dropping memory usage back to previous levels. llvm-svn: 130671
2011-05-02 08:30:12 +08:00
unsigned isObjCMethodParam = Record[Idx++];
unsigned scopeDepth = Record[Idx++];
unsigned scopeIndex = Record[Idx++];
unsigned declQualifier = Record[Idx++];
if (isObjCMethodParam) {
assert(scopeDepth == 0);
PD->setObjCMethodScopeInfo(scopeIndex);
PD->ParmVarDeclBits.ScopeDepthOrObjCQuals = declQualifier;
} else {
PD->setScopeInfo(scopeDepth, scopeIndex);
}
Compress some bits. Only matters for MSVC, or if we ever devirtualize Decl (because bits can't get laid out in base classes if the base is POD). llvm-svn: 130632
2011-05-01 10:13:58 +08:00
PD->ParmVarDeclBits.IsKNRPromoted = Record[Idx++];
PD->ParmVarDeclBits.HasInheritedDefaultArg = Record[Idx++];
Write/read ParmVarDecl's UninstantiatedDefaultArg for PCH. llvm-svn: 107594
2010-07-05 05:44:07 +08:00
if (Record[Idx++]) // hasUninstantiatedDefaultArg.
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
PD->setUninstantiatedDefaultArg(Reader.ReadExpr(F));
Check for matching template-parameter-lists when merging template declarations. llvm-svn: 184791
2013-06-25 06:51:00 +08:00
// FIXME: If this is a redeclaration of a function from another module, handle
// inheritance of default arguments.
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitFileScopeAsmDecl(FileScopeAsmDecl *AD) {
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
VisitDecl(AD);
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
AD->setAsmString(cast<StringLiteral>(Reader.ReadExpr(F)));
Fixed source range for FileScopeAsmDecl. Others source range fixes will follow. llvm-svn: 126939
2011-03-03 22:20:18 +08:00
AD->setRParenLoc(ReadSourceLocation(Record, Idx));
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitBlockDecl(BlockDecl *BD) {
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
VisitDecl(BD);
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
BD->setBody(cast_or_null<CompoundStmt>(Reader.ReadStmt(F)));
BD->setSignatureAsWritten(GetTypeSourceInfo(Record, Idx));
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
unsigned NumParams = Record[Idx++];
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<ParmVarDecl *, 16> Params;
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
Params.reserve(NumParams);
for (unsigned I = 0; I != NumParams; ++I)
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
Params.push_back(ReadDeclAs<ParmVarDecl>(Record, Idx));
ArrayRef-ifying Function/BlockDecl's setParams llvm-svn: 140268
2011-09-22 02:16:56 +08:00
BD->setParams(Params);
An insomniac stab at making block declarations list the variables they close on, as well as more reliably limiting invalid references to locals from nested scopes. llvm-svn: 124721
2011-02-02 21:00:07 +08:00
Serialize and deserialize some missing bits from BlockDecl. llvm-svn: 154676
2012-04-14 01:33:29 +08:00
BD->setIsVariadic(Record[Idx++]);
BD->setBlockMissingReturnType(Record[Idx++]);
BD->setIsConversionFromLambda(Record[Idx++]);
An insomniac stab at making block declarations list the variables they close on, as well as more reliably limiting invalid references to locals from nested scopes. llvm-svn: 124721
2011-02-02 21:00:07 +08:00
bool capturesCXXThis = Record[Idx++];
A few more tweaks to the blocks AST representation: - BlockDeclRefExprs always store VarDecls - BDREs no longer store copy expressions - BlockDecls now store a list of captured variables, information about how they're captured, and a copy expression if necessary With that in hand, change IR generation to use the captures data in blocks instead of walking the block independently. Additionally, optimize block layout by emitting fields in descending alignment order, with a heuristic for filling in words when alignment of the end of the block header is insufficient for the most aligned field. llvm-svn: 125005
2011-02-07 18:33:21 +08:00
unsigned numCaptures = Record[Idx++];
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<BlockDecl::Capture, 16> captures;
A few more tweaks to the blocks AST representation: - BlockDeclRefExprs always store VarDecls - BDREs no longer store copy expressions - BlockDecls now store a list of captured variables, information about how they're captured, and a copy expression if necessary With that in hand, change IR generation to use the captures data in blocks instead of walking the block independently. Additionally, optimize block layout by emitting fields in descending alignment order, with a heuristic for filling in words when alignment of the end of the block header is insufficient for the most aligned field. llvm-svn: 125005
2011-02-07 18:33:21 +08:00
captures.reserve(numCaptures);
for (unsigned i = 0; i != numCaptures; ++i) {
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
VarDecl *decl = ReadDeclAs<VarDecl>(Record, Idx);
A few more tweaks to the blocks AST representation: - BlockDeclRefExprs always store VarDecls - BDREs no longer store copy expressions - BlockDecls now store a list of captured variables, information about how they're captured, and a copy expression if necessary With that in hand, change IR generation to use the captures data in blocks instead of walking the block independently. Additionally, optimize block layout by emitting fields in descending alignment order, with a heuristic for filling in words when alignment of the end of the block header is insufficient for the most aligned field. llvm-svn: 125005
2011-02-07 18:33:21 +08:00
unsigned flags = Record[Idx++];
bool byRef = (flags & 1);
bool nested = (flags & 2);
Expr *copyExpr = ((flags & 4) ? Reader.ReadExpr(F) : 0);
captures.push_back(BlockDecl::Capture(decl, byRef, nested, copyExpr));
}
In ASTReader, replace the never-NULL ASTContext pointer with an ASTContext reference. Remove all of the extra checking and logic that was used to cope with a NULL ASTContext. No effective functionality change. llvm-svn: 139413
2011-09-10 05:34:22 +08:00
BD->setCaptures(Reader.getContext(), captures.begin(),
A few more tweaks to the blocks AST representation: - BlockDeclRefExprs always store VarDecls - BDREs no longer store copy expressions - BlockDecls now store a list of captured variables, information about how they're captured, and a copy expression if necessary With that in hand, change IR generation to use the captures data in blocks instead of walking the block independently. Additionally, optimize block layout by emitting fields in descending alignment order, with a heuristic for filling in words when alignment of the end of the block header is insufficient for the most aligned field. llvm-svn: 125005
2011-02-07 18:33:21 +08:00
captures.end(), capturesCXXThis);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Serialization for captured statements Add serialization for captured statements and captured decls. Also add a const_capture_iterator to CapturedStmt. Test contributed by Wei Pan Differential Revision: http://llvm-reviews.chandlerc.com/D727 llvm-svn: 181048
2013-05-04 03:20:19 +08:00
void ASTDeclReader::VisitCapturedDecl(CapturedDecl *CD) {
VisitDecl(CD);
// Body is set by VisitCapturedStmt.
for (unsigned i = 0; i < CD->NumParams; ++i)
CD->setParam(i, ReadDeclAs<ImplicitParamDecl>(Record, Idx));
Sema for Captured Statements Add CapturedDecl to be the DeclContext for CapturedStmt, and perform semantic analysis. Currently captures all variables by reference. TODO: templates Author: Ben Langmuir <ben.langmuir@intel.com> Differential Revision: http://llvm-reviews.chandlerc.com/D433 llvm-svn: 179618
2013-04-17 03:37:38 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
VisitDecl(D);
D->setLanguage((LinkageSpecDecl::LanguageIDs)Record[Idx++]);
Fixed source range for StaticAssertDecl and LinkageSpecDecl. Fixed source range for declarations using postfix types. llvm-svn: 127251
2011-03-09 00:41:52 +08:00
D->setExternLoc(ReadSourceLocation(Record, Idx));
Fixed end source location for LinkageSpecDecl. llvm-svn: 126943
2011-03-03 22:52:38 +08:00
D->setRBraceLoc(ReadSourceLocation(Record, Idx));
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
}
Step #1/N of implementing support for __label__: split labels into LabelDecl and LabelStmt. There is a 1-1 correspondence between the two, but this simplifies a bunch of code by itself. This is because labels are the only place where we previously had references to random other statements, causing grief for AST serialization and other stuff. This does cause one regression (attr(unused) doesn't silence unused label warnings) which I'll address next. This does fix some minor bugs: 1. "The only valid attribute " diagnostic was capitalized. 2. Various diagnostics printed as ''labelname'' instead of 'labelname' 3. This reduces duplication of label checking between functions and blocks. Review appreciated, particularly for the cindex and template bits. llvm-svn: 125733
2011-02-17 15:39:24 +08:00
void ASTDeclReader::VisitLabelDecl(LabelDecl *D) {
VisitNamedDecl(D);
Fixed LabelDecl source range and cleaned creation code. llvm-svn: 127094
2011-03-06 02:21:20 +08:00
D->setLocStart(ReadSourceLocation(Record, Idx));
Step #1/N of implementing support for __label__: split labels into LabelDecl and LabelStmt. There is a 1-1 correspondence between the two, but this simplifies a bunch of code by itself. This is because labels are the only place where we previously had references to random other statements, causing grief for AST serialization and other stuff. This does cause one regression (attr(unused) doesn't silence unused label warnings) which I'll address next. This does fix some minor bugs: 1. "The only valid attribute " diagnostic was capitalized. 2. Various diagnostics printed as ''labelname'' instead of 'labelname' 3. This reduces duplication of label checking between functions and blocks. Review appreciated, particularly for the cindex and template bits. llvm-svn: 125733
2011-02-17 15:39:24 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitNamespaceDecl(NamespaceDecl *D) {
Switch NamespaceDecl from its own hand-rolled redeclaration chain over to Redeclarable<NamespaceDecl>, so that we benefit from the improveed redeclaration deserialization and merging logic provided by Redeclarable<T>. Otherwise, no functionality change. As a drive-by fix, collapse the "inline" bit into the low bit of the original namespace/anonymous namespace, saving 8 bytes per NamespaceDecl on x86_64. llvm-svn: 147729
2012-01-07 17:11:48 +08:00
RedeclarableResult Redecl = VisitRedeclarable(D);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
VisitNamedDecl(D);
Switch NamespaceDecl from its own hand-rolled redeclaration chain over to Redeclarable<NamespaceDecl>, so that we benefit from the improveed redeclaration deserialization and merging logic provided by Redeclarable<T>. Otherwise, no functionality change. As a drive-by fix, collapse the "inline" bit into the low bit of the original namespace/anonymous namespace, saving 8 bytes per NamespaceDecl on x86_64. llvm-svn: 147729
2012-01-07 17:11:48 +08:00
D->setInline(Record[Idx++]);
Fixed NamespaceDecl source range. llvm-svn: 127242
2011-03-08 20:38:20 +08:00
D->LocStart = ReadSourceLocation(Record, Idx);
D->RBraceLoc = ReadSourceLocation(Record, Idx);
Fix bitcode desynchronization when loading a PCH containing a class template specialization with modules enabled. Just don't merge them at all for now; we'll revisit this when support for template merging is added. In passing, make Decl::dump() a little safer to use with PCH/modules, by making it not deserialize any additional declarations. From a debugger you can call decls_begin() or similar first if you want to dump all child decls. llvm-svn: 182544
2013-05-23 09:49:11 +08:00
// FIXME: At the point of this call, D->getCanonicalDecl() returns 0.
Implement redeclaration merging for namespaces defined in distinct modules. Teach name lookup into namespaces to search in each of the merged DeclContexts as well as the (now-primary) DeclContext. This supports the common case where two different modules put something into the same namespace. llvm-svn: 147778
2012-01-10 01:30:44 +08:00
mergeRedeclarable(D, Redecl);
Switch NamespaceDecl from its own hand-rolled redeclaration chain over to Redeclarable<NamespaceDecl>, so that we benefit from the improveed redeclaration deserialization and merging logic provided by Redeclarable<T>. Otherwise, no functionality change. As a drive-by fix, collapse the "inline" bit into the low bit of the original namespace/anonymous namespace, saving 8 bytes per NamespaceDecl on x86_64. llvm-svn: 147729
2012-01-07 17:11:48 +08:00
if (Redecl.getFirstID() == ThisDeclID) {
When deserializing an anonymous namespace from a module, do not attach the anonymous namespace to its parent. Semantically, this means that the anonymous namespaces defined in one module are distinct from the anonymous namespaces defined in another module. llvm-svn: 147782
2012-01-10 02:07:24 +08:00
// Each module has its own anonymous namespace, which is disjoint from
// any other module's anonymous namespaces, so don't attach the anonymous
// namespace at all.
NamespaceDecl *Anon = ReadDeclAs<NamespaceDecl>(Record, Idx);
if (F.Kind != MK_Module)
D->setAnonymousNamespace(Anon);
Switch NamespaceDecl from its own hand-rolled redeclaration chain over to Redeclarable<NamespaceDecl>, so that we benefit from the improveed redeclaration deserialization and merging logic provided by Redeclarable<T>. Otherwise, no functionality change. As a drive-by fix, collapse the "inline" bit into the low bit of the original namespace/anonymous namespace, saving 8 bytes per NamespaceDecl on x86_64. llvm-svn: 147729
2012-01-07 17:11:48 +08:00
} else {
// Link this namespace back to the first declaration, which has already
// been deserialized.
Rename some functions for consistency. Every other function in Redeclarable.h was using Decl instead of Declaration. llvm-svn: 192900
2013-10-17 23:37:26 +08:00
D->AnonOrFirstNamespaceAndInline.setPointer(D->getFirstDecl());
Switch NamespaceDecl from its own hand-rolled redeclaration chain over to Redeclarable<NamespaceDecl>, so that we benefit from the improveed redeclaration deserialization and merging logic provided by Redeclarable<T>. Otherwise, no functionality change. As a drive-by fix, collapse the "inline" bit into the low bit of the original namespace/anonymous namespace, saving 8 bytes per NamespaceDecl on x86_64. llvm-svn: 147729
2012-01-07 17:11:48 +08:00
}
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitNamespaceAliasDecl(NamespaceAliasDecl *D) {
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
VisitNamedDecl(D);
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
D->NamespaceLoc = ReadSourceLocation(Record, Idx);
D->IdentLoc = ReadSourceLocation(Record, Idx);
Push nested-name-specifier source location information into namespace aliases. llvm-svn: 126496
2011-02-26 01:08:07 +08:00
D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
D->Namespace = ReadDeclAs<NamedDecl>(Record, Idx);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitUsingDecl(UsingDecl *D) {
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
VisitNamedDecl(D);
Improve clarity/consistency of a few UsingDecl methods and related helpers. No functionality change. In Sema helper functions: * renamed isTypeName as HasTypenameKeyword In UsingDecl: * renamed get/setUsingLocation to get/setUsingLoc * renamed is/setTypeName as has/setTypename llvm-svn: 186816
2013-07-22 18:54:09 +08:00
D->setUsingLoc(ReadSourceLocation(Record, Idx));
Update UsingDecl, UnresolvedUsingTypenameDecl, and UnresolvedUsingValueDecl to use NestedNameSpecifierLoc rather than the extremely-lossy NestedNameSpecifier/SourceRange pair it used to use, improving source-location information. Various infrastructure updates to support NestedNameSpecifierLoc: - AST/PCH (de-)serialization - Recursive AST visitor - libclang traversal (including the first tests of this functionality) llvm-svn: 126459
2011-02-25 08:36:19 +08:00
D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
Read/write to/from PCH DeclarationNameLocs, DeclarationNameInfos and QualifierInfos (rdar://8513756). llvm-svn: 116598
2010-10-16 02:21:24 +08:00
ReadDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record, Idx);
Pack UsingDecl more. 88 -> 80 bytes on x86_64. llvm-svn: 147736
2012-01-08 03:09:05 +08:00
D->FirstUsingShadow.setPointer(ReadDeclAs<UsingShadowDecl>(Record, Idx));
Improve clarity/consistency of a few UsingDecl methods and related helpers. No functionality change. In Sema helper functions: * renamed isTypeName as HasTypenameKeyword In UsingDecl: * renamed get/setUsingLocation to get/setUsingLoc * renamed is/setTypeName as has/setTypename llvm-svn: 186816
2013-07-22 18:54:09 +08:00
D->setTypename(Record[Idx++]);
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
if (NamedDecl *Pattern = ReadDeclAs<NamedDecl>(Record, Idx))
In ASTReader, replace the never-NULL ASTContext pointer with an ASTContext reference. Remove all of the extra checking and logic that was used to cope with a NULL ASTContext. No effective functionality change. llvm-svn: 139413
2011-09-10 05:34:22 +08:00
Reader.getContext().setInstantiatedFromUsingDecl(D, Pattern);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitUsingShadowDecl(UsingShadowDecl *D) {
Make UsingShadowDecls redeclarable. This fixes some visibility problems with modules. With this fixed, I no longer see any test regressions in the libc++ test suite when enabling a single-module module.map for libc++ (other than issues with my system headers). llvm-svn: 193219
2013-10-23 10:17:46 +08:00
RedeclarableResult Redecl = VisitRedeclarable(D);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
VisitNamedDecl(D);
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
D->setTargetDecl(ReadDeclAs<NamedDecl>(Record, Idx));
D->UsingOrNextShadow = ReadDeclAs<NamedDecl>(Record, Idx);
UsingShadowDecl *Pattern = ReadDeclAs<UsingShadowDecl>(Record, Idx);
Read/write more information of ASTContext for PCH. Overriden methods and instantiated-from information. llvm-svn: 107597
2010-07-05 05:44:35 +08:00
if (Pattern)
In ASTReader, replace the never-NULL ASTContext pointer with an ASTContext reference. Remove all of the extra checking and logic that was used to cope with a NULL ASTContext. No effective functionality change. llvm-svn: 139413
2011-09-10 05:34:22 +08:00
Reader.getContext().setInstantiatedFromUsingShadowDecl(D, Pattern);
Make UsingShadowDecls redeclarable. This fixes some visibility problems with modules. With this fixed, I no longer see any test regressions in the libc++ test suite when enabling a single-module module.map for libc++ (other than issues with my system headers). llvm-svn: 193219
2013-10-23 10:17:46 +08:00
mergeRedeclarable(D, Redecl);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
VisitNamedDecl(D);
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
D->UsingLoc = ReadSourceLocation(Record, Idx);
D->NamespaceLoc = ReadSourceLocation(Record, Idx);
Push nested-name-specifier source location information into using directives. llvm-svn: 126489
2011-02-26 00:33:46 +08:00
D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
D->NominatedNamespace = ReadDeclAs<NamedDecl>(Record, Idx);
D->CommonAncestor = ReadDeclAs<DeclContext>(Record, Idx);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) {
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
VisitValueDecl(D);
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
D->setUsingLoc(ReadSourceLocation(Record, Idx));
Update UsingDecl, UnresolvedUsingTypenameDecl, and UnresolvedUsingValueDecl to use NestedNameSpecifierLoc rather than the extremely-lossy NestedNameSpecifier/SourceRange pair it used to use, improving source-location information. Various infrastructure updates to support NestedNameSpecifierLoc: - AST/PCH (de-)serialization - Recursive AST visitor - libclang traversal (including the first tests of this functionality) llvm-svn: 126459
2011-02-25 08:36:19 +08:00
D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
Read/write to/from PCH DeclarationNameLocs, DeclarationNameInfos and QualifierInfos (rdar://8513756). llvm-svn: 116598
2010-10-16 02:21:24 +08:00
ReadDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record, Idx);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitUnresolvedUsingTypenameDecl(
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
UnresolvedUsingTypenameDecl *D) {
VisitTypeDecl(D);
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
D->TypenameLocation = ReadSourceLocation(Record, Idx);
Update UsingDecl, UnresolvedUsingTypenameDecl, and UnresolvedUsingValueDecl to use NestedNameSpecifierLoc rather than the extremely-lossy NestedNameSpecifier/SourceRange pair it used to use, improving source-location information. Various infrastructure updates to support NestedNameSpecifierLoc: - AST/PCH (de-)serialization - Recursive AST visitor - libclang traversal (including the first tests of this functionality) llvm-svn: 126459
2011-02-25 08:36:19 +08:00
D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
}
Minor refactoring; Pull reading/writing DefinitionData out into a function. llvm-svn: 117233
2010-10-25 01:26:27 +08:00
void ASTDeclReader::ReadCXXDefinitionData(
Refactoring. - Pass around RecordDataImpl instead of the concrete RecordData so that any SmallVector can be used. - Move ASTDeclWriter::WriteCXXDefinitionData to ASTWriter::AddCXXDefinitionData. llvm-svn: 117236
2010-10-25 01:26:40 +08:00
struct CXXRecordDecl::DefinitionData &Data,
const RecordData &Record, unsigned &Idx) {
Implement AST (de-)serialization for lambda expressions. llvm-svn: 150491
2012-02-15 01:54:36 +08:00
// Note: the caller has deserialized the IsLambda bit already.
Minor refactoring; Pull reading/writing DefinitionData out into a function. llvm-svn: 117233
2010-10-25 01:26:27 +08:00
Data.UserDeclaredConstructor = Record[Idx++];
Refactor to reduce duplication in handling of special member functions. No functionality change. llvm-svn: 168977
2012-11-30 13:11:39 +08:00
Data.UserDeclaredSpecialMembers = Record[Idx++];
Minor refactoring; Pull reading/writing DefinitionData out into a function. llvm-svn: 117233
2010-10-25 01:26:27 +08:00
Data.Aggregate = Record[Idx++];
Data.PlainOldData = Record[Idx++];
Data.Empty = Record[Idx++];
Data.Polymorphic = Record[Idx++];
Data.Abstract = Record[Idx++];
Rename the last '[hH]asStandardLayout' entites to '[iI]sStandardLayout' based on Doug's preferences when we discussed this in IRC. This brings the wording more in line with the standard. llvm-svn: 130603
2011-04-30 18:07:30 +08:00
Data.IsStandardLayout = Record[Idx++];
Completely re-implement the core logic behind the __is_standard_layout type trait. The previous implementation suffered from several problems: 1) It implemented all of the logic in RecordType by walking over every base and field in a CXXRecordDecl and validating the constraints of the standard. This made for very straightforward code, but is extremely inefficient. It also is conceptually wrong, the logic tied to the C++ definition of standard-layout classes should be in CXXRecordDecl, not RecordType. 2) To address the performance problems with #1, a cache bit was added to CXXRecordDecl, and at the completion of every C++ class, the RecordType was queried to determine if it was a standard layout class, and that state was cached. Two things went very very wrong with this. First, the caching version of the query *was never called*. Even within the recursive steps of the walk over all fields and bases the caching variant was not called, making each query a full *recursive* walk. Second, despite the cache not being used, it was computed for every class declared, even when the trait was never used in the program. This probably significantly regressed compile time performance for edge-case files. 3) An ASTContext was required merely to query the type trait because querying it performed the actual computations. 4) The caching bit wasn't managed correctly (uninitialized). The new implementation follows the system for all the other traits on C++ classes by encoding all the state needed in the definition data and building up the trait incrementally as each base and member are added to the definition of the class. The idiosyncracies of the specification of standard-layout classes requires more state than I would like; currently 5 bits. I could eliminate one of the bits easily at the expense of both clarity and resilience of the code. I might be able to eliminate one of the other bits by computing its state in terms of other state bits in the definition. I've already done that in one place where there was a fairly simple way to achieve it. It's possible some of the bits could be moved out of the definition data and into some other structure which isn't serialized if the serialized bloat is a problem. That would preclude serialization of a partial class declaration, but that's likely already precluded. Comments on any of these issues welcome. llvm-svn: 130601
2011-04-30 17:17:45 +08:00
Data.HasNoNonEmptyBases = Record[Idx++];
Data.HasPrivateFields = Record[Idx++];
Data.HasProtectedFields = Record[Idx++];
Data.HasPublicFields = Record[Idx++];
When determining whether we can make a declaration into a global constant, also consider whether it's a class type that has any mutable fields. If so, it can't be a global constant. llvm-svn: 131276
2011-05-13 09:05:07 +08:00
Data.HasMutableFields = Record[Idx++];
Implement DR1460: fix handling of default initializers in unions; don't allow more than one such initializer in a union, make mem-initializers override default initializers for other union members, handle anonymous unions with anonymous struct members better. Fix a couple of semi-related bugs exposed by the tests for same. llvm-svn: 196892
2013-12-10 16:25:00 +08:00
Data.HasVariantMembers = Record[Idx++];
Teach CXXRecordDecl::hasIrrelevantDestructor to check the base classes and data members for deleted or user-provided destructors. Now it's computed in advance, serialize it, and in passing fix all the other record DefinitionData flags whose serialization was missing. llvm-svn: 151441
2012-02-25 15:33:38 +08:00
Data.HasOnlyCMembers = Record[Idx++];
A union can have a constexpr defaulted default constructor, if it has an in-class initializer for one of its fields. Value-initialization of such a type should use the in-class initializer! The former was just a bug, the latter is a (reported) standard defect. llvm-svn: 156274
2012-05-07 09:07:30 +08:00
Data.HasInClassInitializer = Record[Idx++];
Implement C++03 [dcl.init]p5's checking for value-initialization of references properly, rather than faking it up by pretending that a reference member makes the default constructor non-trivial. That leads to rejects-valids when putting such types inside unions. llvm-svn: 169662
2012-12-08 10:01:17 +08:00
Data.HasUninitializedReferenceMember = Record[Idx++];
Finish implementing 'selected constructor' rules for triviality in C++11. In the cases where we can't determine whether special members would be trivial while building the class, we eagerly declare those special members. The impact of this is bounded, since it does not trigger implicit declarations of special members in classes which merely *use* those classes. In order to determine whether we need to apply this rule, we also need to eagerly declare move operations and destructors in cases where they might be deleted. If a move operation were supposed to be deleted, it would instead be suppressed, and we could need overload resolution to determine if we fall back to a trivial copy operation. If a destructor were implicitly deleted, it would cause the move constructor of any derived classes to be suppressed. As discussed on cxx-abi-dev, C++11's selected constructor rules are also retroactively applied as a defect resolution in C++03 mode, in order to identify that class B has a non-trivial copy constructor (since it calls A's constructor template, not A's copy constructor): struct A { template<typename T> A(T &); }; struct B { mutable A a; }; llvm-svn: 169673
2012-12-08 16:32:28 +08:00
Data.NeedOverloadResolutionForMoveConstructor = Record[Idx++];
Data.NeedOverloadResolutionForMoveAssignment = Record[Idx++];
Data.NeedOverloadResolutionForDestructor = Record[Idx++];
Data.DefaultedMoveConstructorIsDeleted = Record[Idx++];
Data.DefaultedMoveAssignmentIsDeleted = Record[Idx++];
Data.DefaultedDestructorIsDeleted = Record[Idx++];
Refactor to reduce duplication in handling of special member functions. No functionality change. llvm-svn: 168977
2012-11-30 13:11:39 +08:00
Data.HasTrivialSpecialMembers = Record[Idx++];
Add missing serialization code for one of the CXXRecordDecl definition flags. llvm-svn: 206493
2014-04-18 04:33:01 +08:00
Data.DeclaredNonTrivialSpecialMembers = Record[Idx++];
Refactor to reduce duplication in handling of special member functions. No functionality change. llvm-svn: 168977
2012-11-30 13:11:39 +08:00
Data.HasIrrelevantDestructor = Record[Idx++];
Renamings to consistently use 'Constexpr' not 'ConstExpr' when referring to the C++0x 'constexpr' keyword. llvm-svn: 137230
2011-08-11 02:11:37 +08:00
Data.HasConstexprNonCopyMoveConstructor = Record[Idx++];
Teach CXXRecordDecl::hasIrrelevantDestructor to check the base classes and data members for deleted or user-provided destructors. Now it's computed in advance, serialize it, and in passing fix all the other record DefinitionData flags whose serialization was missing. llvm-svn: 151441
2012-02-25 15:33:38 +08:00
Data.DefaultedDefaultConstructorIsConstexpr = Record[Idx++];
Data.HasConstexprDefaultConstructor = Record[Idx++];
Implement most of the remaining logic in __is_literal type trait. This should now support all of the C++98 types, and all of the C++0x types Clang supports. llvm-svn: 130079
2011-04-24 10:49:34 +08:00
Data.HasNonLiteralTypeFieldsOrBases = Record[Idx++];
Minor refactoring; Pull reading/writing DefinitionData out into a function. llvm-svn: 117233
2010-10-25 01:26:27 +08:00
Data.ComputedVisibleConversions = Record[Idx++];
Implement implicit deletion of default constructors. Yes, I'm aware that the diagnostics are awful. Tests to follow. llvm-svn: 131203
2011-05-12 06:34:38 +08:00
Data.UserProvidedDefaultConstructor = Record[Idx++];
Refactor to reduce duplication in handling of special member functions. No functionality change. llvm-svn: 168977
2012-11-30 13:11:39 +08:00
Data.DeclaredSpecialMembers = Record[Idx++];
Store on the CXXRecordDecl whether the class has, or would have, a copy constructor/assignment operator with a const-qualified parameter type. The prior method for determining this incorrectly used overload resolution. llvm-svn: 168775
2012-11-28 14:23:12 +08:00
Data.ImplicitCopyConstructorHasConstParam = Record[Idx++];
Data.ImplicitCopyAssignmentHasConstParam = Record[Idx++];
Data.HasDeclaredCopyConstructorWithConstParam = Record[Idx++];
Data.HasDeclaredCopyAssignmentWithConstParam = Record[Idx++];
Serialize and deserialize IsMarkedFinal/IsMarkedExplicit. llvm-svn: 124041
2011-01-23 02:11:02 +08:00
Minor refactoring; Pull reading/writing DefinitionData out into a function. llvm-svn: 117233
2010-10-25 01:26:27 +08:00
Data.NumBases = Record[Idx++];
Make the deserialization of C++ base class specifiers lazy, improving the performance of C++ PCH and reducing stack depth in the reader. llvm-svn: 117732
2010-10-30 06:39:52 +08:00
if (Data.NumBases)
Don't introduce a local -> global mapping for CXXBaseSpecifiers. The IDs will never cross module boundaries, since they're tied to the CXXDefinitionData, so just use a local mapping throughout. Eliminate the global -> local tables and supporting data. llvm-svn: 136847
2011-08-04 08:01:48 +08:00
Data.Bases = Reader.readCXXBaseSpecifiers(F, Record, Idx);
Minor refactoring; Pull reading/writing DefinitionData out into a function. llvm-svn: 117233
2010-10-25 01:26:27 +08:00
Data.NumVBases = Record[Idx++];
Make the deserialization of C++ base class specifiers lazy, improving the performance of C++ PCH and reducing stack depth in the reader. llvm-svn: 117732
2010-10-30 06:39:52 +08:00
if (Data.NumVBases)
Don't introduce a local -> global mapping for CXXBaseSpecifiers. The IDs will never cross module boundaries, since they're tied to the CXXDefinitionData, so just use a local mapping throughout. Eliminate the global -> local tables and supporting data. llvm-svn: 136847
2011-08-04 08:01:48 +08:00
Data.VBases = Reader.readCXXBaseSpecifiers(F, Record, Idx);
Make the deserialization of C++ base class specifiers lazy, improving the performance of C++ PCH and reducing stack depth in the reader. llvm-svn: 117732
2010-10-30 06:39:52 +08:00
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
Reader.ReadUnresolvedSet(F, Data.Conversions, Record, Idx);
Reader.ReadUnresolvedSet(F, Data.VisibleConversions, Record, Idx);
Minor refactoring; Pull reading/writing DefinitionData out into a function. llvm-svn: 117233
2010-10-25 01:26:27 +08:00
assert(Data.Definition && "Data.Definition should be already set!");
Map from local decl IDs to global decl IDs when lazily deserializing friend decl chains. llvm-svn: 189629
2013-08-30 08:23:29 +08:00
Data.FirstFriend = ReadDeclID(Record, Idx);
Implement AST (de-)serialization for lambda expressions. llvm-svn: 150491
2012-02-15 01:54:36 +08:00
if (Data.IsLambda) {
typedef LambdaExpr::Capture Capture;
CXXRecordDecl::LambdaDefinitionData &Lambda
= static_cast<CXXRecordDecl::LambdaDefinitionData &>(Data);
Improve our handling of lambda expressions that occur within default arguments. There are two aspects to this: - Make sure that when marking the declarations referenced in a default argument, we don't try to mark local variables, both because it's a waste of time and because the semantics are wrong: we're not in a place where we could capture these variables again even if it did make sense. - When a lambda expression occurs in a default argument of a function template, make sure that the corresponding closure type is considered dependent, so that it will get properly instantiated. The second bit is a bit of a hack; to fix it properly, we may have to rearchitect our handling of default arguments, parsing them only after creating the function definition. However, I'd like to separate that work from the lambdas work. llvm-svn: 151076
2012-02-22 03:11:17 +08:00
Lambda.Dependent = Record[Idx++];
Refactor out the circular reference to LambdaExpr in CXXRecordDecl. A prior commit of this patch was reverted because it was within the blamelist's purview of a failing test. The failure of that test has been addressed here: http://lists.cs.uiuc.edu/pipermail/cfe-commits/Week-of-Mon-20131021/091546.html. Therefore I am recommitting this patch (all tests pass on windows, except for the usual modules & index suspects that never pass on my box). Some background: Both Doug and Richard had asked me in Chicago to remove the circular reference in CXXRecordDecl to LambdaExpr by factoring out and storing the needed information from LambdaExpr directly into CXXRecordDecl. In addition, I have added an IsGenericLambda flag - this makes life a little easier when we implement capturing, and are Sema-analyzing the body of a lambda (and the calloperator hasn't been wired to the closure class yet). Any inner lambdas can have potential captures that could require walking up the scope chain and checking if any generic lambdas are capture-ready. This 'bit' makes some of that checking easier. No change in functionality. This patch was approved by Doug with minor modifications (comments were cleaned up, and all data members were converted from bool/enum to unsigned, as requested): http://llvm-reviews.chandlerc.com/D1856 Thanks! llvm-svn: 193246
2013-10-24 00:10:50 +08:00
Lambda.IsGenericLambda = Record[Idx++];
Lambda.CaptureDefault = Record[Idx++];
Implement AST (de-)serialization for lambda expressions. llvm-svn: 150491
2012-02-15 01:54:36 +08:00
Lambda.NumCaptures = Record[Idx++];
Lambda.NumExplicitCaptures = Record[Idx++];
Basic support for name mangling of C++11 lambda expressions. Because name mangling in the Itanium C++ ABI for lambda expressions is so dependent on context, we encode the number used to encode each lambda as part of the lambda closure type, and maintain this value within Sema. Note that there are a several pieces still missing: - We still get the linkage of lambda expressions wrong - We aren't properly numbering or mangling lambda expressions that occur in default function arguments or in data member initializers. - We aren't (de-)serializing the lambda numbering tables llvm-svn: 150982
2012-02-21 03:44:39 +08:00
Lambda.ManglingNumber = Record[Idx++];
Implement name mangling for lambda expressions that occur within the default arguments of function parameters. This simple-sounding task is complicated greatly by two issues: (1) Default arguments aren't actually a real context, so we need to maintain extra state within lambda expressions to track when a lambda was actually in a default argument. (2) At the time that we parse a default argument, the FunctionDecl doesn't exist yet, so lambda closure types end up in the enclosing context. It's not clear that we ever want to change that, so instead we introduce the notion of the "effective" context of a declaration for the purposes of name mangling. llvm-svn: 151011
2012-02-21 08:37:24 +08:00
Lambda.ContextDecl = ReadDecl(Record, Idx);
Implement AST (de-)serialization for lambda expressions. llvm-svn: 150491
2012-02-15 01:54:36 +08:00
Lambda.Captures
= (Capture*)Reader.Context.Allocate(sizeof(Capture)*Lambda.NumCaptures);
Capture *ToCapture = Lambda.Captures;
Add the TypeSourceInfo for the lambda call operator to the lambda's definition info; it needs to be there because the mangler needs to access it before we're finished defining the lambda class. PR12808. llvm-svn: 164186
2012-09-19 09:18:11 +08:00
Lambda.MethodTyInfo = GetTypeSourceInfo(Record, Idx);
Implement AST (de-)serialization for lambda expressions. llvm-svn: 150491
2012-02-15 01:54:36 +08:00
for (unsigned I = 0, N = Lambda.NumCaptures; I != N; ++I) {
SourceLocation Loc = ReadSourceLocation(Record, Idx);
bool IsImplicit = Record[Idx++];
LambdaCaptureKind Kind = static_cast<LambdaCaptureKind>(Record[Idx++]);
First pass of semantic analysis for init-captures: check the initializer, build a FieldDecl from it, and propagate both into the closure type and the LambdaExpr. You can't do much useful with them yet -- you can't use them within the body of the lambda, because we don't have a representation for "the this of the lambda, not the this of the enclosing context". We also don't have support or a representation for a nested capture of an init-capture yet, which was intended to work despite not being allowed by the current standard wording. llvm-svn: 181985
2013-05-16 14:20:58 +08:00
switch (Kind) {
case LCK_This:
*ToCapture++ = Capture(Loc, IsImplicit, Kind, 0, SourceLocation());
break;
case LCK_ByCopy:
Per latest drafting, switch to implementing init-captures as if by declaring and capturing a variable declaration, and complete the implementation of them. llvm-svn: 191605
2013-09-28 12:02:39 +08:00
case LCK_ByRef:
First pass of semantic analysis for init-captures: check the initializer, build a FieldDecl from it, and propagate both into the closure type and the LambdaExpr. You can't do much useful with them yet -- you can't use them within the body of the lambda, because we don't have a representation for "the this of the lambda, not the this of the enclosing context". We also don't have support or a representation for a nested capture of an init-capture yet, which was intended to work despite not being allowed by the current standard wording. llvm-svn: 181985
2013-05-16 14:20:58 +08:00
VarDecl *Var = ReadDeclAs<VarDecl>(Record, Idx);
SourceLocation EllipsisLoc = ReadSourceLocation(Record, Idx);
*ToCapture++ = Capture(Loc, IsImplicit, Kind, Var, EllipsisLoc);
break;
}
Implement AST (de-)serialization for lambda expressions. llvm-svn: 150491
2012-02-15 01:54:36 +08:00
}
}
Minor refactoring; Pull reading/writing DefinitionData out into a function. llvm-svn: 117233
2010-10-25 01:26:27 +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
void ASTDeclReader::MergeDefinitionData(
CXXRecordDecl *D, struct CXXRecordDecl::DefinitionData &MergeDD) {
assert(D->DefinitionData && "merging class definition into non-definition");
auto &DD = *D->DefinitionData;
// If the new definition has new special members, let the name lookup
// code know that it needs to look in the new definition too.
if ((MergeDD.DeclaredSpecialMembers & ~DD.DeclaredSpecialMembers) &&
DD.Definition != MergeDD.Definition) {
Reader.MergedLookups[DD.Definition].push_back(MergeDD.Definition);
DD.Definition->setHasExternalVisibleStorage();
}
// FIXME: Move this out into a .def file?
// FIXME: Issue a diagnostic on a mismatched MATCH_FIELD, rather than
// asserting; this can happen in the case of an ODR violation.
bool DetectedOdrViolation = false;
#define OR_FIELD(Field) DD.Field |= MergeDD.Field;
#define MATCH_FIELD(Field) \
DetectedOdrViolation |= DD.Field != MergeDD.Field; \
OR_FIELD(Field)
MATCH_FIELD(UserDeclaredConstructor)
MATCH_FIELD(UserDeclaredSpecialMembers)
MATCH_FIELD(Aggregate)
MATCH_FIELD(PlainOldData)
MATCH_FIELD(Empty)
MATCH_FIELD(Polymorphic)
MATCH_FIELD(Abstract)
MATCH_FIELD(IsStandardLayout)
MATCH_FIELD(HasNoNonEmptyBases)
MATCH_FIELD(HasPrivateFields)
MATCH_FIELD(HasProtectedFields)
MATCH_FIELD(HasPublicFields)
MATCH_FIELD(HasMutableFields)
MATCH_FIELD(HasVariantMembers)
MATCH_FIELD(HasOnlyCMembers)
MATCH_FIELD(HasInClassInitializer)
MATCH_FIELD(HasUninitializedReferenceMember)
MATCH_FIELD(NeedOverloadResolutionForMoveConstructor)
MATCH_FIELD(NeedOverloadResolutionForMoveAssignment)
MATCH_FIELD(NeedOverloadResolutionForDestructor)
MATCH_FIELD(DefaultedMoveConstructorIsDeleted)
MATCH_FIELD(DefaultedMoveAssignmentIsDeleted)
MATCH_FIELD(DefaultedDestructorIsDeleted)
OR_FIELD(HasTrivialSpecialMembers)
OR_FIELD(DeclaredNonTrivialSpecialMembers)
MATCH_FIELD(HasIrrelevantDestructor)
OR_FIELD(HasConstexprNonCopyMoveConstructor)
MATCH_FIELD(DefaultedDefaultConstructorIsConstexpr)
OR_FIELD(HasConstexprDefaultConstructor)
MATCH_FIELD(HasNonLiteralTypeFieldsOrBases)
// ComputedVisibleConversions is handled below.
MATCH_FIELD(UserProvidedDefaultConstructor)
OR_FIELD(DeclaredSpecialMembers)
MATCH_FIELD(ImplicitCopyConstructorHasConstParam)
MATCH_FIELD(ImplicitCopyAssignmentHasConstParam)
OR_FIELD(HasDeclaredCopyConstructorWithConstParam)
OR_FIELD(HasDeclaredCopyAssignmentWithConstParam)
MATCH_FIELD(IsLambda)
#undef OR_FIELD
#undef MATCH_FIELD
if (DD.NumBases != MergeDD.NumBases || DD.NumVBases != MergeDD.NumVBases)
DetectedOdrViolation = true;
// FIXME: Issue a diagnostic if the base classes don't match when we come
// to lazily load them.
// FIXME: Issue a diagnostic if the list of conversion functions doesn't
// match when we come to lazily load them.
if (MergeDD.ComputedVisibleConversions && !DD.ComputedVisibleConversions) {
DD.VisibleConversions = std::move(MergeDD.VisibleConversions);
DD.ComputedVisibleConversions = true;
}
// FIXME: Issue a diagnostic if FirstFriend doesn't match when we come to
// lazily load it.
if (DD.IsLambda) {
// FIXME: ODR-checking for merging lambdas (this happens, for instance,
// when they occur within the body of a function template specialization).
}
if (DetectedOdrViolation)
Reader.PendingOdrMergeFailures[DD.Definition].push_back(MergeDD.Definition);
}
void ASTDeclReader::ReadCXXRecordDefinition(CXXRecordDecl *D) {
struct CXXRecordDecl::DefinitionData *DD;
ASTContext &C = Reader.getContext();
// Determine whether this is a lambda closure type, so that we can
// allocate the appropriate DefinitionData structure.
bool IsLambda = Record[Idx++];
if (IsLambda)
DD = new (C) CXXRecordDecl::LambdaDefinitionData(D, 0, false, false,
LCD_None);
else
DD = new (C) struct CXXRecordDecl::DefinitionData(D);
ReadCXXDefinitionData(*DD, Record, Idx);
// If we're reading an update record, we might already have a definition for
// this record. If so, just merge into it.
if (D->DefinitionData) {
MergeDefinitionData(D, *DD);
return;
}
// Propagate the DefinitionData pointer to the canonical declaration, so
// that all other deserialized declarations will see it.
CXXRecordDecl *Canon = D->getCanonicalDecl();
if (Canon == D) {
D->DefinitionData = DD;
D->IsCompleteDefinition = true;
} else if (!Canon->DefinitionData) {
Canon->DefinitionData = D->DefinitionData = DD;
D->IsCompleteDefinition = true;
// Note that we have deserialized a definition. Any declarations
// deserialized before this one will be be given the DefinitionData
// pointer at the end.
Reader.PendingDefinitions.insert(D);
} else {
// We have already deserialized a definition of this record. This
// definition is no longer really a definition. Note that the pre-existing
// definition is the *real* definition.
Reader.MergedDeclContexts.insert(
std::make_pair(D, Canon->DefinitionData->Definition));
D->DefinitionData = D->getCanonicalDecl()->DefinitionData;
D->IsCompleteDefinition = false;
MergeDefinitionData(D, *DD);
}
}
Fix bitcode desynchronization when loading a PCH containing a class template specialization with modules enabled. Just don't merge them at all for now; we'll revisit this when support for template merging is added. In passing, make Decl::dump() a little safer to use with PCH/modules, by making it not deserialize any additional declarations. From a debugger you can call decls_begin() or similar first if you want to dump all child decls. llvm-svn: 182544
2013-05-23 09:49:11 +08:00
ASTDeclReader::RedeclarableResult
ASTDeclReader::VisitCXXRecordDeclImpl(CXXRecordDecl *D) {
RedeclarableResult Redecl = VisitRecordDeclImpl(D);
Fix issue with chained PCH where forward references did not pick up later definition in the chained PCH. llvm-svn: 116887
2010-10-20 08:11:15 +08:00
Now that deserializing a definition of a C++ class/Objective-C class/Objective-C protocol suffices get all of the redeclarations of that declaration wired to the definition, we no longer need to record the identity of the definition in every declaration. Instead, just record a bit to indicate whether a particular declaration is the definition. llvm-svn: 148224
2012-01-16 02:17:48 +08:00
ASTContext &C = Reader.getContext();
Fully read/write CXXRecordDecl for PCH. llvm-svn: 107475
2010-07-02 19:55:32 +08:00
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +08:00
enum CXXRecKind {
CXXRecNotTemplate = 0, CXXRecTemplate, CXXRecMemberSpecialization
};
switch ((CXXRecKind)Record[Idx++]) {
case CXXRecNotTemplate:
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
mergeRedeclarable(D, Redecl);
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +08:00
break;
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
case CXXRecTemplate: {
// Merged when we merge the template.
ClassTemplateDecl *Template = ReadDeclAs<ClassTemplateDecl>(Record, Idx);
D->TemplateOrInstantiation = Template;
if (!Template->getTemplatedDecl()) {
// We've not actually loaded the ClassTemplateDecl yet, because we're
// currently being loaded as its pattern. Rely on it to set up our
// TypeForDecl (see VisitClassTemplateDecl).
//
// Beware: we do not yet know our canonical declaration, and may still
// get merged once the surrounding class template has got off the ground.
TypeIDForTypeDecl = 0;
}
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +08:00
break;
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
}
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +08:00
case CXXRecMemberSpecialization: {
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
CXXRecordDecl *RD = ReadDeclAs<CXXRecordDecl>(Record, Idx);
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +08:00
TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
SourceLocation POI = ReadSourceLocation(Record, Idx);
Avoid setters in ASTDeclReader::VisitCXXRecordDecl. llvm-svn: 113741
2010-09-13 19:45:25 +08:00
MemberSpecializationInfo *MSI = new (C) MemberSpecializationInfo(RD, TSK);
MSI->setPointOfInstantiation(POI);
D->TemplateOrInstantiation = MSI;
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
mergeRedeclarable(D, Redecl);
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +08:00
break;
}
}
Store in PCH the key function of C++ class to avoid deserializing the complete declaration context in order to compute it. Progress for rdar://7260160. llvm-svn: 116508
2010-10-15 04:14:38 +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
bool WasDefinition = Record[Idx++];
if (WasDefinition)
ReadCXXRecordDefinition(D);
else
// Propagate DefinitionData pointer from the canonical declaration.
D->DefinitionData = D->getCanonicalDecl()->DefinitionData;
Be lazier when loading KeyFunctions from PCH/modules. We don't need to load these in eagerly if we're not actually processing a translation unit. The added laziness here also avoids us loading in parts of a CXXRecordDecl earlier than an upcoming class template specialization merging patch would like. Ideally, we should mark the vtable as used when we see a definition for the key function, rather than having a separate pass over dynamic classes at the end of the TU. The existing approach is pretty bad for PCH/modules, since it forcibly loads the declarations of all key functions in all imported modules, whether or not those key functions are defined. llvm-svn: 189627
2013-08-30 07:59:27 +08:00
// Lazily load the key function to avoid deserializing every method so we can
Store in PCH the key function of C++ class to avoid deserializing the complete declaration context in order to compute it. Progress for rdar://7260160. llvm-svn: 116508
2010-10-15 04:14:38 +08:00
// compute it.
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
if (WasDefinition) {
DeclID KeyFn = ReadDeclID(Record, Idx);
if (KeyFn && D->IsCompleteDefinition)
Be lazier when loading KeyFunctions from PCH/modules. We don't need to load these in eagerly if we're not actually processing a translation unit. The added laziness here also avoids us loading in parts of a CXXRecordDecl earlier than an upcoming class template specialization merging patch would like. Ideally, we should mark the vtable as used when we see a definition for the key function, rather than having a separate pass over dynamic classes at the end of the TU. The existing approach is pretty bad for PCH/modules, since it forcibly loads the declarations of all key functions in all imported modules, whether or not those key functions are defined. llvm-svn: 189627
2013-08-30 07:59:27 +08:00
C.KeyFunctions[D] = KeyFn;
Store in PCH the key function of C++ class to avoid deserializing the complete declaration context in order to compute it. Progress for rdar://7260160. llvm-svn: 116508
2010-10-15 04:14:38 +08:00
}
Fix bitcode desynchronization when loading a PCH containing a class template specialization with modules enabled. Just don't merge them at all for now; we'll revisit this when support for template merging is added. In passing, make Decl::dump() a little safer to use with PCH/modules, by making it not deserialize any additional declarations. From a debugger you can call decls_begin() or similar first if you want to dump all child decls. llvm-svn: 182544
2013-05-23 09:49:11 +08:00
return Redecl;
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitCXXMethodDecl(CXXMethodDecl *D) {
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
VisitFunctionDecl(D);
Read/write more information of ASTContext for PCH. Overriden methods and instantiated-from information. llvm-svn: 107597
2010-07-05 05:44:35 +08:00
unsigned NumOverridenMethods = Record[Idx++];
while (NumOverridenMethods--) {
// Avoid invariant checking of CXXMethodDecl::addOverriddenMethod,
// MD may be initializing.
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
if (CXXMethodDecl *MD = ReadDeclAs<CXXMethodDecl>(Record, Idx))
In ASTReader, replace the never-NULL ASTContext pointer with an ASTContext reference. Remove all of the extra checking and logic that was used to cope with a NULL ASTContext. No effective functionality change. llvm-svn: 139413
2011-09-10 05:34:22 +08:00
Reader.getContext().addOverriddenMethod(D, MD);
Read/write more information of ASTContext for PCH. Overriden methods and instantiated-from information. llvm-svn: 107597
2010-07-05 05:44:35 +08:00
}
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
VisitCXXMethodDecl(D);
Fix PR18307: Properly (de)serialize inherited constructors and their using declarations Reviewed in http://llvm-reviews.chandlerc.com/D3102 llvm-svn: 204951
2014-03-28 03:22:19 +08:00
if (auto *CD = ReadDeclAs<CXXConstructorDecl>(Record, Idx))
D->setInheritedConstructor(CD);
Handle CXXConstructorDecl, CXXDestructorDecl, and CXXConversionDecl for PCH. <vector> header can be used correctly through PCH now. llvm-svn: 107483
2010-07-02 23:58:43 +08:00
D->IsExplicitSpecified = 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
// FIXME: We should defer loading this until we need the constructor's body.
[C++11] Replace llvm::tie with std::tie. llvm-svn: 202639
2014-03-02 21:01:17 +08:00
std::tie(D->CtorInitializers, D->NumCtorInitializers) =
Reader.ReadCXXCtorInitializers(F, Record, Idx);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitCXXDestructorDecl(CXXDestructorDecl *D) {
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
VisitCXXMethodDecl(D);
Handle CXXConstructorDecl, CXXDestructorDecl, and CXXConversionDecl for PCH. <vector> header can be used correctly through PCH now. llvm-svn: 107483
2010-07-02 23:58:43 +08:00
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
D->OperatorDelete = ReadDeclAs<FunctionDecl>(Record, Idx);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitCXXConversionDecl(CXXConversionDecl *D) {
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
VisitCXXMethodDecl(D);
Handle CXXConstructorDecl, CXXDestructorDecl, and CXXConversionDecl for PCH. <vector> header can be used correctly through PCH now. llvm-svn: 107483
2010-07-02 23:58:43 +08:00
D->IsExplicitSpecified = Record[Idx++];
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
}
Introduce a module import declaration, so that we properly represent, e.g., __import_module__ std.vector; in the AST. llvm-svn: 145725
2011-12-03 07:23:56 +08:00
void ASTDeclReader::VisitImportDecl(ImportDecl *D) {
VisitDecl(D);
D->ImportedAndComplete.setPointer(readModule(Record, Idx));
D->ImportedAndComplete.setInt(Record[Idx++]);
SourceLocation *StoredLocs = reinterpret_cast<SourceLocation *>(D + 1);
for (unsigned I = 0, N = Record.back(); I != N; ++I)
StoredLocs[I] = ReadSourceLocation(Record, Idx);
[PCH] Fix serialization of an ImportDecl. ImportDecl's module ID was not written out and the reader accepted as module ID the serialized: Record.push_back(!IdentifierLocs.empty()); llvm-svn: 165087
2012-10-03 09:58:45 +08:00
++Idx; // The number of stored source locations.
Introduce a module import declaration, so that we properly represent, e.g., __import_module__ std.vector; in the AST. llvm-svn: 145725
2011-12-03 07:23:56 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitAccessSpecDecl(AccessSpecDecl *D) {
Added AccessSpecDecl node. llvm-svn: 105525
2010-06-05 13:09:32 +08:00
VisitDecl(D);
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
D->setColonLoc(ReadSourceLocation(Record, Idx));
Added AccessSpecDecl node. llvm-svn: 105525
2010-06-05 13:09:32 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitFriendDecl(FriendDecl *D) {
Read/write the identifier namespace in PCH for decls that may modify it. We can now use a PCH'ed <map>. llvm-svn: 107617
2010-07-05 18:38:01 +08:00
VisitDecl(D);
Added outer template parameter lists to friend type AST nodes. llvm-svn: 174050
2013-01-31 17:54:08 +08:00
if (Record[Idx++]) // hasFriendDecl
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
D->Friend = ReadDeclAs<NamedDecl>(Record, Idx);
Added outer template parameter lists to friend type AST nodes. llvm-svn: 174050
2013-01-31 17:54:08 +08:00
else
D->Friend = GetTypeSourceInfo(Record, Idx);
for (unsigned i = 0; i != D->NumTPLists; ++i)
D->getTPLists()[i] = Reader.ReadTemplateParameterList(F, Record, Idx);
Map from local decl IDs to global decl IDs when lazily deserializing friend decl chains. llvm-svn: 189629
2013-08-30 08:23:29 +08:00
D->NextFriend = ReadDeclID(Record, Idx);
White-listing templated-scope friend decls is a good idea, but doing it by marking the decl invalid isn't. Make some steps towards supporting these and then hastily shut them down at the last second by marking them as unsupported. llvm-svn: 116661
2010-10-16 14:59:13 +08:00
D->UnsupportedFriend = (Record[Idx++] != 0);
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
D->FriendLoc = ReadSourceLocation(Record, Idx);
Support C++ friend declarations for PCH. This commit 'introduces' a slightly different way to restore the state of the AST object. It makes PCHDeclReader/PCHDeclWriter friends and gives them access to the private members of the object. The rationale is to avoid using/modifying the AST interfaces for PCH read/write so that to: -Avoid complications with objects that have side-effects during creation or when using some setters. -Not 'pollute' the AST interface with methods only used by the PCH reader/writer -Allow AST objects to be read-only. llvm-svn: 107219
2010-06-30 06:47:00 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitFriendTemplateDecl(FriendTemplateDecl *D) {
Read/write FriendTemplateDecl for PCH. llvm-svn: 109113
2010-07-23 00:04:10 +08:00
VisitDecl(D);
unsigned NumParams = Record[Idx++];
D->NumParams = NumParams;
D->Params = new TemplateParameterList*[NumParams];
for (unsigned i = 0; i != NumParams; ++i)
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
D->Params[i] = Reader.ReadTemplateParameterList(F, Record, Idx);
Read/write FriendTemplateDecl for PCH. llvm-svn: 109113
2010-07-23 00:04:10 +08:00
if (Record[Idx++]) // HasFriendDecl
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
D->Friend = ReadDeclAs<NamedDecl>(Record, Idx);
Read/write FriendTemplateDecl for PCH. llvm-svn: 109113
2010-07-23 00:04:10 +08:00
else
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
D->Friend = GetTypeSourceInfo(Record, Idx);
D->FriendLoc = ReadSourceLocation(Record, Idx);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
}
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
DeclID ASTDeclReader::VisitTemplateDecl(TemplateDecl *D) {
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +08:00
VisitNamedDecl(D);
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
DeclID PatternID = ReadDeclID(Record, Idx);
NamedDecl *TemplatedDecl = cast_or_null<NamedDecl>(Reader.GetDecl(PatternID));
Support C++ class template specializations and partial specializations for PCH. llvm-svn: 106625
2010-06-23 21:48:30 +08:00
TemplateParameterList* TemplateParams
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
= Reader.ReadTemplateParameterList(F, Record, Idx);
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +08:00
D->init(TemplatedDecl, TemplateParams);
Check for matching template-parameter-lists when merging template declarations. llvm-svn: 184791
2013-06-25 06:51:00 +08:00
// FIXME: If this is a redeclaration of a template from another module, handle
// inheritance of default template arguments.
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 PatternID;
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
}
During name lookup, use redecl_iterator to walk over the redeclaration chain to determine whether any declaration of the given entity is visible, eliminating the redundant (and less efficient) getPreviousDeclaration() implementation. This tweak uncovered an omission in the handling of RedeclarableTemplateDecl, where we weren't making sure to search for additional redeclarations of a template in other module files. Things would be cleaner if RedeclarableTemplateDecl actually used Redeclarable. llvm-svn: 147687
2012-01-07 06:05:37 +08:00
ASTDeclReader::RedeclarableResult
ASTDeclReader::VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D) {
Reimplement RedeclarableTemplateDecl in terms of Redeclarable<RedeclarableTemplateDecl>, eliminating a bunch of redeclaration-chain logic both in RedeclarableTemplateDecl and especially in its (de-)serialization. As part of this, eliminate the RedeclarableTemplate<> class template, which was an abstraction that didn't actually save anything. llvm-svn: 148181
2012-01-14 23:13:49 +08:00
RedeclarableResult Redecl = VisitRedeclarable(D);
Re-implement (de-)serialization of redeclaration chains for redeclaration templates (RedeclarableTemplateDecl), similarly to the way (de-)serialization is implemented for Redeclarable<T>. In the process, found a simpler formulation for handling redeclaration chains and implemented that in both places. The new test establishes that we're building the redeclaration chains properly. However, the FIXME indicates where we're tickling a different bug that has to do with us not setting the DefinitionData pointer properly in redeclarations that we detected after the definition itself was deserialized. The (separable) fix for that bug is forthcoming. llvm-svn: 146883
2011-12-20 02:19:24 +08:00
Reimplement RedeclarableTemplateDecl in terms of Redeclarable<RedeclarableTemplateDecl>, eliminating a bunch of redeclaration-chain logic both in RedeclarableTemplateDecl and especially in its (de-)serialization. As part of this, eliminate the RedeclarableTemplate<> class template, which was an abstraction that didn't actually save anything. llvm-svn: 148181
2012-01-14 23:13:49 +08:00
// Make sure we've allocated the Common pointer first. We do this before
// VisitTemplateDecl so that getCommonPtr() can be used during initialization.
RedeclarableTemplateDecl *CanonD = D->getCanonicalDecl();
if (!CanonD->Common) {
CanonD->Common = CanonD->newCommon(Reader.getContext());
Reader.PendingDefinitions.insert(CanonD);
}
D->Common = CanonD->Common;
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
Reimplement RedeclarableTemplateDecl in terms of Redeclarable<RedeclarableTemplateDecl>, eliminating a bunch of redeclaration-chain logic both in RedeclarableTemplateDecl and especially in its (de-)serialization. As part of this, eliminate the RedeclarableTemplate<> class template, which was an abstraction that didn't actually save anything. llvm-svn: 148181
2012-01-14 23:13:49 +08:00
// If this is the first declaration of the template, fill in the information
// for the 'common' pointer.
if (ThisDeclID == Redecl.getFirstID()) {
Refactor redeclarable template declarations This patch refactors much of the common code in ClassTemplateDecl and FunctionTemplateDecl into a common base class RedeclarableTemplateDecl together with support functions in a template class RedeclarableTemplate. The patch also includes similar refactoring for these classes' PCH reader and writer implementations. llvm-svn: 109754
2010-07-30 00:11:51 +08:00
if (RedeclarableTemplateDecl *RTD
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
= ReadDeclAs<RedeclarableTemplateDecl>(Record, Idx)) {
Refactor redeclarable template declarations This patch refactors much of the common code in ClassTemplateDecl and FunctionTemplateDecl into a common base class RedeclarableTemplateDecl together with support functions in a template class RedeclarableTemplate. The patch also includes similar refactoring for these classes' PCH reader and writer implementations. llvm-svn: 109754
2010-07-30 00:11:51 +08:00
assert(RTD->getKind() == D->getKind() &&
"InstantiatedFromMemberTemplate kind mismatch");
Reimplement RedeclarableTemplateDecl in terms of Redeclarable<RedeclarableTemplateDecl>, eliminating a bunch of redeclaration-chain logic both in RedeclarableTemplateDecl and especially in its (de-)serialization. As part of this, eliminate the RedeclarableTemplate<> class template, which was an abstraction that didn't actually save anything. llvm-svn: 148181
2012-01-14 23:13:49 +08:00
D->setInstantiatedFromMemberTemplate(RTD);
Refactor redeclarable template declarations This patch refactors much of the common code in ClassTemplateDecl and FunctionTemplateDecl into a common base class RedeclarableTemplateDecl together with support functions in a template class RedeclarableTemplate. The patch also includes similar refactoring for these classes' PCH reader and writer implementations. llvm-svn: 109754
2010-07-30 00:11:51 +08:00
if (Record[Idx++])
D->setMemberSpecialization();
}
}
Also merge template redeclarations. Don't require specializations (of existing and read template) to be unique. llvm-svn: 164931
2012-10-01 17:18:00 +08:00
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
DeclID PatternID = VisitTemplateDecl(D);
Fix C++ PCH issues. PCH got a severe beating by the boost-using test case reported here: http://llvm.org/PR8099 Fix issues like: -When PCH reading, make sure Decl's getASTContext() doesn't get called since a Decl in the parent hierarchy may be initializing. -In ASTDeclReader::VisitFunctionDecl VisitRedeclarable should be called before using FunctionDecl's isCanonicalDecl() -In ASTDeclReader::VisitRedeclarableTemplateDecl CommonOrPrev must be initialized before anything else. llvm-svn: 113391
2010-09-09 03:31:22 +08:00
D->IdentifierNamespace = Record[Idx++];
Also merge template redeclarations. Don't require specializations (of existing and read template) to be unique. llvm-svn: 164931
2012-10-01 17:18:00 +08:00
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
mergeRedeclarable(D, Redecl, PatternID);
Also merge template redeclarations. Don't require specializations (of existing and read template) to be unique. llvm-svn: 164931
2012-10-01 17:18:00 +08:00
Merge common pointers for redeclarations of the same template across modules. llvm-svn: 192560
2013-10-14 07:50:45 +08:00
// If we merged the template with a prior declaration chain, merge the common
// pointer.
// FIXME: Actually merge here, don't just overwrite.
D->Common = D->getCanonicalDecl()->Common;
Reimplement RedeclarableTemplateDecl in terms of Redeclarable<RedeclarableTemplateDecl>, eliminating a bunch of redeclaration-chain logic both in RedeclarableTemplateDecl and especially in its (de-)serialization. As part of this, eliminate the RedeclarableTemplate<> class template, which was an abstraction that didn't actually save anything. llvm-svn: 148181
2012-01-14 23:13:49 +08:00
return Redecl;
Refactor redeclarable template declarations This patch refactors much of the common code in ClassTemplateDecl and FunctionTemplateDecl into a common base class RedeclarableTemplateDecl together with support functions in a template class RedeclarableTemplate. The patch also includes similar refactoring for these classes' PCH reader and writer implementations. llvm-svn: 109754
2010-07-30 00:11:51 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitClassTemplateDecl(ClassTemplateDecl *D) {
Reimplement RedeclarableTemplateDecl in terms of Redeclarable<RedeclarableTemplateDecl>, eliminating a bunch of redeclaration-chain logic both in RedeclarableTemplateDecl and especially in its (de-)serialization. As part of this, eliminate the RedeclarableTemplate<> class template, which was an abstraction that didn't actually save anything. llvm-svn: 148181
2012-01-14 23:13:49 +08:00
RedeclarableResult Redecl = VisitRedeclarableTemplateDecl(D);
Refactor redeclarable template declarations This patch refactors much of the common code in ClassTemplateDecl and FunctionTemplateDecl into a common base class RedeclarableTemplateDecl together with support functions in a template class RedeclarableTemplate. The patch also includes similar refactoring for these classes' PCH reader and writer implementations. llvm-svn: 109754
2010-07-30 00:11:51 +08:00
Reimplement RedeclarableTemplateDecl in terms of Redeclarable<RedeclarableTemplateDecl>, eliminating a bunch of redeclaration-chain logic both in RedeclarableTemplateDecl and especially in its (de-)serialization. As part of this, eliminate the RedeclarableTemplate<> class template, which was an abstraction that didn't actually save anything. llvm-svn: 148181
2012-01-14 23:13:49 +08:00
if (ThisDeclID == Redecl.getFirstID()) {
Make AST deserialization for class template specializations lazier, by not loading the specializations of a class template until some AST consumer needs them. llvm-svn: 117498
2010-10-28 06:21:36 +08:00
// This ClassTemplateDecl owns a CommonPtr; read it to keep track of all of
// the specializations.
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<serialization::DeclID, 2> SpecIDs;
Make AST deserialization for class template specializations lazier, by not loading the specializations of a class template until some AST consumer needs them. llvm-svn: 117498
2010-10-28 06:21:36 +08:00
SpecIDs.push_back(0);
// Specializations.
unsigned Size = Record[Idx++];
SpecIDs[0] += Size;
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
for (unsigned I = 0; I != Size; ++I)
SpecIDs.push_back(ReadDeclID(Record, Idx));
Make AST deserialization for class template specializations lazier, by not loading the specializations of a class template until some AST consumer needs them. llvm-svn: 117498
2010-10-28 06:21:36 +08:00
// Partial specializations.
Size = Record[Idx++];
SpecIDs[0] += Size;
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
for (unsigned I = 0; I != Size; ++I)
SpecIDs.push_back(ReadDeclID(Record, Idx));
Make AST deserialization for class template specializations lazier, by not loading the specializations of a class template until some AST consumer needs them. llvm-svn: 117498
2010-10-28 06:21:36 +08:00
[PCH] Write out the ClassTemplateDecl::Common::InjectedClassNameType type reference instead of relying on computing it. In general, if storage is no issue, it is preferable to deserialize info from the PCH instead of trying to recompute it after the PCH was loaded. The incentive to change this now was due to r155303 changing how friend template classes in dependent contexts are handled; such classes can now be chained to a previous template class but the computed InjectedClassNameType may be different due to the extra template parameters from the dependent context. The new handling requires more investigation but, in the meantime, writing out InjectedClassNameType fixes PCH issue in rdar://12627738. llvm-svn: 167425
2012-11-06 08:35:02 +08:00
ClassTemplateDecl::Common *CommonPtr = D->getCommonPtr();
Make AST deserialization for class template specializations lazier, by not loading the specializations of a class template until some AST consumer needs them. llvm-svn: 117498
2010-10-28 06:21:36 +08:00
if (SpecIDs[0]) {
typedef serialization::DeclID DeclID;
Reimplement RedeclarableTemplateDecl in terms of Redeclarable<RedeclarableTemplateDecl>, eliminating a bunch of redeclaration-chain logic both in RedeclarableTemplateDecl and especially in its (de-)serialization. As part of this, eliminate the RedeclarableTemplate<> class template, which was an abstraction that didn't actually save anything. llvm-svn: 148181
2012-01-14 23:13:49 +08:00
// FIXME: Append specializations!
Make AST deserialization for class template specializations lazier, by not loading the specializations of a class template until some AST consumer needs them. llvm-svn: 117498
2010-10-28 06:21:36 +08:00
CommonPtr->LazySpecializations
In ASTReader, replace the never-NULL ASTContext pointer with an ASTContext reference. Remove all of the extra checking and logic that was used to cope with a NULL ASTContext. No effective functionality change. llvm-svn: 139413
2011-09-10 05:34:22 +08:00
= new (Reader.getContext()) DeclID [SpecIDs.size()];
Make AST deserialization for class template specializations lazier, by not loading the specializations of a class template until some AST consumer needs them. llvm-svn: 117498
2010-10-28 06:21:36 +08:00
memcpy(CommonPtr->LazySpecializations, SpecIDs.data(),
SpecIDs.size() * sizeof(DeclID));
}
[PCH] Write out the ClassTemplateDecl::Common::InjectedClassNameType type reference instead of relying on computing it. In general, if storage is no issue, it is preferable to deserialize info from the PCH instead of trying to recompute it after the PCH was loaded. The incentive to change this now was due to r155303 changing how friend template classes in dependent contexts are handled; such classes can now be chained to a previous template class but the computed InjectedClassNameType may be different due to the extra template parameters from the dependent context. The new handling requires more investigation but, in the meantime, writing out InjectedClassNameType fixes PCH issue in rdar://12627738. llvm-svn: 167425
2012-11-06 08:35:02 +08:00
CommonPtr->InjectedClassNameType = Reader.readType(F, Record, Idx);
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +08:00
}
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
if (D->getTemplatedDecl()->TemplateOrInstantiation) {
// We were loaded before our templated declaration was. We've not set up
// its corresponding type yet (see VisitCXXRecordDeclImpl), so reconstruct
// it now.
Reader.Context.getInjectedClassNameType(
D->getTemplatedDecl(), D->getCommonPtr()->InjectedClassNameType);
}
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
}
A clean-up pass, exploring the unification of traversals of class, variable and function templates. llvm-svn: 189152
2013-08-24 06:21:36 +08:00
/// TODO: Unify with ClassTemplateDecl version?
/// May require unifying ClassTemplateDecl and
/// VarTemplateDecl beyond TemplateDecl...
Started implementing variable templates. Top level declarations should be fully supported, up to some limitations documented as FIXMEs or TODO. Static data member templates work very partially. Static data member templates of class templates need particular attention... llvm-svn: 187762
2013-08-06 09:03:05 +08:00
void ASTDeclReader::VisitVarTemplateDecl(VarTemplateDecl *D) {
RedeclarableResult Redecl = VisitRedeclarableTemplateDecl(D);
if (ThisDeclID == Redecl.getFirstID()) {
Bug fix: disallow a variable template to be redeclared as a non-templated variable llvm-svn: 188350
2013-08-14 11:09:19 +08:00
// This VarTemplateDecl owns a CommonPtr; read it to keep track of all of
Started implementing variable templates. Top level declarations should be fully supported, up to some limitations documented as FIXMEs or TODO. Static data member templates work very partially. Static data member templates of class templates need particular attention... llvm-svn: 187762
2013-08-06 09:03:05 +08:00
// the specializations.
SmallVector<serialization::DeclID, 2> SpecIDs;
SpecIDs.push_back(0);
// Specializations.
unsigned Size = Record[Idx++];
SpecIDs[0] += Size;
for (unsigned I = 0; I != Size; ++I)
SpecIDs.push_back(ReadDeclID(Record, Idx));
// Partial specializations.
Size = Record[Idx++];
SpecIDs[0] += Size;
for (unsigned I = 0; I != Size; ++I)
SpecIDs.push_back(ReadDeclID(Record, Idx));
VarTemplateDecl::Common *CommonPtr = D->getCommonPtr();
if (SpecIDs[0]) {
typedef serialization::DeclID DeclID;
// FIXME: Append specializations!
CommonPtr->LazySpecializations =
new (Reader.getContext()) DeclID[SpecIDs.size()];
memcpy(CommonPtr->LazySpecializations, SpecIDs.data(),
SpecIDs.size() * sizeof(DeclID));
}
}
}
Fix bitcode desynchronization when loading a PCH containing a class template specialization with modules enabled. Just don't merge them at all for now; we'll revisit this when support for template merging is added. In passing, make Decl::dump() a little safer to use with PCH/modules, by making it not deserialize any additional declarations. From a debugger you can call decls_begin() or similar first if you want to dump all child decls. llvm-svn: 182544
2013-05-23 09:49:11 +08:00
ASTDeclReader::RedeclarableResult
ASTDeclReader::VisitClassTemplateSpecializationDeclImpl(
ClassTemplateSpecializationDecl *D) {
RedeclarableResult Redecl = VisitCXXRecordDeclImpl(D);
Avoid setters in ASTDeclReader::VisitClassTemplateSpecializationDecl. llvm-svn: 113742
2010-09-13 19:45:32 +08:00
In ASTReader, replace the never-NULL ASTContext pointer with an ASTContext reference. Remove all of the extra checking and logic that was used to cope with a NULL ASTContext. No effective functionality change. llvm-svn: 139413
2011-09-10 05:34:22 +08:00
ASTContext &C = Reader.getContext();
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
if (Decl *InstD = ReadDecl(Record, Idx)) {
Support C++ class template specializations and partial specializations for PCH. llvm-svn: 106625
2010-06-23 21:48:30 +08:00
if (ClassTemplateDecl *CTD = dyn_cast<ClassTemplateDecl>(InstD)) {
Avoid setters in ASTDeclReader::VisitClassTemplateSpecializationDecl. llvm-svn: 113742
2010-09-13 19:45:32 +08:00
D->SpecializedTemplate = CTD;
Support C++ class template specializations and partial specializations for PCH. llvm-svn: 106625
2010-06-23 21:48:30 +08:00
} else {
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<TemplateArgument, 8> TemplArgs;
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
Avoid setters in ASTDeclReader::VisitClassTemplateSpecializationDecl. llvm-svn: 113742
2010-09-13 19:45:32 +08:00
TemplateArgumentList *ArgList
Remove broken support for variadic templates, along with the various abstractions (e.g., TemplateArgumentListBuilder) that were designed to support variadic templates. Only a few remnants of variadic templates remain, in the parser (parsing template type parameter packs), AST (template type parameter pack bits and TemplateArgument::Pack), and Sema; these are expected to be used in a future implementation of variadic templates. But don't get too excited about that happening now. llvm-svn: 118385
2010-11-08 07:05:16 +08:00
= TemplateArgumentList::CreateCopy(C, TemplArgs.data(),
TemplArgs.size());
Avoid setters in ASTDeclReader::VisitClassTemplateSpecializationDecl. llvm-svn: 113742
2010-09-13 19:45:32 +08:00
ClassTemplateSpecializationDecl::SpecializedPartialSpecialization *PS
= new (C) ClassTemplateSpecializationDecl::
SpecializedPartialSpecialization();
PS->PartialSpecialization
= cast<ClassTemplatePartialSpecializationDecl>(InstD);
PS->TemplateArgs = ArgList;
D->SpecializedTemplate = PS;
Support C++ class template specializations and partial specializations for PCH. llvm-svn: 106625
2010-06-23 21:48:30 +08:00
}
}
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<TemplateArgument, 8> TemplArgs;
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
Remove broken support for variadic templates, along with the various abstractions (e.g., TemplateArgumentListBuilder) that were designed to support variadic templates. Only a few remnants of variadic templates remain, in the parser (parsing template type parameter packs), AST (template type parameter pack bits and TemplateArgument::Pack), and Sema; these are expected to be used in a future implementation of variadic templates. But don't get too excited about that happening now. llvm-svn: 118385
2010-11-08 07:05:16 +08:00
D->TemplateArgs = TemplateArgumentList::CreateCopy(C, TemplArgs.data(),
TemplArgs.size());
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
D->PointOfInstantiation = ReadSourceLocation(Record, Idx);
Avoid setters in ASTDeclReader::VisitClassTemplateSpecializationDecl. llvm-svn: 113742
2010-09-13 19:45:32 +08:00
D->SpecializationKind = (TemplateSpecializationKind)Record[Idx++];
Bring ASTReader and Writer into sync for the case where a canonical template specialization was written, which is non-canonical at the time of reading: force the reading of the ClassTemplateDecl if it was written. The easiest way out is to store whether the decl was canonical at the time of writing. Add test. llvm-svn: 164927
2012-10-01 15:34:47 +08:00
bool writtenAsCanonicalDecl = Record[Idx++];
if (writtenAsCanonicalDecl) {
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
ClassTemplateDecl *CanonPattern = ReadDeclAs<ClassTemplateDecl>(Record,Idx);
Bring ASTReader and Writer into sync for the case where a canonical template specialization was written, which is non-canonical at the time of reading: force the reading of the ClassTemplateDecl if it was written. The easiest way out is to store whether the decl was canonical at the time of writing. Add test. llvm-svn: 164927
2012-10-01 15:34:47 +08:00
if (D->isCanonicalDecl()) { // It's kept in the folding set.
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
// Set this as, or find, the canonical declaration for this specialization
ClassTemplateSpecializationDecl *CanonSpec;
Fix deserializing of class template partial specializations. Assign sequence numbers as we deserialize class template partial specializations. We can't assume that the old sequence numbers will work. The sequence numbers are still deterministic, but are now a lot less predictable for class template partial specializations in modules/PCH. llvm-svn: 184811
2013-06-25 09:25:15 +08:00
if (ClassTemplatePartialSpecializationDecl *Partial =
dyn_cast<ClassTemplatePartialSpecializationDecl>(D)) {
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
CanonSpec = CanonPattern->getCommonPtr()->PartialSpecializations
Fix deserializing of class template partial specializations. Assign sequence numbers as we deserialize class template partial specializations. We can't assume that the old sequence numbers will work. The sequence numbers are still deterministic, but are now a lot less predictable for class template partial specializations in modules/PCH. llvm-svn: 184811
2013-06-25 09:25:15 +08:00
.GetOrInsertNode(Partial);
Bring ASTReader and Writer into sync for the case where a canonical template specialization was written, which is non-canonical at the time of reading: force the reading of the ClassTemplateDecl if it was written. The easiest way out is to store whether the decl was canonical at the time of writing. Add test. llvm-svn: 164927
2012-10-01 15:34:47 +08:00
} else {
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
CanonSpec =
CanonPattern->getCommonPtr()->Specializations.GetOrInsertNode(D);
}
// If there was already a canonical specialization, merge into it.
if (CanonSpec != D) {
mergeRedeclarable<TagDecl>(D, CanonSpec, Redecl);
// This declaration might be a definition. Merge with any existing
// definition.
if (D->DefinitionData) {
if (!CanonSpec->DefinitionData) {
CanonSpec->DefinitionData = D->DefinitionData;
} else {
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
MergeDefinitionData(CanonSpec, *D->DefinitionData);
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
Reader.PendingDefinitions.erase(D);
Reader.MergedDeclContexts.insert(
std::make_pair(D, CanonSpec->DefinitionData->Definition));
D->IsCompleteDefinition = false;
D->DefinitionData = CanonSpec->DefinitionData;
}
}
Bring ASTReader and Writer into sync for the case where a canonical template specialization was written, which is non-canonical at the time of reading: force the reading of the ClassTemplateDecl if it was written. The easiest way out is to store whether the decl was canonical at the time of writing. Add test. llvm-svn: 164927
2012-10-01 15:34:47 +08:00
}
Reorganize how ClassTemplate[Partial]SpecializationDecls are read/written to avoid the possibility of adding an unitialized one into the folding set. llvm-svn: 108016
2010-07-10 05:11:43 +08:00
}
}
Fix bitcode desynchronization when loading a PCH containing a class template specialization with modules enabled. Just don't merge them at all for now; we'll revisit this when support for template merging is added. In passing, make Decl::dump() a little safer to use with PCH/modules, by making it not deserialize any additional declarations. From a debugger you can call decls_begin() or similar first if you want to dump all child decls. llvm-svn: 182544
2013-05-23 09:49:11 +08:00
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
// Explicit info.
if (TypeSourceInfo *TyInfo = GetTypeSourceInfo(Record, Idx)) {
ClassTemplateSpecializationDecl::ExplicitSpecializationInfo *ExplicitInfo
= new (C) ClassTemplateSpecializationDecl::ExplicitSpecializationInfo;
ExplicitInfo->TypeAsWritten = TyInfo;
ExplicitInfo->ExternLoc = ReadSourceLocation(Record, Idx);
ExplicitInfo->TemplateKeywordLoc = ReadSourceLocation(Record, Idx);
D->ExplicitInfo = ExplicitInfo;
}
Fix bitcode desynchronization when loading a PCH containing a class template specialization with modules enabled. Just don't merge them at all for now; we'll revisit this when support for template merging is added. In passing, make Decl::dump() a little safer to use with PCH/modules, by making it not deserialize any additional declarations. From a debugger you can call decls_begin() or similar first if you want to dump all child decls. llvm-svn: 182544
2013-05-23 09:49:11 +08:00
return Redecl;
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitClassTemplatePartialSpecializationDecl(
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
ClassTemplatePartialSpecializationDecl *D) {
Fix bitcode desynchronization when loading a PCH containing a class template specialization with modules enabled. Just don't merge them at all for now; we'll revisit this when support for template merging is added. In passing, make Decl::dump() a little safer to use with PCH/modules, by making it not deserialize any additional declarations. From a debugger you can call decls_begin() or similar first if you want to dump all child decls. llvm-svn: 182544
2013-05-23 09:49:11 +08:00
RedeclarableResult Redecl = VisitClassTemplateSpecializationDeclImpl(D);
Support C++ class template specializations and partial specializations for PCH. llvm-svn: 106625
2010-06-23 21:48:30 +08:00
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
D->TemplateParams = Reader.ReadTemplateParameterList(F, Record, Idx);
Added source locs for angled parentheses in class/var template partial specs. llvm-svn: 188134
2013-08-10 15:24:53 +08:00
D->ArgsAsWritten = Reader.ReadASTTemplateArgumentListInfo(F, Record, Idx);
Avoid setters in ASTDeclReader::VisitClassTemplatePartialSpecializationDecl. llvm-svn: 113743
2010-09-13 19:45:41 +08:00
Support C++ class template specializations and partial specializations for PCH. llvm-svn: 106625
2010-06-23 21:48:30 +08:00
// These are read/set from/to the first declaration.
Fix bitcode desynchronization when loading a PCH containing a class template specialization with modules enabled. Just don't merge them at all for now; we'll revisit this when support for template merging is added. In passing, make Decl::dump() a little safer to use with PCH/modules, by making it not deserialize any additional declarations. From a debugger you can call decls_begin() or similar first if you want to dump all child decls. llvm-svn: 182544
2013-05-23 09:49:11 +08:00
if (ThisDeclID == Redecl.getFirstID()) {
Avoid setters in ASTDeclReader::VisitClassTemplatePartialSpecializationDecl. llvm-svn: 113743
2010-09-13 19:45:41 +08:00
D->InstantiatedFromMember.setPointer(
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
ReadDeclAs<ClassTemplatePartialSpecializationDecl>(Record, Idx));
Avoid setters in ASTDeclReader::VisitClassTemplatePartialSpecializationDecl. llvm-svn: 113743
2010-09-13 19:45:41 +08:00
D->InstantiatedFromMember.setInt(Record[Idx++]);
Support C++ class template specializations and partial specializations for PCH. llvm-svn: 106625
2010-06-23 21:48:30 +08:00
}
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
}
Serialize the new bits in CXXRecordDecl::DefinitionData. llvm-svn: 138855
2011-08-31 21:59:56 +08:00
void ASTDeclReader::VisitClassScopeFunctionSpecializationDecl(
ClassScopeFunctionSpecializationDecl *D) {
Add serialization support for ClassScopeFunctionSpecializationDecl. llvm-svn: 137799
2011-08-17 09:06:54 +08:00
VisitDecl(D);
D->Specialization = ReadDeclAs<CXXMethodDecl>(Record, Idx);
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
Reimplement RedeclarableTemplateDecl in terms of Redeclarable<RedeclarableTemplateDecl>, eliminating a bunch of redeclaration-chain logic both in RedeclarableTemplateDecl and especially in its (de-)serialization. As part of this, eliminate the RedeclarableTemplate<> class template, which was an abstraction that didn't actually save anything. llvm-svn: 148181
2012-01-14 23:13:49 +08:00
RedeclarableResult Redecl = VisitRedeclarableTemplateDecl(D);
Support emitting/reading function templates to/from PCH. llvm-svn: 106534
2010-06-22 17:55:07 +08:00
Reimplement RedeclarableTemplateDecl in terms of Redeclarable<RedeclarableTemplateDecl>, eliminating a bunch of redeclaration-chain logic both in RedeclarableTemplateDecl and especially in its (de-)serialization. As part of this, eliminate the RedeclarableTemplate<> class template, which was an abstraction that didn't actually save anything. llvm-svn: 148181
2012-01-14 23:13:49 +08:00
if (ThisDeclID == Redecl.getFirstID()) {
Support emitting/reading function templates to/from PCH. llvm-svn: 106534
2010-06-22 17:55:07 +08:00
// This FunctionTemplateDecl owns a CommonPtr; read it.
Lazily deserialize function template specializations. This fixes a cycle in module deserialization / merging, and more laziness here is general goodness. llvm-svn: 185132
2013-06-28 12:37:53 +08:00
// Read the function specialization declaration IDs. The specializations
// themselves will be loaded if they're needed.
if (unsigned NumSpecs = Record[Idx++]) {
// FIXME: Append specializations!
FunctionTemplateDecl::Common *CommonPtr = D->getCommonPtr();
CommonPtr->LazySpecializations = new (Reader.getContext())
serialization::DeclID[NumSpecs + 1];
CommonPtr->LazySpecializations[0] = NumSpecs;
for (unsigned I = 0; I != NumSpecs; ++I)
CommonPtr->LazySpecializations[I + 1] = ReadDeclID(Record, Idx);
}
Support emitting/reading function templates to/from PCH. llvm-svn: 106534
2010-06-22 17:55:07 +08:00
}
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
}
A clean-up pass, exploring the unification of traversals of class, variable and function templates. llvm-svn: 189152
2013-08-24 06:21:36 +08:00
/// TODO: Unify with ClassTemplateSpecializationDecl version?
/// May require unifying ClassTemplate(Partial)SpecializationDecl and
/// VarTemplate(Partial)SpecializationDecl with a new data
/// structure Template(Partial)SpecializationDecl, and
/// using Template(Partial)SpecializationDecl as input type.
Started implementing variable templates. Top level declarations should be fully supported, up to some limitations documented as FIXMEs or TODO. Static data member templates work very partially. Static data member templates of class templates need particular attention... llvm-svn: 187762
2013-08-06 09:03:05 +08:00
ASTDeclReader::RedeclarableResult
ASTDeclReader::VisitVarTemplateSpecializationDeclImpl(
VarTemplateSpecializationDecl *D) {
RedeclarableResult Redecl = VisitVarDeclImpl(D);
ASTContext &C = Reader.getContext();
if (Decl *InstD = ReadDecl(Record, Idx)) {
if (VarTemplateDecl *VTD = dyn_cast<VarTemplateDecl>(InstD)) {
D->SpecializedTemplate = VTD;
} else {
SmallVector<TemplateArgument, 8> TemplArgs;
Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
TemplateArgumentList *ArgList = TemplateArgumentList::CreateCopy(
C, TemplArgs.data(), TemplArgs.size());
VarTemplateSpecializationDecl::SpecializedPartialSpecialization *PS =
new (C)
VarTemplateSpecializationDecl::SpecializedPartialSpecialization();
PS->PartialSpecialization =
cast<VarTemplatePartialSpecializationDecl>(InstD);
PS->TemplateArgs = ArgList;
D->SpecializedTemplate = PS;
}
}
// Explicit info.
if (TypeSourceInfo *TyInfo = GetTypeSourceInfo(Record, Idx)) {
VarTemplateSpecializationDecl::ExplicitSpecializationInfo *ExplicitInfo =
new (C) VarTemplateSpecializationDecl::ExplicitSpecializationInfo;
ExplicitInfo->TypeAsWritten = TyInfo;
ExplicitInfo->ExternLoc = ReadSourceLocation(Record, Idx);
ExplicitInfo->TemplateKeywordLoc = ReadSourceLocation(Record, Idx);
D->ExplicitInfo = ExplicitInfo;
}
SmallVector<TemplateArgument, 8> TemplArgs;
Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
D->TemplateArgs =
TemplateArgumentList::CreateCopy(C, TemplArgs.data(), TemplArgs.size());
D->PointOfInstantiation = ReadSourceLocation(Record, Idx);
D->SpecializationKind = (TemplateSpecializationKind)Record[Idx++];
bool writtenAsCanonicalDecl = Record[Idx++];
if (writtenAsCanonicalDecl) {
VarTemplateDecl *CanonPattern = ReadDeclAs<VarTemplateDecl>(Record, Idx);
if (D->isCanonicalDecl()) { // It's kept in the folding set.
if (VarTemplatePartialSpecializationDecl *Partial =
dyn_cast<VarTemplatePartialSpecializationDecl>(D)) {
CanonPattern->getCommonPtr()->PartialSpecializations
.GetOrInsertNode(Partial);
} else {
CanonPattern->getCommonPtr()->Specializations.GetOrInsertNode(D);
}
}
}
return Redecl;
}
A clean-up pass, exploring the unification of traversals of class, variable and function templates. llvm-svn: 189152
2013-08-24 06:21:36 +08:00
/// TODO: Unify with ClassTemplatePartialSpecializationDecl version?
/// May require unifying ClassTemplate(Partial)SpecializationDecl and
/// VarTemplate(Partial)SpecializationDecl with a new data
/// structure Template(Partial)SpecializationDecl, and
/// using Template(Partial)SpecializationDecl as input type.
Started implementing variable templates. Top level declarations should be fully supported, up to some limitations documented as FIXMEs or TODO. Static data member templates work very partially. Static data member templates of class templates need particular attention... llvm-svn: 187762
2013-08-06 09:03:05 +08:00
void ASTDeclReader::VisitVarTemplatePartialSpecializationDecl(
VarTemplatePartialSpecializationDecl *D) {
RedeclarableResult Redecl = VisitVarTemplateSpecializationDeclImpl(D);
D->TemplateParams = Reader.ReadTemplateParameterList(F, Record, Idx);
Added source locs for angled parentheses in class/var template partial specs. llvm-svn: 188134
2013-08-10 15:24:53 +08:00
D->ArgsAsWritten = Reader.ReadASTTemplateArgumentListInfo(F, Record, Idx);
Started implementing variable templates. Top level declarations should be fully supported, up to some limitations documented as FIXMEs or TODO. Static data member templates work very partially. Static data member templates of class templates need particular attention... llvm-svn: 187762
2013-08-06 09:03:05 +08:00
// These are read/set from/to the first declaration.
if (ThisDeclID == Redecl.getFirstID()) {
D->InstantiatedFromMember.setPointer(
ReadDeclAs<VarTemplatePartialSpecializationDecl>(Record, Idx));
D->InstantiatedFromMember.setInt(Record[Idx++]);
}
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +08:00
VisitTypeDecl(D);
D->setDeclaredWithTypename(Record[Idx++]);
bool Inherited = Record[Idx++];
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
TypeSourceInfo *DefArg = GetTypeSourceInfo(Record, Idx);
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +08:00
D->setDefaultArgument(DefArg, Inherited);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D) {
NonTypeTemplateParmDecl is just a DeclaratorDecl, not a VarDecl. Also, reorganize and make very explicit the logic for determining the value kind and type of a referenced declaration. llvm-svn: 125150
2011-02-09 09:13:10 +08:00
VisitDeclaratorDecl(D);
Support NonTypeTemplateParmDecl for PCH. llvm-svn: 106860
2010-06-26 00:25:09 +08:00
// TemplateParmPosition.
D->setDepth(Record[Idx++]);
D->setPosition(Record[Idx++]);
Implement support for non-type template parameter packs whose type is a pack expansion, e.g., the parameter pack Values in: template<typename ...Types> struct Outer { template<Types ...Values> struct Inner; }; This new implementation approach introduces the notion of an "expanded" non-type template parameter pack, for which we have already expanded the types of the parameter pack (to, say, "int*, float*", for Outer<int*, float*>) but have not yet expanded the values. Aside from creating these expanded non-type template parameter packs, this patch updates template argument checking and non-type template parameter pack instantiation to make use of the appropriate types in the parameter pack. llvm-svn: 123845
2011-01-20 04:10:05 +08:00
if (D->isExpandedParameterPack()) {
void **Data = reinterpret_cast<void **>(D + 1);
for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
Data[2*I] = Reader.readType(F, Record, Idx).getAsOpaquePtr();
Implement support for non-type template parameter packs whose type is a pack expansion, e.g., the parameter pack Values in: template<typename ...Types> struct Outer { template<Types ...Values> struct Inner; }; This new implementation approach introduces the notion of an "expanded" non-type template parameter pack, for which we have already expanded the types of the parameter pack (to, say, "int*, float*", for Outer<int*, float*>) but have not yet expanded the values. Aside from creating these expanded non-type template parameter packs, this patch updates template argument checking and non-type template parameter pack instantiation to make use of the appropriate types in the parameter pack. llvm-svn: 123845
2011-01-20 04:10:05 +08:00
Data[2*I + 1] = GetTypeSourceInfo(Record, Idx);
}
} else {
// Rest of NonTypeTemplateParmDecl.
D->ParameterPack = Record[Idx++];
if (Record[Idx++]) {
Expr *DefArg = Reader.ReadExpr(F);
bool Inherited = Record[Idx++];
D->setDefaultArgument(DefArg, Inherited);
}
}
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
Support TemplateTemplateParmDecl for PCH. llvm-svn: 107884
2010-07-09 01:12:57 +08:00
VisitTemplateDecl(D);
// TemplateParmPosition.
D->setDepth(Record[Idx++]);
D->setPosition(Record[Idx++]);
PR9023: A template template parameter whose template parameter list contains an unexpanded parameter pack is a pack expansion. Thus, as with a non-type template parameter which is a pack expansion, it needs to be expanded early into a fixed list of template parameters. Since the expanded list of template parameters is not itself a parameter pack, it is permitted to appear before the end of the template parameter list, so also remove that restriction (for both template template parameter pack expansions and non-type template parameter pack expansions). llvm-svn: 163369
2012-09-07 10:06:42 +08:00
if (D->isExpandedParameterPack()) {
void **Data = reinterpret_cast<void **>(D + 1);
for (unsigned I = 0, N = D->getNumExpansionTemplateParameters();
I != N; ++I)
Data[I] = Reader.ReadTemplateParameterList(F, Record, Idx);
} else {
// Rest of TemplateTemplateParmDecl.
TemplateArgumentLoc Arg = Reader.ReadTemplateArgumentLoc(F, Record, Idx);
bool IsInherited = Record[Idx++];
D->setDefaultArgument(Arg, IsInherited);
D->ParameterPack = Record[Idx++];
}
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
}
Implement support for C++0x alias templates. llvm-svn: 130953
2011-05-06 05:57:07 +08:00
void ASTDeclReader::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
VisitRedeclarableTemplateDecl(D);
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitStaticAssertDecl(StaticAssertDecl *D) {
Read/write C++0x static_assert for PCH. llvm-svn: 109123
2010-07-23 01:28:12 +08:00
VisitDecl(D);
Stop instantiating a class if we hit a static_assert failure. Also, if the static_assert fails when parsing the template, don't diagnose it again on every instantiation. llvm-svn: 160088
2012-07-12 06:37:56 +08:00
D->AssertExprAndFailed.setPointer(Reader.ReadExpr(F));
D->AssertExprAndFailed.setInt(Record[Idx++]);
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
D->Message = cast<StringLiteral>(Reader.ReadExpr(F));
Fixed source range for StaticAssertDecl and LinkageSpecDecl. Fixed source range for declarations using postfix types. llvm-svn: 127251
2011-03-09 00:41:52 +08:00
D->RParenLoc = ReadSourceLocation(Record, Idx);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
}
[Sema] Semantic analysis for empty-declaration and attribute-declaration. Introduce a new AST Decl node "EmptyDecl" to model empty-declaration. Have attributes from attribute-declaration appertain to the EmptyDecl node by creating the AST representations of these attributes and attach them to the EmptyDecl node so these attributes can be sema checked just as attributes attached to "normal" declarations. llvm-svn: 175900
2013-02-23 01:15:32 +08:00
void ASTDeclReader::VisitEmptyDecl(EmptyDecl *D) {
VisitDecl(D);
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
std::pair<uint64_t, uint64_t>
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
ASTDeclReader::VisitDeclContext(DeclContext *DC) {
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
uint64_t LexicalOffset = Record[Idx++];
uint64_t VisibleOffset = Record[Idx++];
return std::make_pair(LexicalOffset, VisibleOffset);
}
Apart from storing/retrieving the previous redeclaration from PCH, also store/retrieve the most recent redeclaration. That way we are sure that the full redeclarations chain is loaded. When using chained PCHs, first declarations point to the most recent redeclarations in the same PCH. To address this use a REDECLS_UPDATE_LATEST record block to keep track of which first declarations need to point to a most recent redeclaration in another PCH. llvm-svn: 110125
2010-08-04 01:30:10 +08:00
template <typename T>
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
ASTDeclReader::RedeclarableResult
ASTDeclReader::VisitRedeclarable(Redeclarable<T> *D) {
Completely re-implement (de-)serialization of redeclaration chains, again. The prior implementation was very linked-list oriented, and the list-splicing logic was both fairly convoluted (when loading from multiple modules) and failed to preserve a reasonable ordering for the redeclaration chains. This new implementation uses a simpler strategy, where we store the ordered redeclaration chains in an array-like structure (indexed based on the first declaration), and use that ordering to add individual deserialized declarations to the end of the existing chain. That way, the chain mimics the ordering from its modules, and a bug somewhere is far less likely to result in a broken linked list. llvm-svn: 148222
2012-01-16 00:58:34 +08:00
DeclID FirstDeclID = ReadDeclID(Record, Idx);
Completely re-implement (de-)serialization of declaration chains. The previous implementation relied heavily on the declaration chain being stored as a (circular) linked list on disk, as it is in memory. However, when deserializing from multiple modules, the different chains could get mixed up, leading to broken declaration chains. The new solution keeps track of the first and last declarations in the chain for each module file. When we load a declaration, we search all of the module files for redeclarations of that declaration, then splice together all of the lists into a coherent whole (along with any redeclarations that were actually parsed). As a drive-by fix, (de-)serialize the redeclaration chains of TypedefNameDecls, which had somehow gotten missed previously. Add a test of this serialization. This new scheme creates a redeclaration table that is fairly large in the PCH file (on the order of 400k for Cocoa.h's 12MB PCH file). The table is mmap'd in and searched via a binary search, but it's still quite large. A future tweak will eliminate entries for declarations that have no redeclarations anywhere, and should drastically reduce the size of this table. llvm-svn: 146841
2011-12-18 07:38:30 +08:00
Completely re-implement (de-)serialization of redeclaration chains, again. The prior implementation was very linked-list oriented, and the list-splicing logic was both fairly convoluted (when loading from multiple modules) and failed to preserve a reasonable ordering for the redeclaration chains. This new implementation uses a simpler strategy, where we store the ordered redeclaration chains in an array-like structure (indexed based on the first declaration), and use that ordering to add individual deserialized declarations to the end of the existing chain. That way, the chain mimics the ordering from its modules, and a bug somewhere is far less likely to result in a broken linked list. llvm-svn: 148222
2012-01-16 00:58:34 +08:00
// 0 indicates that this declaration was the only declaration of its entity,
// and is used for space optimization.
if (FirstDeclID == 0)
Re-implement (de-)serialization of redeclaration chains for redeclaration templates (RedeclarableTemplateDecl), similarly to the way (de-)serialization is implemented for Redeclarable<T>. In the process, found a simpler formulation for handling redeclaration chains and implemented that in both places. The new test establishes that we're building the redeclaration chains properly. However, the FIXME indicates where we're tickling a different bug that has to do with us not setting the DefinitionData pointer properly in redeclarations that we detected after the definition itself was deserialized. The (separable) fix for that bug is forthcoming. llvm-svn: 146883
2011-12-20 02:19:24 +08:00
FirstDeclID = ThisDeclID;
Completely re-implement (de-)serialization of redeclaration chains, again. The prior implementation was very linked-list oriented, and the list-splicing logic was both fairly convoluted (when loading from multiple modules) and failed to preserve a reasonable ordering for the redeclaration chains. This new implementation uses a simpler strategy, where we store the ordered redeclaration chains in an array-like structure (indexed based on the first declaration), and use that ordering to add individual deserialized declarations to the end of the existing chain. That way, the chain mimics the ordering from its modules, and a bug somewhere is far less likely to result in a broken linked list. llvm-svn: 148222
2012-01-16 00:58:34 +08:00
T *FirstDecl = cast_or_null<T>(Reader.GetDecl(FirstDeclID));
if (FirstDecl != D) {
When reading the AST, delay loading of the redeclaration chain to avoid deeply nested calls. Temporarily set the first (canonical) declaration as the previous one, which is the one that matters, and mark the real previous DeclID to be loaded & attached later on. Fixes rdar://8956193. llvm-svn: 125434
2011-02-12 15:50:47 +08:00
// We delay loading of the redeclaration chain to avoid deeply nested calls.
// We temporarily set the first (canonical) declaration as the previous one
// which is the one that matters and mark the real previous DeclID to be
// loaded & attached later on.
Address minor FIXME in RedeclLink to contain a PointerIntPair instead of derive from it. Use actual factory functions rather than derived classes acting as named constructors/factories. llvm-svn: 157588
2012-05-29 03:38:42 +08:00
D->RedeclLink = Redeclarable<T>::PreviousDeclLink(FirstDecl);
Completely re-implement (de-)serialization of redeclaration chains, again. The prior implementation was very linked-list oriented, and the list-splicing logic was both fairly convoluted (when loading from multiple modules) and failed to preserve a reasonable ordering for the redeclaration chains. This new implementation uses a simpler strategy, where we store the ordered redeclaration chains in an array-like structure (indexed based on the first declaration), and use that ordering to add individual deserialized declarations to the end of the existing chain. That way, the chain mimics the ordering from its modules, and a bug somewhere is far less likely to result in a broken linked list. llvm-svn: 148222
2012-01-16 00:58:34 +08:00
}
// Note that this declaration has been deserialized.
Reader.RedeclsDeserialized.insert(static_cast<T *>(D));
// The result structure takes care to note that we need to load the
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
// other declaration chains for this ID.
When deserializing a declaration, don't look for redeclarations if its kind indicates that it can never be redeclared. Good for a 1% speedup, and redeclaration searching drops off the profile. llvm-svn: 173054
2013-01-22 00:16:40 +08:00
return RedeclarableResult(Reader, FirstDeclID,
static_cast<T *>(D)->getKind());
Apart from storing/retrieving the previous redeclaration from PCH, also store/retrieve the most recent redeclaration. That way we are sure that the full redeclarations chain is loaded. When using chained PCHs, first declarations point to the most recent redeclarations in the same PCH. To address this use a REDECLS_UPDATE_LATEST record block to keep track of which first declarations need to point to a most recent redeclaration in another PCH. llvm-svn: 110125
2010-08-04 01:30:10 +08:00
}
Factor the merging of declarations in the AST reader out to a separate member function template, since the behavior is identical for ObjCInterfaceDecl and ObjCProtocolDecl. It's expected that all redeclarable entities will have the same behavior. llvm-svn: 147450
2012-01-04 01:27:13 +08:00
/// \brief Attempts to merge the given declaration (D) with another declaration
/// of the same entity.
template<typename T>
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
void ASTDeclReader::mergeRedeclarable(Redeclarable<T> *D,
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
RedeclarableResult &Redecl,
DeclID TemplatePatternID) {
Don't attempt to merge a deserialized declaration with existing declarations in the AST unless modules are enabled. This case doesn't come up with precompiled headers, and it isn't cheap. llvm-svn: 147451
2012-01-04 01:31:38 +08:00
// If modules are not available, there is no reason to perform this merge.
Unify naming of LangOptions variable/get function across the Clang stack (Lex to AST). The member variable is always "LangOpts" and the member function is always "getLangOpts". Reviewed by Chris Lattner llvm-svn: 152536
2012-03-11 15:00:24 +08:00
if (!Reader.getContext().getLangOpts().Modules)
Don't attempt to merge a deserialized declaration with existing declarations in the AST unless modules are enabled. This case doesn't come up with precompiled headers, and it isn't cheap. llvm-svn: 147451
2012-01-04 01:31:38 +08:00
return;
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
if (FindExistingResult ExistingRes = findExisting(static_cast<T*>(D)))
if (T *Existing = ExistingRes)
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
mergeRedeclarable(D, Existing, Redecl, TemplatePatternID);
}
/// \brief "Cast" to type T, asserting if we don't have an implicit conversion.
/// We use this to put code in a template that will only be valid for certain
/// instantiations.
template<typename T> static T assert_cast(T t) { return t; }
template<typename T> static T assert_cast(...) {
llvm_unreachable("bad assert_cast");
}
/// \brief Merge together the pattern declarations from two template
/// declarations.
void ASTDeclReader::mergeTemplatePattern(RedeclarableTemplateDecl *D,
RedeclarableTemplateDecl *Existing,
DeclID DsID) {
auto *DPattern = D->getTemplatedDecl();
auto *ExistingPattern = Existing->getTemplatedDecl();
RedeclarableResult Result(Reader, DsID, DPattern->getKind());
if (auto *DClass = dyn_cast<CXXRecordDecl>(DPattern))
// FIXME: Merge definitions here, if both declarations had definitions.
return mergeRedeclarable(DClass, cast<TagDecl>(ExistingPattern),
Result);
if (auto *DFunction = dyn_cast<FunctionDecl>(DPattern))
return mergeRedeclarable(DFunction, cast<FunctionDecl>(ExistingPattern),
Result);
if (auto *DVar = dyn_cast<VarDecl>(DPattern))
return mergeRedeclarable(DVar, cast<VarDecl>(ExistingPattern), Result);
llvm_unreachable("merged an unknown kind of redeclarable template");
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
}
/// \brief Attempts to merge the given declaration (D) with another declaration
/// of the same entity.
template<typename 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
void ASTDeclReader::mergeRedeclarable(Redeclarable<T> *DBase, T *Existing,
RedeclarableResult &Redecl,
DeclID TemplatePatternID) {
T *D = static_cast<T*>(DBase);
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
T *ExistingCanon = Existing->getCanonicalDecl();
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 *DCanon = D->getCanonicalDecl();
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
if (ExistingCanon != DCanon) {
// Have our redeclaration link point back at the canonical declaration
// of the existing declaration, so that this declaration has the
// appropriate canonical declaration.
D->RedeclLink = Redeclarable<T>::PreviousDeclLink(ExistingCanon);
// When we merge a namespace, update its pointer to the first namespace.
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
if (auto *Namespace = dyn_cast<NamespaceDecl>(D))
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
Namespace->AnonOrFirstNamespaceAndInline.setPointer(
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
assert_cast<NamespaceDecl*>(ExistingCanon));
// When we merge a template, merge its pattern.
if (auto *DTemplate = dyn_cast<RedeclarableTemplateDecl>(D))
mergeTemplatePattern(
DTemplate, assert_cast<RedeclarableTemplateDecl*>(ExistingCanon),
TemplatePatternID);
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
// Don't introduce DCanon into the set of pending declaration chains.
Redecl.suppress();
// Introduce ExistingCanon into the set of pending declaration chains,
// if in fact it came from a module file.
if (ExistingCanon->isFromASTFile()) {
GlobalDeclID ExistingCanonID = ExistingCanon->getGlobalID();
assert(ExistingCanonID && "Unrecorded canonical declaration ID?");
if (Reader.PendingDeclChainsKnown.insert(ExistingCanonID))
Reader.PendingDeclChains.push_back(ExistingCanonID);
}
// If this declaration was the canonical declaration, make a note of
// that. We accept the linear algorithm here because the number of
// unique canonical declarations of an entity should always be tiny.
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
if (DCanon == D) {
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
SmallVectorImpl<DeclID> &Merged = Reader.MergedDecls[ExistingCanon];
if (std::find(Merged.begin(), Merged.end(), Redecl.getFirstID())
== Merged.end())
Merged.push_back(Redecl.getFirstID());
// If ExistingCanon did not come from a module file, introduce the
// first declaration that *does* come from a module file to the
// set of pending declaration chains, so that we merge this
// declaration.
if (!ExistingCanon->isFromASTFile() &&
Reader.PendingDeclChainsKnown.insert(Redecl.getFirstID()))
Reader.PendingDeclChains.push_back(Merged[0]);
Factor the merging of declarations in the AST reader out to a separate member function template, since the behavior is identical for ObjCInterfaceDecl and ObjCProtocolDecl. It's expected that all redeclarable entities will have the same behavior. llvm-svn: 147450
2012-01-04 01:27:13 +08:00
}
}
}
When merging class definitions across modules in C++, merge together fields. This change doesn't go all the way to making fields redeclarable; instead, it makes them 'mergeable', which means we can find the canonical declaration, but not much else (and for a declaration that's not from a module, the canonical declaration is always that declaration). llvm-svn: 192092
2013-10-07 16:02:11 +08:00
/// \brief Attempts to merge the given declaration (D) with another declaration
/// of the same entity, for the case where the entity is not actually
/// redeclarable. This happens, for instance, when merging the fields of
/// identical class definitions from two different modules.
template<typename T>
void ASTDeclReader::mergeMergeable(Mergeable<T> *D) {
// If modules are not available, there is no reason to perform this merge.
if (!Reader.getContext().getLangOpts().Modules)
return;
C++ modules: merging for enumerations and enumerators with multiple definitions (eg through template instantiations in multiple modules). llvm-svn: 192740
2013-10-16 06:02:41 +08:00
// ODR-based merging is only performed in C++. In C, identically-named things
// in different translation units are not redeclarations (but may still have
// compatible types).
if (!Reader.getContext().getLangOpts().CPlusPlus)
return;
When merging class definitions across modules in C++, merge together fields. This change doesn't go all the way to making fields redeclarable; instead, it makes them 'mergeable', which means we can find the canonical declaration, but not much else (and for a declaration that's not from a module, the canonical declaration is always that declaration). llvm-svn: 192092
2013-10-07 16:02:11 +08:00
if (FindExistingResult ExistingRes = findExisting(static_cast<T*>(D)))
if (T *Existing = ExistingRes)
Reader.Context.setPrimaryMergedDecl(static_cast<T*>(D),
Existing->getCanonicalDecl());
}
OpenMP threadprivate directive parsing and semantic analysis llvm-svn: 177705
2013-03-22 14:34:35 +08:00
void ASTDeclReader::VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D) {
VisitDecl(D);
unsigned NumVars = D->varlist_size();
OpenMP threadprivate with qualified names. llvm-svn: 181683
2013-05-13 12:18:18 +08:00
SmallVector<Expr *, 16> Vars;
OpenMP threadprivate directive parsing and semantic analysis llvm-svn: 177705
2013-03-22 14:34:35 +08:00
Vars.reserve(NumVars);
for (unsigned i = 0; i != NumVars; ++i) {
OpenMP threadprivate with qualified names. llvm-svn: 181683
2013-05-13 12:18:18 +08:00
Vars.push_back(Reader.ReadExpr(F));
OpenMP threadprivate directive parsing and semantic analysis llvm-svn: 177705
2013-03-22 14:34:35 +08:00
}
D->setVars(Vars);
}
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
//===----------------------------------------------------------------------===//
move attribute reading to PCHReaderDecl.cpp, remove some extraneous braces. llvm-svn: 70191
2009-04-27 14:01:06 +08:00
// Attribute Reading
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
//===----------------------------------------------------------------------===//
move attribute reading to PCHReaderDecl.cpp, remove some extraneous braces. llvm-svn: 70191
2009-04-27 14:01:06 +08:00
/// \brief Reads attributes from the current stream position.
Promote ModuleMap::Module to a namespace-scope class in the Basic library, since modules cut across all of the libraries. Rename serialization::Module to serialization::ModuleFile to side-step the annoying naming conflict. Prune a bunch of ModuleMap.h includes that are no longer needed (most files only needed the Module type). llvm-svn: 145538
2011-12-01 07:21:26 +08:00
void ASTReader::ReadAttributes(ModuleFile &F, AttrVec &Attrs,
Read/write declaration attributes from/to PCH properly. Embed them in the declaration block instead of trying to create another block. The new block was messing with the assumption that after decls block comes the stmts block. Fixes http://llvm.org/PR8406 llvm-svn: 116737
2010-10-19 03:20:11 +08:00
const RecordData &Record, unsigned &Idx) {
for (unsigned i = 0, e = Record[Idx++]; i != e; ++i) {
move attribute reading to PCHReaderDecl.cpp, remove some extraneous braces. llvm-svn: 70191
2009-04-27 14:01:06 +08:00
Attr *New = 0;
Implement first TD-based usage of attributes. Currently, there are two effective changes: - Attr::Kind has been changed to attr::Kind, in a separate namespace rather than the Attr class. This is because the enumerator needs to be visible to parse. - The class definitions for the C++0x attributes other than aligned are generated by TableGen. The specific classes generated by TableGen are controlled by an array in TableGen (see the accompanying commit to the LLVM repository). I will be expanding the amount of code generated as I develop the new attributes system while initially keeping it confined to these attributes. llvm-svn: 106172
2010-06-17 07:43:53 +08:00
attr::Kind Kind = (attr::Kind)Record[Idx++];
Keep the source range of attributes. Depends on a llvm tablegen commit. llvm-svn: 139600
2011-09-14 00:05:58 +08:00
SourceRange Range = ReadSourceRange(F, Record, Idx);
move attribute reading to PCHReaderDecl.cpp, remove some extraneous braces. llvm-svn: 70191
2009-04-27 14:01:06 +08:00
Generate Attr subclasses with TableGen. Now all classes derived from Attr are generated from TableGen. Additionally, Attr* is no longer its own linked list; SmallVectors or Attr* are used. The accompanying LLVM commit contains the updates to TableGen necessary for this. Some other notes about newly-generated attribute classes: - The constructor arguments are a SourceLocation and a Context&, followed by the attributes arguments in the order that they were defined in Attr.td - Every argument in Attr.td has an appropriate accessor named getFoo, and there are sometimes a few extra ones (such as to get the length of a variadic argument). Additionally, specific_attr_iterator has been introduced, which will iterate over an AttrVec, but only over attributes of a certain type. It can be accessed through either Decl::specific_attr_begin/end or the global functions of the same name. llvm-svn: 111455
2010-08-19 07:23:40 +08:00
#include "clang/Serialization/AttrPCHRead.inc"
move attribute reading to PCHReaderDecl.cpp, remove some extraneous braces. llvm-svn: 70191
2009-04-27 14:01:06 +08:00
assert(New && "Unable to decode attribute?");
Generate Attr subclasses with TableGen. Now all classes derived from Attr are generated from TableGen. Additionally, Attr* is no longer its own linked list; SmallVectors or Attr* are used. The accompanying LLVM commit contains the updates to TableGen necessary for this. Some other notes about newly-generated attribute classes: - The constructor arguments are a SourceLocation and a Context&, followed by the attributes arguments in the order that they were defined in Attr.td - Every argument in Attr.td has an appropriate accessor named getFoo, and there are sometimes a few extra ones (such as to get the length of a variadic argument). Additionally, specific_attr_iterator has been introduced, which will iterate over an AttrVec, but only over attributes of a certain type. It can be accessed through either Decl::specific_attr_begin/end or the global functions of the same name. llvm-svn: 111455
2010-08-19 07:23:40 +08:00
Attrs.push_back(New);
move attribute reading to PCHReaderDecl.cpp, remove some extraneous braces. llvm-svn: 70191
2009-04-27 14:01:06 +08:00
}
}
//===----------------------------------------------------------------------===//
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
// ASTReader Implementation
move attribute reading to PCHReaderDecl.cpp, remove some extraneous braces. llvm-svn: 70191
2009-04-27 14:01:06 +08:00
//===----------------------------------------------------------------------===//
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
/// \brief Note that we have loaded the declaration with the given
/// Index.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
///
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
/// This routine notes that this declaration has already been loaded,
/// so that future GetDecl calls will return this declaration rather
/// than trying to load a new declaration.
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
inline void ASTReader::LoadedDecl(unsigned Index, Decl *D) {
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
assert(!DeclsLoaded[Index] && "Decl loaded twice?");
DeclsLoaded[Index] = D;
}
/// \brief Determine whether the consumer will be interested in seeing
/// this declaration (via HandleTopLevelDecl).
///
/// This routine should return true for anything that might affect
/// code generation, e.g., inline function definitions, Objective-C
/// declarations with metadata, etc.
When we load a function or method body from an AST file, we check whether that function/method already has a body (loaded from some other AST file), as introduced in r165137. Delay this check until after the redeclaration chains have been wired up. While I'm here, make the loading of method bodies lazy. llvm-svn: 165513
2012-10-10 01:21:28 +08:00
static bool isConsumerInterestedIn(Decl *D, bool HasBody) {
[PCH] Fix a regression that r139441 introduced (decls were getting passed to the consumer without being fully deserialized). The regression was on compiling boost.python and it was too difficult to get a reduced test case unfortunately. Also modify the logic of how objc methods are getting passed to the consumer; codegen depended on receiving objc methods before the implementation decl. Since the interesting objc methods are ones with a body and such methods only exist inside an ObjCImplDecl, deserialize and pass to consumer all the methods of ObCImplDecl when we see one. Fixes http://llvm.org/PR10922 & rdar://10117105. llvm-svn: 139644
2011-09-14 05:35:00 +08:00
// An ObjCMethodDecl is never considered as "interesting" because its
// implementation container always is.
Clean up our handling of Objective-C definitions in AST files. Rather than having CodeGen check whether a declaration comes from an AST file (which it shouldn't know or care about), make sure that the AST writer and reader pass along "interesting" declarations that CodeGen needs to know about. llvm-svn: 139441
2011-09-10 08:22:34 +08:00
if (isa<FileScopeAsmDecl>(D) ||
isa<ObjCProtocolDecl>(D) ||
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
isa<ObjCImplDecl>(D) ||
isa<ImportDecl>(D))
PCH: When deserializing an explicit "external definition", don't pass it to HandleTopLevelDecl -- this is already being done inside the reader. This is something of a hack, since whether the reader actually did this depends on the "isConsumerInterestedIn" predicate. I think we need to rework how this works, but I need to discuss with Doug. llvm-svn: 82111
2009-09-17 11:06:44 +08:00
return true;
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
if (VarDecl *Var = dyn_cast<VarDecl>(D))
Make sure C++ variable definitions are actually passed to the consumer when loaded from PCH. llvm-svn: 110322
2010-08-05 17:47:59 +08:00
return Var->isFileVarDecl() &&
Var->isThisDeclarationADefinition() == VarDecl::Definition;
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
if (FunctionDecl *Func = dyn_cast<FunctionDecl>(D))
When we load a function or method body from an AST file, we check whether that function/method already has a body (loaded from some other AST file), as introduced in r165137. Delay this check until after the redeclaration chains have been wired up. While I'm here, make the loading of method bodies lazy. llvm-svn: 165513
2012-10-10 01:21:28 +08:00
return Func->doesThisDeclarationHaveABody() || HasBody;
Clean up our handling of Objective-C definitions in AST files. Rather than having CodeGen check whether a declaration comes from an AST file (which it shouldn't know or care about), make sure that the AST writer and reader pass along "interesting" declarations that CodeGen needs to know about. llvm-svn: 139441
2011-09-10 08:22:34 +08:00
return false;
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Use a ContinuousRangeMap to map from the global declaration ID in the AST reader down to the AST file + local ID within that file, rather than lamely walking the PCH chain. There's no actual functionality change now, but this is cleaner and more general. llvm-svn: 135548
2011-07-20 08:27:43 +08:00
/// \brief Get the correct cursor and offset for loading a declaration.
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
ASTReader::RecordLocation
[PCH] Pull the location out of the serialized declarations and put it in the array of decl bit offsets. This allows us to easily get at the location of a decl without deserializing it. It increases size of Cocoa PCH by only 0.2%. llvm-svn: 143123
2011-10-28 02:47:35 +08:00
ASTReader::DeclCursorForID(DeclID ID, unsigned &RawLocation) {
Instead of modifying the ObjC AST to not modify existing declarations, teach chained PCH to overwrite declarations from earlier PCH files in dependent ones. Tell Sema to note when it changes AST nodes so that they have to be reserialized. Finally, the ObjCProtocolDecls created in forward decls, like the ObjCInterfaceDecls in @class forward decls, are not lexically part of the decl context; only the definition is. llvm-svn: 110989
2010-08-13 08:28:03 +08:00
// See if there's an override.
DeclReplacementMap::iterator It = ReplacedDecls.find(ID);
[PCH] Now that we store the location of a decl outside its record make sure that we keep track of locations of replaced decls as well. llvm-svn: 143341
2011-10-31 15:20:15 +08:00
if (It != ReplacedDecls.end()) {
RawLocation = It->second.RawLoc;
return RecordLocation(It->second.Mod, It->second.Offset);
}
Instead of modifying the ObjC AST to not modify existing declarations, teach chained PCH to overwrite declarations from earlier PCH files in dependent ones. Tell Sema to note when it changes AST nodes so that they have to be reserialized. Finally, the ObjCProtocolDecls created in forward decls, like the ObjCInterfaceDecls in @class forward decls, are not lexically part of the decl context; only the definition is. llvm-svn: 110989
2010-08-13 08:28:03 +08:00
Use a ContinuousRangeMap to map from the global declaration ID in the AST reader down to the AST file + local ID within that file, rather than lamely walking the PCH chain. There's no actual functionality change now, but this is cleaner and more general. llvm-svn: 135548
2011-07-20 08:27:43 +08:00
GlobalDeclMapType::iterator I = GlobalDeclMap.find(ID);
assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
Promote ModuleMap::Module to a namespace-scope class in the Basic library, since modules cut across all of the libraries. Rename serialization::Module to serialization::ModuleFile to side-step the annoying naming conflict. Prune a bunch of ModuleMap.h includes that are no longer needed (most files only needed the Module type). llvm-svn: 145538
2011-12-01 07:21:26 +08:00
ModuleFile *M = I->second;
[PCH] Pull the location out of the serialized declarations and put it in the array of decl bit offsets. This allows us to easily get at the location of a decl without deserializing it. It increases size of Cocoa PCH by only 0.2%. llvm-svn: 143123
2011-10-28 02:47:35 +08:00
const DeclOffset &
DOffs = M->DeclOffsets[ID - M->BaseDeclID - NUM_PREDEF_DECL_IDS];
RawLocation = DOffs.Loc;
return RecordLocation(M, DOffs.BitOffset);
Allow loading declarations from any file in the chain. WIP llvm-svn: 108956
2010-07-21 06:46:15 +08:00
}
Introduce a global bit-offset continuous range map into the ASTReader, so that we have one, simple way to map from global bit offsets to local bit offsets. Eliminates a number of loops over the chain, and generalizes for more interesting bit remappings. Also, as an amusing oddity, we were computing global bit offsets *backwards* for preprocessed entities (e.g., the directly included PCH file in the chain would start at offset zero, rather than the original PCH that occurs first in translation unit). Even more amusingly, it made precompiled preambles work, because we were forgetting to adjust the local bit offset to a global bit offset when storing preprocessed entity offsets in the ASTUnit. Two wrongs made a right, and now they're both right. llvm-svn: 135750
2011-07-22 14:10:01 +08:00
ASTReader::RecordLocation ASTReader::getLocalBitOffset(uint64_t GlobalOffset) {
Promote ModuleMap::Module to a namespace-scope class in the Basic library, since modules cut across all of the libraries. Rename serialization::Module to serialization::ModuleFile to side-step the annoying naming conflict. Prune a bunch of ModuleMap.h includes that are no longer needed (most files only needed the Module type). llvm-svn: 145538
2011-12-01 07:21:26 +08:00
ContinuousRangeMap<uint64_t, ModuleFile*, 4>::iterator I
Introduce a global bit-offset continuous range map into the ASTReader, so that we have one, simple way to map from global bit offsets to local bit offsets. Eliminates a number of loops over the chain, and generalizes for more interesting bit remappings. Also, as an amusing oddity, we were computing global bit offsets *backwards* for preprocessed entities (e.g., the directly included PCH file in the chain would start at offset zero, rather than the original PCH that occurs first in translation unit). Even more amusingly, it made precompiled preambles work, because we were forgetting to adjust the local bit offset to a global bit offset when storing preprocessed entity offsets in the ASTUnit. Two wrongs made a right, and now they're both right. llvm-svn: 135750
2011-07-22 14:10:01 +08:00
= GlobalBitOffsetsMap.find(GlobalOffset);
assert(I != GlobalBitOffsetsMap.end() && "Corrupted global bit offsets map");
return RecordLocation(I->second, GlobalOffset - I->second->GlobalBitOffset);
}
Promote ModuleMap::Module to a namespace-scope class in the Basic library, since modules cut across all of the libraries. Rename serialization::Module to serialization::ModuleFile to side-step the annoying naming conflict. Prune a bunch of ModuleMap.h includes that are no longer needed (most files only needed the Module type). llvm-svn: 145538
2011-12-01 07:21:26 +08:00
uint64_t ASTReader::getGlobalBitOffset(ModuleFile &M, uint32_t LocalOffset) {
Don't introduce a local -> global mapping for CXXBaseSpecifiers. The IDs will never cross module boundaries, since they're tied to the CXXDefinitionData, so just use a local mapping throughout. Eliminate the global -> local tables and supporting data. llvm-svn: 136847
2011-08-04 08:01:48 +08:00
return LocalOffset + M.GlobalBitOffset;
}
Check for matching template-parameter-lists when merging template declarations. llvm-svn: 184791
2013-06-25 06:51:00 +08:00
static bool isSameTemplateParameterList(const TemplateParameterList *X,
const TemplateParameterList *Y);
/// \brief Determine whether two template parameters are similar enough
/// that they may be used in declarations of the same template.
static bool isSameTemplateParameter(const NamedDecl *X,
const NamedDecl *Y) {
if (X->getKind() != Y->getKind())
return false;
if (const TemplateTypeParmDecl *TX = dyn_cast<TemplateTypeParmDecl>(X)) {
const TemplateTypeParmDecl *TY = cast<TemplateTypeParmDecl>(Y);
return TX->isParameterPack() == TY->isParameterPack();
}
if (const NonTypeTemplateParmDecl *TX = dyn_cast<NonTypeTemplateParmDecl>(X)) {
const NonTypeTemplateParmDecl *TY = cast<NonTypeTemplateParmDecl>(Y);
return TX->isParameterPack() == TY->isParameterPack() &&
TX->getASTContext().hasSameType(TX->getType(), TY->getType());
}
const TemplateTemplateParmDecl *TX = cast<TemplateTemplateParmDecl>(X);
const TemplateTemplateParmDecl *TY = cast<TemplateTemplateParmDecl>(Y);
return TX->isParameterPack() == TY->isParameterPack() &&
isSameTemplateParameterList(TX->getTemplateParameters(),
TY->getTemplateParameters());
}
/// \brief Determine whether two template parameter lists are similar enough
/// that they may be used in declarations of the same template.
static bool isSameTemplateParameterList(const TemplateParameterList *X,
const TemplateParameterList *Y) {
if (X->size() != Y->size())
return false;
for (unsigned I = 0, N = X->size(); I != N; ++I)
if (!isSameTemplateParameter(X->getParam(I), Y->getParam(I)))
return false;
return true;
}
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
/// \brief Determine whether the two declarations refer to the same entity.
static bool isSameEntity(NamedDecl *X, NamedDecl *Y) {
assert(X->getDeclName() == Y->getDeclName() && "Declaration name mismatch!");
if (X == Y)
return true;
// Must be in the same context.
if (!X->getDeclContext()->getRedeclContext()->Equals(
Y->getDeclContext()->getRedeclContext()))
return false;
Implement declaration merging for typedefs loaded from disjoint modules, so long as the typedefs refer to the same underlying type. This ensures that the typedefs end up in the same redeclaration chain. To test this, fix name lookup for C/Objective-C to properly deal with multiple declarations with the same name in the same scope. llvm-svn: 147533
2012-01-05 00:44:10 +08:00
// Two typedefs refer to the same entity if they have the same underlying
// type.
if (TypedefNameDecl *TypedefX = dyn_cast<TypedefNameDecl>(X))
if (TypedefNameDecl *TypedefY = dyn_cast<TypedefNameDecl>(Y))
return X->getASTContext().hasSameType(TypedefX->getUnderlyingType(),
TypedefY->getUnderlyingType());
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
Implement declaration merging for typedefs loaded from disjoint modules, so long as the typedefs refer to the same underlying type. This ensures that the typedefs end up in the same redeclaration chain. To test this, fix name lookup for C/Objective-C to properly deal with multiple declarations with the same name in the same scope. llvm-svn: 147533
2012-01-05 00:44:10 +08:00
// Must have the same kind.
if (X->getKind() != Y->getKind())
return false;
Implement declaration merging for Objective-C protocols across multiple, disjoint modules. There is far too much duplicating with the ObjCInterfaceDecl case here, which I'll eliminate shortly. llvm-svn: 147417
2012-01-02 05:47:52 +08:00
// Objective-C classes and protocols with the same name always match.
if (isa<ObjCInterfaceDecl>(X) || isa<ObjCProtocolDecl>(X))
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
return true;
Fix bitcode desynchronization when loading a PCH containing a class template specialization with modules enabled. Just don't merge them at all for now; we'll revisit this when support for template merging is added. In passing, make Decl::dump() a little safer to use with PCH/modules, by making it not deserialize any additional declarations. From a debugger you can call decls_begin() or similar first if you want to dump all child decls. llvm-svn: 182544
2013-05-23 09:49:11 +08:00
if (isa<ClassTemplateSpecializationDecl>(X)) {
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
// No need to handle these here: we merge them when adding them to the
// template.
Fix bitcode desynchronization when loading a PCH containing a class template specialization with modules enabled. Just don't merge them at all for now; we'll revisit this when support for template merging is added. In passing, make Decl::dump() a little safer to use with PCH/modules, by making it not deserialize any additional declarations. From a debugger you can call decls_begin() or similar first if you want to dump all child decls. llvm-svn: 182544
2013-05-23 09:49:11 +08:00
return false;
}
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
Implement cross-module declaration merging for tag declarations, so that if two modules A and B both contain a declaration of a tag such as struct X; and those two modules are unrelated, the two declarations of X will be merged into a single redeclaration chain. llvm-svn: 147488
2012-01-04 06:46:00 +08:00
// Compatible tags match.
Normalize line endings of r163013 (part 2). llvm-svn: 163032
2012-09-01 06:18:20 +08:00
if (TagDecl *TagX = dyn_cast<TagDecl>(X)) {
TagDecl *TagY = cast<TagDecl>(Y);
return (TagX->getTagKind() == TagY->getTagKind()) ||
((TagX->getTagKind() == TTK_Struct || TagX->getTagKind() == TTK_Class ||
TagX->getTagKind() == TTK_Interface) &&
(TagY->getTagKind() == TTK_Struct || TagY->getTagKind() == TTK_Class ||
TagY->getTagKind() == TTK_Interface));
}
Slightly improve cross-module merging for function templates. llvm-svn: 184689
2013-06-24 12:45:28 +08:00
Normalize line endings of r163013 (part 2). llvm-svn: 163032
2012-09-01 06:18:20 +08:00
// Functions with the same type and linkage match.
Slightly improve cross-module merging for function templates. llvm-svn: 184689
2013-06-24 12:45:28 +08:00
// FIXME: This needs to cope with function template specializations,
// merging of prototyped/non-prototyped functions, etc.
Implement declaration merging for non-template functions from different modules. This implementation is a first approximation of what we want, using only the function type to determine equivalence. Later, we'll want to deal with some of the more subtle issues, including: - C allows a prototyped declaration and a non-prototyped declaration to be merged, which we should support - We may want to ignore the return type when merging, then complain if the return types differ. Or, we may want to leave it as it us, so that we only complain if overload resolution eventually fails. - C++ non-static member functions need to consider cv-qualifiers and ref-qualifiers. - Function templates need to consider the template parameters and return type. - Function template specializations will have special rules. - We can now (accidentally!) end up overloading in C, even without the "overloadable" attribute, and will need to detect this at some point. The actual detection of "is this an overload?" is implemented by Sema::IsOverload(), which will need to be moved into the AST library for re-use here. That will be a future refactor. llvm-svn: 147534
2012-01-05 01:13:46 +08:00
if (FunctionDecl *FuncX = dyn_cast<FunctionDecl>(X)) {
FunctionDecl *FuncY = cast<FunctionDecl>(Y);
Cleanup handling of UniqueExternalLinkage. This patch renames getLinkage to getLinkageInternal. Only code that needs to handle UniqueExternalLinkage specially should call this. Linkage, as defined in the c++ standard, is provided by getFormalLinkage. It maps UniqueExternalLinkage to ExternalLinkage. Most places in the compiler actually want isExternallyVisible, which handles UniqueExternalLinkage as internal. llvm-svn: 181677
2013-05-13 08:12:11 +08:00
return (FuncX->getLinkageInternal() == FuncY->getLinkageInternal()) &&
Implement declaration merging for non-template functions from different modules. This implementation is a first approximation of what we want, using only the function type to determine equivalence. Later, we'll want to deal with some of the more subtle issues, including: - C allows a prototyped declaration and a non-prototyped declaration to be merged, which we should support - We may want to ignore the return type when merging, then complain if the return types differ. Or, we may want to leave it as it us, so that we only complain if overload resolution eventually fails. - C++ non-static member functions need to consider cv-qualifiers and ref-qualifiers. - Function templates need to consider the template parameters and return type. - Function template specializations will have special rules. - We can now (accidentally!) end up overloading in C, even without the "overloadable" attribute, and will need to detect this at some point. The actual detection of "is this an overload?" is implemented by Sema::IsOverload(), which will need to be moved into the AST library for re-use here. That will be a future refactor. llvm-svn: 147534
2012-01-05 01:13:46 +08:00
FuncX->getASTContext().hasSameType(FuncX->getType(), FuncY->getType());
}
Also merge template redeclarations. Don't require specializations (of existing and read template) to be unique. llvm-svn: 164931
2012-10-01 17:18:00 +08:00
Implement declaration merging for variables in disjoint modules. llvm-svn: 147535
2012-01-05 01:21:36 +08:00
// Variables with the same type and linkage match.
if (VarDecl *VarX = dyn_cast<VarDecl>(X)) {
VarDecl *VarY = cast<VarDecl>(Y);
Cleanup handling of UniqueExternalLinkage. This patch renames getLinkage to getLinkageInternal. Only code that needs to handle UniqueExternalLinkage specially should call this. Linkage, as defined in the c++ standard, is provided by getFormalLinkage. It maps UniqueExternalLinkage to ExternalLinkage. Most places in the compiler actually want isExternallyVisible, which handles UniqueExternalLinkage as internal. llvm-svn: 181677
2013-05-13 08:12:11 +08:00
return (VarX->getLinkageInternal() == VarY->getLinkageInternal()) &&
Implement declaration merging for variables in disjoint modules. llvm-svn: 147535
2012-01-05 01:21:36 +08:00
VarX->getASTContext().hasSameType(VarX->getType(), VarY->getType());
}
Slightly improve cross-module merging for function templates. llvm-svn: 184689
2013-06-24 12:45:28 +08:00
Implement redeclaration merging for namespaces defined in distinct modules. Teach name lookup into namespaces to search in each of the merged DeclContexts as well as the (now-primary) DeclContext. This supports the common case where two different modules put something into the same namespace. llvm-svn: 147778
2012-01-10 01:30:44 +08:00
// Namespaces with the same name and inlinedness match.
if (NamespaceDecl *NamespaceX = dyn_cast<NamespaceDecl>(X)) {
NamespaceDecl *NamespaceY = cast<NamespaceDecl>(Y);
return NamespaceX->isInline() == NamespaceY->isInline();
}
Also merge template redeclarations. Don't require specializations (of existing and read template) to be unique. llvm-svn: 164931
2012-10-01 17:18:00 +08:00
Slightly improve cross-module merging for function templates. llvm-svn: 184689
2013-06-24 12:45:28 +08:00
// Identical template names and kinds match if their template parameter lists
// and patterns match.
if (TemplateDecl *TemplateX = dyn_cast<TemplateDecl>(X)) {
Check for matching template-parameter-lists when merging template declarations. llvm-svn: 184791
2013-06-25 06:51:00 +08:00
TemplateDecl *TemplateY = cast<TemplateDecl>(Y);
Slightly improve cross-module merging for function templates. llvm-svn: 184689
2013-06-24 12:45:28 +08:00
return isSameEntity(TemplateX->getTemplatedDecl(),
Check for matching template-parameter-lists when merging template declarations. llvm-svn: 184791
2013-06-25 06:51:00 +08:00
TemplateY->getTemplatedDecl()) &&
isSameTemplateParameterList(TemplateX->getTemplateParameters(),
TemplateY->getTemplateParameters());
Slightly improve cross-module merging for function templates. llvm-svn: 184689
2013-06-24 12:45:28 +08:00
}
Also merge template redeclarations. Don't require specializations (of existing and read template) to be unique. llvm-svn: 164931
2012-10-01 17:18:00 +08:00
When merging class definitions across modules in C++, merge together fields. This change doesn't go all the way to making fields redeclarable; instead, it makes them 'mergeable', which means we can find the canonical declaration, but not much else (and for a declaration that's not from a module, the canonical declaration is always that declaration). llvm-svn: 192092
2013-10-07 16:02:11 +08:00
// Fields with the same name and the same type match.
if (FieldDecl *FDX = dyn_cast<FieldDecl>(X)) {
FieldDecl *FDY = cast<FieldDecl>(Y);
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
// FIXME: Diagnose if the types don't match.
C++ modules: merging for enumerations and enumerators with multiple definitions (eg through template instantiations in multiple modules). llvm-svn: 192740
2013-10-16 06:02:41 +08:00
// FIXME: Also check the bitwidth is odr-equivalent, if any.
When merging class definitions across modules in C++, merge together fields. This change doesn't go all the way to making fields redeclarable; instead, it makes them 'mergeable', which means we can find the canonical declaration, but not much else (and for a declaration that's not from a module, the canonical declaration is always that declaration). llvm-svn: 192092
2013-10-07 16:02:11 +08:00
return X->getASTContext().hasSameType(FDX->getType(), FDY->getType());
}
C++ modules: merging for enumerations and enumerators with multiple definitions (eg through template instantiations in multiple modules). llvm-svn: 192740
2013-10-16 06:02:41 +08:00
// Enumerators with the same name match.
if (isa<EnumConstantDecl>(X))
// FIXME: Also check the value is odr-equivalent.
return true;
Make UsingShadowDecls redeclarable. This fixes some visibility problems with modules. With this fixed, I no longer see any test regressions in the libc++ test suite when enabling a single-module module.map for libc++ (other than issues with my system headers). llvm-svn: 193219
2013-10-23 10:17:46 +08:00
// Using shadow declarations with the same target match.
if (UsingShadowDecl *USX = dyn_cast<UsingShadowDecl>(X)) {
UsingShadowDecl *USY = cast<UsingShadowDecl>(Y);
return USX->getTargetDecl() == USY->getTargetDecl();
}
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
// FIXME: Many other cases to implement.
return false;
}
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
/// Find the context in which we should search for previous declarations when
/// looking for declarations to merge.
static DeclContext *getPrimaryContextForMerging(DeclContext *DC) {
if (NamespaceDecl *ND = dyn_cast<NamespaceDecl>(DC))
return ND->getOriginalNamespace();
if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC))
return RD->getDefinition();
C++ modules: merging for enumerations and enumerators with multiple definitions (eg through template instantiations in multiple modules). llvm-svn: 192740
2013-10-16 06:02:41 +08:00
if (EnumDecl *ED = dyn_cast<EnumDecl>(DC))
return ED->getASTContext().getLangOpts().CPlusPlus? ED->getDefinition() : 0;
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
return 0;
}
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
ASTDeclReader::FindExistingResult::~FindExistingResult() {
Implement merging of namespace-scope declarations across modules, so that we can merge, for example, two occurrences of namespace N { void f(); } in two disjoint modules. llvm-svn: 147780
2012-01-10 01:38:47 +08:00
if (!AddResult || Existing)
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
return;
C++ modules: Don't call DeclContext::lookup when half-way through deserializing decls. That can reenter deserialization and explode horribly by trying to merge a declaration that we've not got very far through deserializing yet. llvm-svn: 186236
2013-07-13 10:00:19 +08:00
DeclContext *DC = New->getDeclContext()->getRedeclContext();
if (DC->isTranslationUnit() && Reader.SemaObj) {
Revert most of the functionality in r165001. Instead, make sure that the ASTReader doesn't attach a body to a function that is already defined elsewhere. llvm-svn: 165137
2012-10-04 02:34:48 +08:00
Reader.SemaObj->IdResolver.tryAddTopLevelDecl(New, New->getDeclName());
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
} else if (DeclContext *MergeDC = getPrimaryContextForMerging(DC)) {
C++ modules: Don't call DeclContext::lookup when half-way through deserializing decls. That can reenter deserialization and explode horribly by trying to merge a declaration that we've not got very far through deserializing yet. llvm-svn: 186236
2013-07-13 10:00:19 +08:00
// Add the declaration to its redeclaration context so later merging
// lookups will find it.
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
MergeDC->makeDeclVisibleInContextImpl(New, /*Internal*/true);
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
}
}
ASTDeclReader::FindExistingResult ASTDeclReader::findExisting(NamedDecl *D) {
Implement cross-module declaration merging for tag declarations, so that if two modules A and B both contain a declaration of a tag such as struct X; and those two modules are unrelated, the two declarations of X will be merged into a single redeclaration chain. llvm-svn: 147488
2012-01-04 06:46:00 +08:00
DeclarationName Name = D->getDeclName();
if (!Name) {
// Don't bother trying to find unnamed declarations.
FindExistingResult Result(Reader, D, /*Existing=*/0);
Result.suppress();
return Result;
}
C++ modules: Don't call DeclContext::lookup when half-way through deserializing decls. That can reenter deserialization and explode horribly by trying to merge a declaration that we've not got very far through deserializing yet. llvm-svn: 186236
2013-07-13 10:00:19 +08:00
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
// FIXME: Bail out for non-canonical declarations. We will have performed any
// necessary merging already.
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
DeclContext *DC = D->getDeclContext()->getRedeclContext();
if (DC->isTranslationUnit() && Reader.SemaObj) {
IdentifierResolver &IdResolver = Reader.SemaObj->IdResolver;
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
// Temporarily consider the identifier to be up-to-date. We don't want to
// cause additional lookups here.
class UpToDateIdentifierRAII {
IdentifierInfo *II;
bool WasOutToDate;
public:
explicit UpToDateIdentifierRAII(IdentifierInfo *II)
: II(II), WasOutToDate(false)
{
if (II) {
WasOutToDate = II->isOutOfDate();
if (WasOutToDate)
II->setOutOfDate(false);
}
}
~UpToDateIdentifierRAII() {
if (WasOutToDate)
II->setOutOfDate(true);
}
} UpToDate(Name.getAsIdentifierInfo());
Implement cross-module declaration merging for tag declarations, so that if two modules A and B both contain a declaration of a tag such as struct X; and those two modules are unrelated, the two declarations of X will be merged into a single redeclaration chain. llvm-svn: 147488
2012-01-04 06:46:00 +08:00
for (IdentifierResolver::iterator I = IdResolver.begin(Name),
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
IEnd = IdResolver.end();
I != IEnd; ++I) {
if (isSameEntity(*I, D))
return FindExistingResult(Reader, D, *I);
}
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
} else if (DeclContext *MergeDC = getPrimaryContextForMerging(DC)) {
DeclContext::lookup_result R = MergeDC->noload_lookup(Name);
C++ modules: Don't call DeclContext::lookup when half-way through deserializing decls. That can reenter deserialization and explode horribly by trying to merge a declaration that we've not got very far through deserializing yet. llvm-svn: 186236
2013-07-13 10:00:19 +08:00
for (DeclContext::lookup_iterator I = R.begin(), E = R.end(); I != E; ++I) {
Change DeclContextLookup(Const)Result to (Mutable)ArrayRef<NamedDecl*>, as per review discussion in r170365 This does limit these typedefs to being sequences, but no current usage requires them to be contiguous (we could expand this to a more general iterator pair range concept at some point). Also, it'd be nice if SmallVector were constructible directly from an ArrayRef but this is a bit tricky since ArrayRef depends on SmallVectorBaseImpl for the inverse conversion. (& generalizing over all range-like things, while nice, would require some nontrivial SFINAE I haven't thought about yet) llvm-svn: 170482
2012-12-19 08:45:41 +08:00
if (isSameEntity(*I, D))
return FindExistingResult(Reader, D, *I);
Implement merging of namespace-scope declarations across modules, so that we can merge, for example, two occurrences of namespace N { void f(); } in two disjoint modules. llvm-svn: 147780
2012-01-10 01:38:47 +08:00
}
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
} else {
// Not in a mergeable context.
return FindExistingResult(Reader);
Implement merging of namespace-scope declarations across modules, so that we can merge, for example, two occurrences of namespace N { void f(); } in two disjoint modules. llvm-svn: 147780
2012-01-10 01:38:47 +08:00
}
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
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
// If this declaration is from a merged context, make a note that we need to
// check that the canonical definition of that context contains the decl.
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
//
// FIXME: We should do something similar if we merge two definitions of the
// same template specialization into the same CXXRecordDecl.
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
if (Reader.MergedDeclContexts.count(D->getLexicalDeclContext()))
Reader.PendingOdrMergeChecks.push_back(D);
return FindExistingResult(Reader, D, /*Existing=*/0);
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
}
When reading the AST, delay loading of the redeclaration chain to avoid deeply nested calls. Temporarily set the first (canonical) declaration as the previous one, which is the one that matters, and mark the real previous DeclID to be loaded & attached later on. Fixes rdar://8956193. llvm-svn: 125434
2011-02-12 15:50:47 +08:00
void ASTDeclReader::attachPreviousDecl(Decl *D, Decl *previous) {
assert(D && previous);
if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
Address minor FIXME in RedeclLink to contain a PointerIntPair instead of derive from it. Use actual factory functions rather than derived classes acting as named constructors/factories. llvm-svn: 157588
2012-05-29 03:38:42 +08:00
TD->RedeclLink.setNext(cast<TagDecl>(previous));
When reading the AST, delay loading of the redeclaration chain to avoid deeply nested calls. Temporarily set the first (canonical) declaration as the previous one, which is the one that matters, and mark the real previous DeclID to be loaded & attached later on. Fixes rdar://8956193. llvm-svn: 125434
2011-02-12 15:50:47 +08:00
} else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
Address minor FIXME in RedeclLink to contain a PointerIntPair instead of derive from it. Use actual factory functions rather than derived classes acting as named constructors/factories. llvm-svn: 157588
2012-05-29 03:38:42 +08:00
FD->RedeclLink.setNext(cast<FunctionDecl>(previous));
When reading the AST, delay loading of the redeclaration chain to avoid deeply nested calls. Temporarily set the first (canonical) declaration as the previous one, which is the one that matters, and mark the real previous DeclID to be loaded & attached later on. Fixes rdar://8956193. llvm-svn: 125434
2011-02-12 15:50:47 +08:00
} else if (VarDecl *VD = dyn_cast<VarDecl>(D)) {
Address minor FIXME in RedeclLink to contain a PointerIntPair instead of derive from it. Use actual factory functions rather than derived classes acting as named constructors/factories. llvm-svn: 157588
2012-05-29 03:38:42 +08:00
VD->RedeclLink.setNext(cast<VarDecl>(previous));
Completely re-implement (de-)serialization of declaration chains. The previous implementation relied heavily on the declaration chain being stored as a (circular) linked list on disk, as it is in memory. However, when deserializing from multiple modules, the different chains could get mixed up, leading to broken declaration chains. The new solution keeps track of the first and last declarations in the chain for each module file. When we load a declaration, we search all of the module files for redeclarations of that declaration, then splice together all of the lists into a coherent whole (along with any redeclarations that were actually parsed). As a drive-by fix, (de-)serialize the redeclaration chains of TypedefNameDecls, which had somehow gotten missed previously. Add a test of this serialization. This new scheme creates a redeclaration table that is fairly large in the PCH file (on the order of 400k for Cocoa.h's 12MB PCH file). The table is mmap'd in and searched via a binary search, but it's still quite large. A future tweak will eliminate entries for declarations that have no redeclarations anywhere, and should drastically reduce the size of this table. llvm-svn: 146841
2011-12-18 07:38:30 +08:00
} else if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D)) {
Address minor FIXME in RedeclLink to contain a PointerIntPair instead of derive from it. Use actual factory functions rather than derived classes acting as named constructors/factories. llvm-svn: 157588
2012-05-29 03:38:42 +08:00
TD->RedeclLink.setNext(cast<TypedefNameDecl>(previous));
Make UsingShadowDecls redeclarable. This fixes some visibility problems with modules. With this fixed, I no longer see any test regressions in the libc++ test suite when enabling a single-module module.map for libc++ (other than issues with my system headers). llvm-svn: 193219
2013-10-23 10:17:46 +08:00
} else if (UsingShadowDecl *USD = dyn_cast<UsingShadowDecl>(D)) {
USD->RedeclLink.setNext(cast<UsingShadowDecl>(previous));
Completely re-implement (de-)serialization of declaration chains. The previous implementation relied heavily on the declaration chain being stored as a (circular) linked list on disk, as it is in memory. However, when deserializing from multiple modules, the different chains could get mixed up, leading to broken declaration chains. The new solution keeps track of the first and last declarations in the chain for each module file. When we load a declaration, we search all of the module files for redeclarations of that declaration, then splice together all of the lists into a coherent whole (along with any redeclarations that were actually parsed). As a drive-by fix, (de-)serialize the redeclaration chains of TypedefNameDecls, which had somehow gotten missed previously. Add a test of this serialization. This new scheme creates a redeclaration table that is fairly large in the PCH file (on the order of 400k for Cocoa.h's 12MB PCH file). The table is mmap'd in and searched via a binary search, but it's still quite large. A future tweak will eliminate entries for declarations that have no redeclarations anywhere, and should drastically reduce the size of this table. llvm-svn: 146841
2011-12-18 07:38:30 +08:00
} else if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
Address minor FIXME in RedeclLink to contain a PointerIntPair instead of derive from it. Use actual factory functions rather than derived classes acting as named constructors/factories. llvm-svn: 157588
2012-05-29 03:38:42 +08:00
ID->RedeclLink.setNext(cast<ObjCInterfaceDecl>(previous));
Introduce the core infrastructure needed to model redeclaration chains for Objective-C protocols, including: - Using the first declaration as the canonical declaration - Using the definition as the primary DeclContext - Making sure that all declarations have a pointer to the definition data, and that we know which declaration is the definition - Serialization support for redeclaration chains and for adding definitions to already-serialized declarations. However, note that we're not taking advantage of much of this code yet, because we're still re-using ObjCProtocolDecls. llvm-svn: 147410
2012-01-02 03:51:50 +08:00
} else if (ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl>(D)) {
Address minor FIXME in RedeclLink to contain a PointerIntPair instead of derive from it. Use actual factory functions rather than derived classes acting as named constructors/factories. llvm-svn: 157588
2012-05-29 03:38:42 +08:00
PD->RedeclLink.setNext(cast<ObjCProtocolDecl>(previous));
Switch NamespaceDecl from its own hand-rolled redeclaration chain over to Redeclarable<NamespaceDecl>, so that we benefit from the improveed redeclaration deserialization and merging logic provided by Redeclarable<T>. Otherwise, no functionality change. As a drive-by fix, collapse the "inline" bit into the low bit of the original namespace/anonymous namespace, saving 8 bytes per NamespaceDecl on x86_64. llvm-svn: 147729
2012-01-07 17:11:48 +08:00
} else if (NamespaceDecl *ND = dyn_cast<NamespaceDecl>(D)) {
Address minor FIXME in RedeclLink to contain a PointerIntPair instead of derive from it. Use actual factory functions rather than derived classes acting as named constructors/factories. llvm-svn: 157588
2012-05-29 03:38:42 +08:00
ND->RedeclLink.setNext(cast<NamespaceDecl>(previous));
When reading the AST, delay loading of the redeclaration chain to avoid deeply nested calls. Temporarily set the first (canonical) declaration as the previous one, which is the one that matters, and mark the real previous DeclID to be loaded & attached later on. Fixes rdar://8956193. llvm-svn: 125434
2011-02-12 15:50:47 +08:00
} else {
RedeclarableTemplateDecl *TD = cast<RedeclarableTemplateDecl>(D);
Address minor FIXME in RedeclLink to contain a PointerIntPair instead of derive from it. Use actual factory functions rather than derived classes acting as named constructors/factories. llvm-svn: 157588
2012-05-29 03:38:42 +08:00
TD->RedeclLink.setNext(cast<RedeclarableTemplateDecl>(previous));
When reading the AST, delay loading of the redeclaration chain to avoid deeply nested calls. Temporarily set the first (canonical) declaration as the previous one, which is the one that matters, and mark the real previous DeclID to be loaded & attached later on. Fixes rdar://8956193. llvm-svn: 125434
2011-02-12 15:50:47 +08:00
}
When merging redeclaration chains across modules, if a declaration is visible in one module but is only declared as a friend in another module, keep it visible in the result of the merge. This is incomplete on two axes: 1) Our handling of local extern declarations is basically broken (we put them in the wrong decl context, and don't find them in redeclaration lookup, unless they've previously been declared), and this results in them making friends visible after a merge. 2) Eventually we'll need to mark that this has happened, and more carefully check whether a declaration should be visible if it was only visible in some of the modules in which it was declared. Fortunately it's rare for the identifier namespace of a declaration to change along its redeclaration chain. llvm-svn: 187639
2013-08-02 09:09:12 +08:00
// If the declaration was visible in one module, a redeclaration of it in
// another module remains visible even if it wouldn't be visible by itself.
//
// FIXME: In this case, the declaration should only be visible if a module
// that makes it visible has been imported.
D->IdentifierNamespace |=
previous->IdentifierNamespace &
(Decl::IDNS_Ordinary | Decl::IDNS_Tag | Decl::IDNS_Type);
When reading the AST, delay loading of the redeclaration chain to avoid deeply nested calls. Temporarily set the first (canonical) declaration as the previous one, which is the one that matters, and mark the real previous DeclID to be loaded & attached later on. Fixes rdar://8956193. llvm-svn: 125434
2011-02-12 15:50:47 +08:00
}
Completely re-implement (de-)serialization of declaration chains. The previous implementation relied heavily on the declaration chain being stored as a (circular) linked list on disk, as it is in memory. However, when deserializing from multiple modules, the different chains could get mixed up, leading to broken declaration chains. The new solution keeps track of the first and last declarations in the chain for each module file. When we load a declaration, we search all of the module files for redeclarations of that declaration, then splice together all of the lists into a coherent whole (along with any redeclarations that were actually parsed). As a drive-by fix, (de-)serialize the redeclaration chains of TypedefNameDecls, which had somehow gotten missed previously. Add a test of this serialization. This new scheme creates a redeclaration table that is fairly large in the PCH file (on the order of 400k for Cocoa.h's 12MB PCH file). The table is mmap'd in and searched via a binary search, but it's still quite large. A future tweak will eliminate entries for declarations that have no redeclarations anywhere, and should drastically reduce the size of this table. llvm-svn: 146841
2011-12-18 07:38:30 +08:00
void ASTDeclReader::attachLatestDecl(Decl *D, Decl *Latest) {
assert(D && Latest);
if (TagDecl *TD = dyn_cast<TagDecl>(D)) {
TD->RedeclLink
= Redeclarable<TagDecl>::LatestDeclLink(cast<TagDecl>(Latest));
} else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
Make UsingShadowDecls redeclarable. This fixes some visibility problems with modules. With this fixed, I no longer see any test regressions in the libc++ test suite when enabling a single-module module.map for libc++ (other than issues with my system headers). llvm-svn: 193219
2013-10-23 10:17:46 +08:00
FD->RedeclLink
Completely re-implement (de-)serialization of declaration chains. The previous implementation relied heavily on the declaration chain being stored as a (circular) linked list on disk, as it is in memory. However, when deserializing from multiple modules, the different chains could get mixed up, leading to broken declaration chains. The new solution keeps track of the first and last declarations in the chain for each module file. When we load a declaration, we search all of the module files for redeclarations of that declaration, then splice together all of the lists into a coherent whole (along with any redeclarations that were actually parsed). As a drive-by fix, (de-)serialize the redeclaration chains of TypedefNameDecls, which had somehow gotten missed previously. Add a test of this serialization. This new scheme creates a redeclaration table that is fairly large in the PCH file (on the order of 400k for Cocoa.h's 12MB PCH file). The table is mmap'd in and searched via a binary search, but it's still quite large. A future tweak will eliminate entries for declarations that have no redeclarations anywhere, and should drastically reduce the size of this table. llvm-svn: 146841
2011-12-18 07:38:30 +08:00
= Redeclarable<FunctionDecl>::LatestDeclLink(cast<FunctionDecl>(Latest));
} else if (VarDecl *VD = dyn_cast<VarDecl>(D)) {
VD->RedeclLink
= Redeclarable<VarDecl>::LatestDeclLink(cast<VarDecl>(Latest));
} else if (TypedefNameDecl *TD = dyn_cast<TypedefNameDecl>(D)) {
TD->RedeclLink
= Redeclarable<TypedefNameDecl>::LatestDeclLink(
cast<TypedefNameDecl>(Latest));
Make UsingShadowDecls redeclarable. This fixes some visibility problems with modules. With this fixed, I no longer see any test regressions in the libc++ test suite when enabling a single-module module.map for libc++ (other than issues with my system headers). llvm-svn: 193219
2013-10-23 10:17:46 +08:00
} else if (UsingShadowDecl *USD = dyn_cast<UsingShadowDecl>(D)) {
USD->RedeclLink
= Redeclarable<UsingShadowDecl>::LatestDeclLink(
cast<UsingShadowDecl>(Latest));
Completely re-implement (de-)serialization of declaration chains. The previous implementation relied heavily on the declaration chain being stored as a (circular) linked list on disk, as it is in memory. However, when deserializing from multiple modules, the different chains could get mixed up, leading to broken declaration chains. The new solution keeps track of the first and last declarations in the chain for each module file. When we load a declaration, we search all of the module files for redeclarations of that declaration, then splice together all of the lists into a coherent whole (along with any redeclarations that were actually parsed). As a drive-by fix, (de-)serialize the redeclaration chains of TypedefNameDecls, which had somehow gotten missed previously. Add a test of this serialization. This new scheme creates a redeclaration table that is fairly large in the PCH file (on the order of 400k for Cocoa.h's 12MB PCH file). The table is mmap'd in and searched via a binary search, but it's still quite large. A future tweak will eliminate entries for declarations that have no redeclarations anywhere, and should drastically reduce the size of this table. llvm-svn: 146841
2011-12-18 07:38:30 +08:00
} else if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
ID->RedeclLink
= Redeclarable<ObjCInterfaceDecl>::LatestDeclLink(
cast<ObjCInterfaceDecl>(Latest));
Introduce the core infrastructure needed to model redeclaration chains for Objective-C protocols, including: - Using the first declaration as the canonical declaration - Using the definition as the primary DeclContext - Making sure that all declarations have a pointer to the definition data, and that we know which declaration is the definition - Serialization support for redeclaration chains and for adding definitions to already-serialized declarations. However, note that we're not taking advantage of much of this code yet, because we're still re-using ObjCProtocolDecls. llvm-svn: 147410
2012-01-02 03:51:50 +08:00
} else if (ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl>(D)) {
PD->RedeclLink
= Redeclarable<ObjCProtocolDecl>::LatestDeclLink(
cast<ObjCProtocolDecl>(Latest));
Switch NamespaceDecl from its own hand-rolled redeclaration chain over to Redeclarable<NamespaceDecl>, so that we benefit from the improveed redeclaration deserialization and merging logic provided by Redeclarable<T>. Otherwise, no functionality change. As a drive-by fix, collapse the "inline" bit into the low bit of the original namespace/anonymous namespace, saving 8 bytes per NamespaceDecl on x86_64. llvm-svn: 147729
2012-01-07 17:11:48 +08:00
} else if (NamespaceDecl *ND = dyn_cast<NamespaceDecl>(D)) {
ND->RedeclLink
= Redeclarable<NamespaceDecl>::LatestDeclLink(
cast<NamespaceDecl>(Latest));
Completely re-implement (de-)serialization of declaration chains. The previous implementation relied heavily on the declaration chain being stored as a (circular) linked list on disk, as it is in memory. However, when deserializing from multiple modules, the different chains could get mixed up, leading to broken declaration chains. The new solution keeps track of the first and last declarations in the chain for each module file. When we load a declaration, we search all of the module files for redeclarations of that declaration, then splice together all of the lists into a coherent whole (along with any redeclarations that were actually parsed). As a drive-by fix, (de-)serialize the redeclaration chains of TypedefNameDecls, which had somehow gotten missed previously. Add a test of this serialization. This new scheme creates a redeclaration table that is fairly large in the PCH file (on the order of 400k for Cocoa.h's 12MB PCH file). The table is mmap'd in and searched via a binary search, but it's still quite large. A future tweak will eliminate entries for declarations that have no redeclarations anywhere, and should drastically reduce the size of this table. llvm-svn: 146841
2011-12-18 07:38:30 +08:00
} else {
RedeclarableTemplateDecl *TD = cast<RedeclarableTemplateDecl>(D);
Reimplement RedeclarableTemplateDecl in terms of Redeclarable<RedeclarableTemplateDecl>, eliminating a bunch of redeclaration-chain logic both in RedeclarableTemplateDecl and especially in its (de-)serialization. As part of this, eliminate the RedeclarableTemplate<> class template, which was an abstraction that didn't actually save anything. llvm-svn: 148181
2012-01-14 23:13:49 +08:00
TD->RedeclLink
= Redeclarable<RedeclarableTemplateDecl>::LatestDeclLink(
cast<RedeclarableTemplateDecl>(Latest));
Completely re-implement (de-)serialization of declaration chains. The previous implementation relied heavily on the declaration chain being stored as a (circular) linked list on disk, as it is in memory. However, when deserializing from multiple modules, the different chains could get mixed up, leading to broken declaration chains. The new solution keeps track of the first and last declarations in the chain for each module file. When we load a declaration, we search all of the module files for redeclarations of that declaration, then splice together all of the lists into a coherent whole (along with any redeclarations that were actually parsed). As a drive-by fix, (de-)serialize the redeclaration chains of TypedefNameDecls, which had somehow gotten missed previously. Add a test of this serialization. This new scheme creates a redeclaration table that is fairly large in the PCH file (on the order of 400k for Cocoa.h's 12MB PCH file). The table is mmap'd in and searched via a binary search, but it's still quite large. A future tweak will eliminate entries for declarations that have no redeclarations anywhere, and should drastically reduce the size of this table. llvm-svn: 146841
2011-12-18 07:38:30 +08:00
}
}
Serialize the AST reader's mapping from canonical declarations to the set of (previously-canonical) declaration IDs to the module file, so that future AST reader instances that load the module know which declarations are merged. This is important in the fairly tricky case where a declaration of an entity, e.g., @class X; occurs before the import of a module that also declares that entity. We merge the declarations, and record the fact that the declaration of X loaded from the module was merged into the (now canonical) declaration of X that we parsed. llvm-svn: 147181
2011-12-23 05:40:42 +08:00
ASTReader::MergedDeclsMap::iterator
ASTReader::combineStoredMergedDecls(Decl *Canon, GlobalDeclID CanonID) {
// If we don't have any stored merged declarations, just look in the
// merged declarations set.
StoredMergedDeclsMap::iterator StoredPos = StoredMergedDecls.find(CanonID);
if (StoredPos == StoredMergedDecls.end())
return MergedDecls.find(Canon);
// Append the stored merged declarations to the merged declarations set.
MergedDeclsMap::iterator Pos = MergedDecls.find(Canon);
if (Pos == MergedDecls.end())
Pos = MergedDecls.insert(std::make_pair(Canon,
SmallVector<DeclID, 2>())).first;
Pos->second.append(StoredPos->second.begin(), StoredPos->second.end());
StoredMergedDecls.erase(StoredPos);
// Sort and uniquify the set of merged declarations.
llvm::array_pod_sort(Pos->second.begin(), Pos->second.end());
Pos->second.erase(std::unique(Pos->second.begin(), Pos->second.end()),
Pos->second.end());
return Pos;
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
/// \brief Read the declaration at the given offset from the AST file.
Introduce the local -> global declaration ID mapping into the AST reader, to allow AST files to be loaded with their declarations remapped to different ID numbers. Fix a number of places where we were either failing to map local declaration IDs into global declaration IDs or where interpreting the local declaration IDs within the wrong module. I've tested this via the usual "random gaps" method. It works well except for the preamble tests, because our handling of the precompiled preamble requires declaration and preprocessed entity to be stable when parsing code and then loading that back into memory. This property will hold in general, but my randomized testing naturally breaks this property to get more coverage. In the future, I expect that the precompiled preamble logic won't need this property. I am very unhappy with the current handling of the translation unit, which is a rather egregious hack. We're going to have to do something very different here for loading multiple AST files, because we don't want to have to cope with merging two translation units. Likely, we'll just handle translation units entirely via "update" records, and predefine a single, fixed declaration ID for the translation unit. That will come later. llvm-svn: 136779
2011-08-03 23:48:04 +08:00
Decl *ASTReader::ReadDeclRecord(DeclID ID) {
In the serialized AST format, make the translation unit a "predefined" declaration that never actually gets serialized. Instead, serialize the various kinds of update records (lexical decls, visible decls, the addition of an anonymous namespace) for the translation unit, even if we're not chaining. This way, we won't have to deal with multiple loaded translation unit declarations. llvm-svn: 137395
2011-08-12 08:15:20 +08:00
unsigned Index = ID - NUM_PREDEF_DECL_IDS;
[PCH] Pull the location out of the serialized declarations and put it in the array of decl bit offsets. This allows us to easily get at the location of a decl without deserializing it. It increases size of Cocoa PCH by only 0.2%. llvm-svn: 143123
2011-10-28 02:47:35 +08:00
unsigned RawLocation = 0;
RecordLocation Loc = DeclCursorForID(ID, RawLocation);
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
llvm::BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor;
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
// Keep track of where we are in the stream, then jump back there
// after reading this declaration.
read all decls (and attributes and stmts/exprs referenced by the decl) from the DeclsCursor. llvm-svn: 70190
2009-04-27 13:58:23 +08:00
SavedStreamPosition SavedPosition(DeclsCursor);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
ReadingKindTracker ReadingKind(Read_Decl, *this);
Fix PR 4489, a crash in PCH loading that occurs when loading the name of a top-level declaration loads another top-level declaration of the same name whose type depends on the first declaration having been completed. This commit breaks the circular dependency by delaying loads of top-level declarations triggered by loading a name until we are no longer recursively loading types or declarations. llvm-svn: 74847
2009-07-07 02:54:52 +08:00
// Note that we are loading a declaration record.
Refactor the way PCHReader tracks whether we are in recursive loading. -Replace CurrentlyLoadingTypeOrDecl with a counting scheme (NumCurrentElementsDeserializing) -Provide outside access to the mechanism by adding methods StartedDeserializing/FinishedDeserializing to ExternalASTSource. These are preparation for the next commit. llvm-svn: 109856
2010-07-30 18:03:16 +08:00
Deserializing ADecl(this);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
DeclsCursor.JumpToBit(Loc.Offset);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
RecordData Record;
read all decls (and attributes and stmts/exprs referenced by the decl) from the DeclsCursor. llvm-svn: 70190
2009-04-27 13:58:23 +08:00
unsigned Code = DeclsCursor.ReadCode();
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
unsigned Idx = 0;
Remove an unused private field exposed by the recent LLVM_DELETED_FUNCTION changes. llvm-svn: 164106
2012-09-18 13:34:55 +08:00
ASTDeclReader Reader(*this, *Loc.F, ID, RawLocation, Record,Idx);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
read all decls (and attributes and stmts/exprs referenced by the decl) from the DeclsCursor. llvm-svn: 70190
2009-04-27 13:58:23 +08:00
Decl *D = 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
switch ((DeclCode)DeclsCursor.readRecord(Code, Record)) {
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_CONTEXT_LEXICAL:
case DECL_CONTEXT_VISIBLE:
Switch assert(0/false) llvm_unreachable. llvm-svn: 140367
2011-09-23 13:06:16 +08:00
llvm_unreachable("Record cannot be de-serialized with ReadDeclRecord");
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_TYPEDEF:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = TypedefDecl::CreateDeserialized(Context, ID);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
break;
Support for C++11 (non-template) alias declarations. llvm-svn: 129567
2011-04-15 22:24:37 +08:00
case DECL_TYPEALIAS:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = TypeAliasDecl::CreateDeserialized(Context, ID);
Support for C++11 (non-template) alias declarations. llvm-svn: 129567
2011-04-15 22:24:37 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_ENUM:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = EnumDecl::CreateDeserialized(Context, ID);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_RECORD:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = RecordDecl::CreateDeserialized(Context, ID);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_ENUM_CONSTANT:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = EnumConstantDecl::CreateDeserialized(Context, ID);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_FUNCTION:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = FunctionDecl::CreateDeserialized(Context, ID);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_LINKAGE_SPEC:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = LinkageSpecDecl::CreateDeserialized(Context, ID);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
break;
Step #1/N of implementing support for __label__: split labels into LabelDecl and LabelStmt. There is a 1-1 correspondence between the two, but this simplifies a bunch of code by itself. This is because labels are the only place where we previously had references to random other statements, causing grief for AST serialization and other stuff. This does cause one regression (attr(unused) doesn't silence unused label warnings) which I'll address next. This does fix some minor bugs: 1. "The only valid attribute " diagnostic was capitalized. 2. Various diagnostics printed as ''labelname'' instead of 'labelname' 3. This reduces duplication of label checking between functions and blocks. Review appreciated, particularly for the cindex and template bits. llvm-svn: 125733
2011-02-17 15:39:24 +08:00
case DECL_LABEL:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = LabelDecl::CreateDeserialized(Context, ID);
Step #1/N of implementing support for __label__: split labels into LabelDecl and LabelStmt. There is a 1-1 correspondence between the two, but this simplifies a bunch of code by itself. This is because labels are the only place where we previously had references to random other statements, causing grief for AST serialization and other stuff. This does cause one regression (attr(unused) doesn't silence unused label warnings) which I'll address next. This does fix some minor bugs: 1. "The only valid attribute " diagnostic was capitalized. 2. Various diagnostics printed as ''labelname'' instead of 'labelname' 3. This reduces duplication of label checking between functions and blocks. Review appreciated, particularly for the cindex and template bits. llvm-svn: 125733
2011-02-17 15:39:24 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_NAMESPACE:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = NamespaceDecl::CreateDeserialized(Context, ID);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_NAMESPACE_ALIAS:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = NamespaceAliasDecl::CreateDeserialized(Context, ID);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_USING:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = UsingDecl::CreateDeserialized(Context, ID);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_USING_SHADOW:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = UsingShadowDecl::CreateDeserialized(Context, ID);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_USING_DIRECTIVE:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = UsingDirectiveDecl::CreateDeserialized(Context, ID);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_UNRESOLVED_USING_VALUE:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = UnresolvedUsingValueDecl::CreateDeserialized(Context, ID);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_UNRESOLVED_USING_TYPENAME:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = UnresolvedUsingTypenameDecl::CreateDeserialized(Context, ID);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_CXX_RECORD:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = CXXRecordDecl::CreateDeserialized(Context, ID);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_CXX_METHOD:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = CXXMethodDecl::CreateDeserialized(Context, ID);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_CXX_CONSTRUCTOR:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = CXXConstructorDecl::CreateDeserialized(Context, ID);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_CXX_DESTRUCTOR:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = CXXDestructorDecl::CreateDeserialized(Context, ID);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_CXX_CONVERSION:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = CXXConversionDecl::CreateDeserialized(Context, ID);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_ACCESS_SPEC:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = AccessSpecDecl::CreateDeserialized(Context, ID);
Added AccessSpecDecl node. llvm-svn: 105525
2010-06-05 13:09:32 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_FRIEND:
Added outer template parameter lists to friend type AST nodes. llvm-svn: 174050
2013-01-31 17:54:08 +08:00
D = FriendDecl::CreateDeserialized(Context, ID, Record[Idx++]);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_FRIEND_TEMPLATE:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = FriendTemplateDecl::CreateDeserialized(Context, ID);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_CLASS_TEMPLATE:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = ClassTemplateDecl::CreateDeserialized(Context, ID);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_CLASS_TEMPLATE_SPECIALIZATION:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = ClassTemplateSpecializationDecl::CreateDeserialized(Context, ID);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = ClassTemplatePartialSpecializationDecl::CreateDeserialized(Context, ID);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
break;
Started implementing variable templates. Top level declarations should be fully supported, up to some limitations documented as FIXMEs or TODO. Static data member templates work very partially. Static data member templates of class templates need particular attention... llvm-svn: 187762
2013-08-06 09:03:05 +08:00
case DECL_VAR_TEMPLATE:
D = VarTemplateDecl::CreateDeserialized(Context, ID);
break;
case DECL_VAR_TEMPLATE_SPECIALIZATION:
D = VarTemplateSpecializationDecl::CreateDeserialized(Context, ID);
break;
case DECL_VAR_TEMPLATE_PARTIAL_SPECIALIZATION:
D = VarTemplatePartialSpecializationDecl::CreateDeserialized(Context, ID);
break;
Implement function template specialization at class scope extension in Microsoft mode. A new AST node is introduced: ClassScopeFunctionSpecialization. This node holds a FunctionDecl that is not yet specialized; then during the class template instantiation the ClassScopeFunctionSpecialization will spawn the actual function specialization. Example: template <class T> class A { public: template <class U> void f(U p) { } template <> void f(int p) { } // <== class scope specialization }; This extension is necessary to parse MSVC standard C++ headers, MFC and ATL code. BTW, with this feature in, clang can parse (-fsyntax-only) all the MSVC 2010 standard header files without any error. llvm-svn: 137573
2011-08-14 11:52:19 +08:00
case DECL_CLASS_SCOPE_FUNCTION_SPECIALIZATION:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = ClassScopeFunctionSpecializationDecl::CreateDeserialized(Context, ID);
Implement function template specialization at class scope extension in Microsoft mode. A new AST node is introduced: ClassScopeFunctionSpecialization. This node holds a FunctionDecl that is not yet specialized; then during the class template instantiation the ClassScopeFunctionSpecialization will spawn the actual function specialization. Example: template <class T> class A { public: template <class U> void f(U p) { } template <> void f(int p) { } // <== class scope specialization }; This extension is necessary to parse MSVC standard C++ headers, MFC and ATL code. BTW, with this feature in, clang can parse (-fsyntax-only) all the MSVC 2010 standard header files without any error. llvm-svn: 137573
2011-08-14 11:52:19 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_FUNCTION_TEMPLATE:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = FunctionTemplateDecl::CreateDeserialized(Context, ID);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_TEMPLATE_TYPE_PARM:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = TemplateTypeParmDecl::CreateDeserialized(Context, ID);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_NON_TYPE_TEMPLATE_PARM:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = NonTypeTemplateParmDecl::CreateDeserialized(Context, ID);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
break;
Implement support for non-type template parameter packs whose type is a pack expansion, e.g., the parameter pack Values in: template<typename ...Types> struct Outer { template<Types ...Values> struct Inner; }; This new implementation approach introduces the notion of an "expanded" non-type template parameter pack, for which we have already expanded the types of the parameter pack (to, say, "int*, float*", for Outer<int*, float*>) but have not yet expanded the values. Aside from creating these expanded non-type template parameter packs, this patch updates template argument checking and non-type template parameter pack instantiation to make use of the appropriate types in the parameter pack. llvm-svn: 123845
2011-01-20 04:10:05 +08:00
case DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = NonTypeTemplateParmDecl::CreateDeserialized(Context, ID, Record[Idx++]);
Implement support for non-type template parameter packs whose type is a pack expansion, e.g., the parameter pack Values in: template<typename ...Types> struct Outer { template<Types ...Values> struct Inner; }; This new implementation approach introduces the notion of an "expanded" non-type template parameter pack, for which we have already expanded the types of the parameter pack (to, say, "int*, float*", for Outer<int*, float*>) but have not yet expanded the values. Aside from creating these expanded non-type template parameter packs, this patch updates template argument checking and non-type template parameter pack instantiation to make use of the appropriate types in the parameter pack. llvm-svn: 123845
2011-01-20 04:10:05 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_TEMPLATE_TEMPLATE_PARM:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = TemplateTemplateParmDecl::CreateDeserialized(Context, ID);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
break;
PR9023: A template template parameter whose template parameter list contains an unexpanded parameter pack is a pack expansion. Thus, as with a non-type template parameter which is a pack expansion, it needs to be expanded early into a fixed list of template parameters. Since the expanded list of template parameters is not itself a parameter pack, it is permitted to appear before the end of the template parameter list, so also remove that restriction (for both template template parameter pack expansions and non-type template parameter pack expansions). llvm-svn: 163369
2012-09-07 10:06:42 +08:00
case DECL_EXPANDED_TEMPLATE_TEMPLATE_PARM_PACK:
D = TemplateTemplateParmDecl::CreateDeserialized(Context, ID,
Record[Idx++]);
break;
Implement support for C++0x alias templates. llvm-svn: 130953
2011-05-06 05:57:07 +08:00
case DECL_TYPE_ALIAS_TEMPLATE:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = TypeAliasTemplateDecl::CreateDeserialized(Context, ID);
Implement support for C++0x alias templates. llvm-svn: 130953
2011-05-06 05:57:07 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_STATIC_ASSERT:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = StaticAssertDecl::CreateDeserialized(Context, ID);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_OBJC_METHOD:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = ObjCMethodDecl::CreateDeserialized(Context, ID);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_OBJC_INTERFACE:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = ObjCInterfaceDecl::CreateDeserialized(Context, ID);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_OBJC_IVAR:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = ObjCIvarDecl::CreateDeserialized(Context, ID);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_OBJC_PROTOCOL:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = ObjCProtocolDecl::CreateDeserialized(Context, ID);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_OBJC_AT_DEFS_FIELD:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = ObjCAtDefsFieldDecl::CreateDeserialized(Context, ID);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_OBJC_CATEGORY:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = ObjCCategoryDecl::CreateDeserialized(Context, ID);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_OBJC_CATEGORY_IMPL:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = ObjCCategoryImplDecl::CreateDeserialized(Context, ID);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_OBJC_IMPLEMENTATION:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = ObjCImplementationDecl::CreateDeserialized(Context, ID);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_OBJC_COMPATIBLE_ALIAS:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = ObjCCompatibleAliasDecl::CreateDeserialized(Context, ID);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_OBJC_PROPERTY:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = ObjCPropertyDecl::CreateDeserialized(Context, ID);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_OBJC_PROPERTY_IMPL:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = ObjCPropertyImplDecl::CreateDeserialized(Context, ID);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_FIELD:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = FieldDecl::CreateDeserialized(Context, ID);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
break;
Major anonymous union/struct redesign. A new AST node is introduced: def IndirectField : DDecl<Value>; IndirectFields are injected into the anonymous's parent scope and chain back to the original field. Name lookup for anonymous entities now result in an IndirectFieldDecl instead of a FieldDecl. There is no functionality change, the code generated should be the same. llvm-svn: 119919
2010-11-21 14:08:52 +08:00
case DECL_INDIRECTFIELD:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = IndirectFieldDecl::CreateDeserialized(Context, ID);
Major anonymous union/struct redesign. A new AST node is introduced: def IndirectField : DDecl<Value>; IndirectFields are injected into the anonymous's parent scope and chain back to the original field. Name lookup for anonymous entities now result in an IndirectFieldDecl instead of a FieldDecl. There is no functionality change, the code generated should be the same. llvm-svn: 119919
2010-11-21 14:08:52 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_VAR:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = VarDecl::CreateDeserialized(Context, ID);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_IMPLICIT_PARAM:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = ImplicitParamDecl::CreateDeserialized(Context, ID);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_PARM_VAR:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = ParmVarDecl::CreateDeserialized(Context, ID);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_FILE_SCOPE_ASM:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = FileScopeAsmDecl::CreateDeserialized(Context, ID);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_BLOCK:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = BlockDecl::CreateDeserialized(Context, ID);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
break;
Basic support for Microsoft property declarations and references thereto. Patch by Tong Shen! llvm-svn: 179585
2013-04-16 15:28:30 +08:00
case DECL_MS_PROPERTY:
D = MSPropertyDecl::CreateDeserialized(Context, ID);
break;
Sema for Captured Statements Add CapturedDecl to be the DeclContext for CapturedStmt, and perform semantic analysis. Currently captures all variables by reference. TODO: templates Author: Ben Langmuir <ben.langmuir@intel.com> Differential Revision: http://llvm-reviews.chandlerc.com/D433 llvm-svn: 179618
2013-04-17 03:37:38 +08:00
case DECL_CAPTURED:
Serialization for captured statements Add serialization for captured statements and captured decls. Also add a const_capture_iterator to CapturedStmt. Test contributed by Wei Pan Differential Revision: http://llvm-reviews.chandlerc.com/D727 llvm-svn: 181048
2013-05-04 03:20:19 +08:00
D = CapturedDecl::CreateDeserialized(Context, ID, Record[Idx++]);
Sema for Captured Statements Add CapturedDecl to be the DeclContext for CapturedStmt, and perform semantic analysis. Currently captures all variables by reference. TODO: templates Author: Ben Langmuir <ben.langmuir@intel.com> Differential Revision: http://llvm-reviews.chandlerc.com/D433 llvm-svn: 179618
2013-04-17 03:37:38 +08:00
break;
Make the deserialization of C++ base class specifiers lazy, improving the performance of C++ PCH and reducing stack depth in the reader. llvm-svn: 117732
2010-10-30 06:39:52 +08:00
case DECL_CXX_BASE_SPECIFIERS:
Error("attempt to read a C++ base-specifier record as a declaration");
return 0;
Introduce a module import declaration, so that we properly represent, e.g., __import_module__ std.vector; in the AST. llvm-svn: 145725
2011-12-03 07:23:56 +08:00
case DECL_IMPORT:
// Note: last entry of the ImportDecl record is the number of stored source
// locations.
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = ImportDecl::CreateDeserialized(Context, ID, Record.back());
Introduce a module import declaration, so that we properly represent, e.g., __import_module__ std.vector; in the AST. llvm-svn: 145725
2011-12-03 07:23:56 +08:00
break;
OpenMP threadprivate directive parsing and semantic analysis llvm-svn: 177705
2013-03-22 14:34:35 +08:00
case DECL_OMP_THREADPRIVATE:
D = OMPThreadPrivateDecl::CreateDeserialized(Context, ID, Record[Idx++]);
break;
[Sema] Semantic analysis for empty-declaration and attribute-declaration. Introduce a new AST Decl node "EmptyDecl" to model empty-declaration. Have attributes from attribute-declaration appertain to the EmptyDecl node by creating the AST representations of these attributes and attach them to the EmptyDecl node so these attributes can be sema checked just as attributes attached to "normal" declarations. llvm-svn: 175900
2013-02-23 01:15:32 +08:00
case DECL_EMPTY:
D = EmptyDecl::CreateDeserialized(Context, ID);
break;
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
assert(D && "Unknown declaration reading AST file");
move attribute reading to PCHReaderDecl.cpp, remove some extraneous braces. llvm-svn: 70191
2009-04-27 14:01:06 +08:00
LoadedDecl(Index, D);
[PCH] Set the DeclContext before doing any deserialization, to make sure internal calls to Decl::getASTContext() by Decl's methods will find the TranslationUnitDecl without crashing due to a parent declaration context still deserializing. llvm-svn: 150153
2012-02-09 14:02:44 +08:00
// Set the DeclContext before doing any deserialization, to make sure internal
// calls to Decl::getASTContext() by Decl's methods will find the
// TranslationUnitDecl without crashing.
D->setDeclContext(Context.getTranslationUnitDecl());
move attribute reading to PCHReaderDecl.cpp, remove some extraneous braces. llvm-svn: 70191
2009-04-27 14:01:06 +08:00
Reader.Visit(D);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
// If this declaration is also a declaration context, get the
// offsets for its tables of lexical and visible declarations.
if (DeclContext *DC = dyn_cast<DeclContext>(D)) {
Fix handling of module imports adding names to a DeclContext after qualified name lookup has been performed in that context (this probably only happens in C++). 1) Whenever we add names to a context, set a flag on it, and if we perform lookup and discover that the context has had a lookup table built but has the flag set, update all entries in the lookup table with additional names from the external source. 2) When marking a DeclContext as having external visible decls, mark the context in which lookup is performed, not the one we are adding. These won't be the same if we're adding another copy of a pre-existing namespace. llvm-svn: 174577
2013-02-07 11:37:08 +08:00
// FIXME: This should really be
// DeclContext *LookupDC = DC->getPrimaryContext();
// but that can walk the redeclaration chain, which might not work yet.
DeclContext *LookupDC = DC;
if (isa<NamespaceDecl>(DC))
LookupDC = DC->getPrimaryContext();
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
std::pair<uint64_t, uint64_t> Offsets = Reader.VisitDeclContext(DC);
if (Offsets.first || Offsets.second) {
In the AST reader, switch name lookup within a DeclContect over to the module DAG-based lookup scheme. This required some reshuffling, so that each module stores its own mapping from DeclContexts to their lexical and visible sets for those DeclContexts (rather than one big "chain"). Overall, this allows simple qualified name lookup into the translation unit to gather results from multiple modules, with the lookup results in module B shadowing the lookup results in module A when B imports A. Walking all of the lexical declarations in a module DAG is still a mess; we'll end up walking the loaded module list backwards, which works fine for chained PCH but doesn't make sense in a DAG. I'll tackle this issue as a separate commit. llvm-svn: 138463
2011-08-25 03:03:07 +08:00
if (Offsets.first != 0)
DC->setHasExternalLexicalStorage(true);
if (Offsets.second != 0)
Fix handling of module imports adding names to a DeclContext after qualified name lookup has been performed in that context (this probably only happens in C++). 1) Whenever we add names to a context, set a flag on it, and if we perform lookup and discover that the context has had a lookup table built but has the flag set, update all entries in the lookup table with additional names from the external source. 2) When marking a DeclContext as having external visible decls, mark the context in which lookup is performed, not the one we are adding. These won't be the same if we're adding another copy of a pre-existing namespace. llvm-svn: 174577
2013-02-07 11:37:08 +08:00
LookupDC->setHasExternalVisibleStorage(true);
In the AST reader, switch name lookup within a DeclContect over to the module DAG-based lookup scheme. This required some reshuffling, so that each module stores its own mapping from DeclContexts to their lexical and visible sets for those DeclContexts (rather than one big "chain"). Overall, this allows simple qualified name lookup into the translation unit to gather results from multiple modules, with the lookup results in module B shadowing the lookup results in module A when B imports A. Walking all of the lexical declarations in a module DAG is still a mess; we'll end up walking the loaded module list backwards, which works fine for chained PCH but doesn't make sense in a DAG. I'll tackle this issue as a separate commit. llvm-svn: 138463
2011-08-25 03:03:07 +08:00
if (ReadDeclContextStorage(*Loc.F, DeclsCursor, Offsets,
Loc.F->DeclContextInfos[DC]))
- Fix recording of offsets of types in dependent PCHs. - Stop reading in (and thus deserializing) every declaration in the TU when creating a dependent PCH. - Switch the storage of a decl context's lexical declarations to a blob containing the IDs instead of a record. This is the only sane way of supporting update records later on. llvm-svn: 109474
2010-07-27 08:17:23 +08:00
return 0;
On reading DeclContexts from PCH, check for visible updates even if the context was empty in the original version. Also, if there are any, tell the context that it has external visible decls. This fixes the problem that a namespace that was empty in the initial PCH (could also happen if the initial PCH didn't include any std header but caused implicit creation of namespace std, e.g. due to implicit declaration of a virtual destructor) never found any declaration declared in *any* chained PCH. Very ugly when the chained PCH includes all that std stuff, as the errors were effectively the same as not including std headers. llvm-svn: 130102
2011-04-25 00:27:54 +08:00
}
Read the UPDATE_VISIBLE record, and add its visible decls to the lookup tables. Also, free the lookup tables when destructing the ASTReader. llvm-svn: 111880
2010-08-24 08:50:04 +08:00
On reading DeclContexts from PCH, check for visible updates even if the context was empty in the original version. Also, if there are any, tell the context that it has external visible decls. This fixes the problem that a namespace that was empty in the initial PCH (could also happen if the initial PCH didn't include any std header but caused implicit creation of namespace std, e.g. due to implicit declaration of a virtual destructor) never found any declaration declared in *any* chained PCH. Very ugly when the chained PCH includes all that std stuff, as the errors were effectively the same as not including std headers. llvm-svn: 130102
2011-04-25 00:27:54 +08:00
// Now add the pending visible updates for this decl context, if it has any.
DeclContextVisibleUpdatesPending::iterator I =
PendingVisibleUpdates.find(ID);
if (I != PendingVisibleUpdates.end()) {
// There are updates. This means the context has external visible
// storage, even if the original stored version didn't.
Fix handling of module imports adding names to a DeclContext after qualified name lookup has been performed in that context (this probably only happens in C++). 1) Whenever we add names to a context, set a flag on it, and if we perform lookup and discover that the context has had a lookup table built but has the flag set, update all entries in the lookup table with additional names from the external source. 2) When marking a DeclContext as having external visible decls, mark the context in which lookup is performed, not the one we are adding. These won't be the same if we're adding another copy of a pre-existing namespace. llvm-svn: 174577
2013-02-07 11:37:08 +08:00
LookupDC->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
for (const auto &Update : I->second) {
DeclContextInfo &Info = Update.second->DeclContextInfos[DC];
delete Info.NameLookupTableData;
Info.NameLookupTableData = Update.first;
}
On reading DeclContexts from PCH, check for visible updates even if the context was empty in the original version. Also, if there are any, tell the context that it has external visible decls. This fixes the problem that a namespace that was empty in the initial PCH (could also happen if the initial PCH didn't include any std header but caused implicit creation of namespace std, e.g. due to implicit declaration of a virtual destructor) never found any declaration declared in *any* chained PCH. Very ugly when the chained PCH includes all that std stuff, as the errors were effectively the same as not including std headers. llvm-svn: 130102
2011-04-25 00:27:54 +08:00
PendingVisibleUpdates.erase(I);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
}
assert(Idx == Record.size());
In the serialized AST format, make the translation unit a "predefined" declaration that never actually gets serialized. Instead, serialize the various kinds of update records (lexical decls, visible decls, the addition of an anonymous namespace) for the translation unit, even if we're not chaining. This way, we won't have to deal with multiple loaded translation unit declarations. llvm-svn: 137395
2011-08-12 08:15:20 +08:00
// Load any relevant update records.
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
PendingUpdateRecords.push_back(std::make_pair(ID, D));
[PCH] Load the chained objc categories only after recursive loading is finished otherwise we may crash. llvm-svn: 144524
2011-11-14 15:07:59 +08:00
Reimplement (de-)serialization of Objective-C categories to eliminate the direct serialization of the linked-list structure. Instead, use a scheme similar to how we handle redeclarations, with redeclaration lists on the side. This addresses several issues: - In cases involving mixing and matching of many categories across many modules, the linked-list structure would not be consistent across different modules, and categories would get lost. - If a module is loaded after the class definition and its other categories have already been loaded, we wouldn't see any categories in the newly-loaded module. llvm-svn: 149112
2012-01-27 09:47:08 +08:00
// Load the categories after recursive loading is finished.
if (ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(D))
if (Class->isThisDeclarationADefinition())
loadObjCCategories(ID, Class);
Support importing of ObjC categories from modules. The initial incentive was to fix a crash when PCH chaining categories to an interface, but the fix was done in the "modules way" that I hear is popular with the kids these days. Each module stores the local chain of categories and we combine them when the interface is loaded. We also warn if non-dependent modules introduce duplicate named categories. llvm-svn: 138926
2011-09-01 08:58:55 +08:00
In the serialized AST format, make the translation unit a "predefined" declaration that never actually gets serialized. Instead, serialize the various kinds of update records (lexical decls, visible decls, the addition of an anonymous namespace) for the translation unit, even if we're not chaining. This way, we won't have to deal with multiple loaded translation unit declarations. llvm-svn: 137395
2011-08-12 08:15:20 +08:00
// If we have deserialized a declaration that has a definition the
// AST consumer might need to know about, queue it.
// We don't pass it to the consumer immediately because we may be in recursive
// loading, and some declarations may still be initializing.
When we load a function or method body from an AST file, we check whether that function/method already has a body (loaded from some other AST file), as introduced in r165137. Delay this check until after the redeclaration chains have been wired up. While I'm here, make the loading of method bodies lazy. llvm-svn: 165513
2012-10-10 01:21:28 +08:00
if (isConsumerInterestedIn(D, Reader.hasPendingBody()))
Reimplement (de-)serialization of Objective-C categories to eliminate the direct serialization of the linked-list structure. Instead, use a scheme similar to how we handle redeclarations, with redeclaration lists on the side. This addresses several issues: - In cases involving mixing and matching of many categories across many modules, the linked-list structure would not be consistent across different modules, and categories would get lost. - If a module is loaded after the class definition and its other categories have already been loaded, we wouldn't see any categories in the newly-loaded module. llvm-svn: 149112
2012-01-27 09:47:08 +08:00
InterestingDecls.push_back(D);
Merge pending instantiations instead of overwriting existing ones. Check whether a pending instantiation needs to be instantiated (or whether an instantiation already exists). Verify the size of the PendingInstantiations record (was only checking size of existing PendingInstantiations). Migrate Obj-C++ part of redecl-merge into separate test, now that this is growing. templates.mm: test that CodeGen has seen exactly one definition of template instantiations. redecl-merge.m: use "@" specifier for expected-diagnostics. llvm-svn: 164993
2012-10-02 17:09:43 +08:00
In the serialized AST format, make the translation unit a "predefined" declaration that never actually gets serialized. Instead, serialize the various kinds of update records (lexical decls, visible decls, the addition of an anonymous namespace) for the translation unit, even if we're not chaining. This way, we won't have to deal with multiple loaded translation unit declarations. llvm-svn: 137395
2011-08-12 08:15:20 +08:00
return D;
}
void ASTReader::loadDeclUpdateRecords(serialization::DeclID ID, Decl *D) {
Put the mechanism in place to track modifications in an AST entity that were committed after its initial creation/deserialization and store the changes in a chained PCH. The idea is that the AST entities call methods on the ASTMutationListener to give notifications of changes; the PCHWriter implements the ASTMutationListener interface and stores the incremental changes of the updated entity. WIP llvm-svn: 117235
2010-10-25 01:26:36 +08:00
// The declaration may have been modified by files later in the chain.
// If this is the case, read the record containing the updates from each file
// and pass it to ASTDeclReader to make the modifications.
DeclUpdateOffsetsMap::iterator UpdI = DeclUpdateOffsets.find(ID);
if (UpdI != DeclUpdateOffsets.end()) {
FileOffsetsTy &UpdateOffsets = UpdI->second;
If an update record makes a declaration interesting, pass it to the consumer. llvm-svn: 204550
2014-03-23 08:27:18 +08:00
bool WasInteresting = isConsumerInterestedIn(D, false);
Put the mechanism in place to track modifications in an AST entity that were committed after its initial creation/deserialization and store the changes in a chained PCH. The idea is that the AST entities call methods on the ASTMutationListener to give notifications of changes; the PCHWriter implements the ASTMutationListener interface and stores the incremental changes of the updated entity. WIP llvm-svn: 117235
2010-10-25 01:26:36 +08:00
for (FileOffsetsTy::iterator
In the serialized AST format, make the translation unit a "predefined" declaration that never actually gets serialized. Instead, serialize the various kinds of update records (lexical decls, visible decls, the addition of an anonymous namespace) for the translation unit, even if we're not chaining. This way, we won't have to deal with multiple loaded translation unit declarations. llvm-svn: 137395
2011-08-12 08:15:20 +08:00
I = UpdateOffsets.begin(), E = UpdateOffsets.end(); I != E; ++I) {
Promote ModuleMap::Module to a namespace-scope class in the Basic library, since modules cut across all of the libraries. Rename serialization::Module to serialization::ModuleFile to side-step the annoying naming conflict. Prune a bunch of ModuleMap.h includes that are no longer needed (most files only needed the Module type). llvm-svn: 145538
2011-12-01 07:21:26 +08:00
ModuleFile *F = I->first;
Put the mechanism in place to track modifications in an AST entity that were committed after its initial creation/deserialization and store the changes in a chained PCH. The idea is that the AST entities call methods on the ASTMutationListener to give notifications of changes; the PCHWriter implements the ASTMutationListener interface and stores the incremental changes of the updated entity. WIP llvm-svn: 117235
2010-10-25 01:26:36 +08:00
uint64_t Offset = I->second;
llvm::BitstreamCursor &Cursor = F->DeclsCursor;
SavedStreamPosition SavedPosition(Cursor);
Cursor.JumpToBit(Offset);
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);
Put the mechanism in place to track modifications in an AST entity that were committed after its initial creation/deserialization and store the changes in a chained PCH. The idea is that the AST entities call methods on the ASTMutationListener to give notifications of changes; the PCHWriter implements the ASTMutationListener interface and stores the incremental changes of the updated entity. WIP llvm-svn: 117235
2010-10-25 01:26:36 +08:00
(void)RecCode;
assert(RecCode == DECL_UPDATES && "Expected DECL_UPDATES record!");
If an update record makes a declaration interesting, pass it to the consumer. llvm-svn: 204550
2014-03-23 08:27:18 +08:00
In the serialized AST format, make the translation unit a "predefined" declaration that never actually gets serialized. Instead, serialize the various kinds of update records (lexical decls, visible decls, the addition of an anonymous namespace) for the translation unit, even if we're not chaining. This way, we won't have to deal with multiple loaded translation unit declarations. llvm-svn: 137395
2011-08-12 08:15:20 +08:00
unsigned Idx = 0;
Remove an unused private field exposed by the recent LLVM_DELETED_FUNCTION changes. llvm-svn: 164106
2012-09-18 13:34:55 +08:00
ASTDeclReader Reader(*this, *F, ID, 0, Record, Idx);
Add a decl update when a static data member of a class template is instantiated in a different PCH than its containing class. Otherwise we get double definition errors. Fixes a Boost.MPL problem that affects Boost.Accumulators and probably a lot more of Boost. llvm-svn: 130488
2011-04-29 16:19:30 +08:00
Reader.UpdateDecl(D, *F, Record);
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 might have made this declaration interesting. If so, remember that
// we need to hand it off to the consumer.
if (!WasInteresting &&
isConsumerInterestedIn(D, Reader.hasPendingBody())) {
InterestingDecls.push_back(D);
WasInteresting = true;
}
Put the mechanism in place to track modifications in an AST entity that were committed after its initial creation/deserialization and store the changes in a chained PCH. The idea is that the AST entities call methods on the ASTMutationListener to give notifications of changes; the PCHWriter implements the ASTMutationListener interface and stores the incremental changes of the updated entity. WIP llvm-svn: 117235
2010-10-25 01:26:36 +08:00
}
}
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Put the mechanism in place to track modifications in an AST entity that were committed after its initial creation/deserialization and store the changes in a chained PCH. The idea is that the AST entities call methods on the ASTMutationListener to give notifications of changes; the PCHWriter implements the ASTMutationListener interface and stores the incremental changes of the updated entity. WIP llvm-svn: 117235
2010-10-25 01:26:36 +08:00
Completely re-implement (de-)serialization of declaration chains. The previous implementation relied heavily on the declaration chain being stored as a (circular) linked list on disk, as it is in memory. However, when deserializing from multiple modules, the different chains could get mixed up, leading to broken declaration chains. The new solution keeps track of the first and last declarations in the chain for each module file. When we load a declaration, we search all of the module files for redeclarations of that declaration, then splice together all of the lists into a coherent whole (along with any redeclarations that were actually parsed). As a drive-by fix, (de-)serialize the redeclaration chains of TypedefNameDecls, which had somehow gotten missed previously. Add a test of this serialization. This new scheme creates a redeclaration table that is fairly large in the PCH file (on the order of 400k for Cocoa.h's 12MB PCH file). The table is mmap'd in and searched via a binary search, but it's still quite large. A future tweak will eliminate entries for declarations that have no redeclarations anywhere, and should drastically reduce the size of this table. llvm-svn: 146841
2011-12-18 07:38:30 +08:00
namespace {
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
/// \brief Module visitor class that finds all of the redeclarations of a
///
Completely re-implement (de-)serialization of declaration chains. The previous implementation relied heavily on the declaration chain being stored as a (circular) linked list on disk, as it is in memory. However, when deserializing from multiple modules, the different chains could get mixed up, leading to broken declaration chains. The new solution keeps track of the first and last declarations in the chain for each module file. When we load a declaration, we search all of the module files for redeclarations of that declaration, then splice together all of the lists into a coherent whole (along with any redeclarations that were actually parsed). As a drive-by fix, (de-)serialize the redeclaration chains of TypedefNameDecls, which had somehow gotten missed previously. Add a test of this serialization. This new scheme creates a redeclaration table that is fairly large in the PCH file (on the order of 400k for Cocoa.h's 12MB PCH file). The table is mmap'd in and searched via a binary search, but it's still quite large. A future tweak will eliminate entries for declarations that have no redeclarations anywhere, and should drastically reduce the size of this table. llvm-svn: 146841
2011-12-18 07:38:30 +08:00
class RedeclChainVisitor {
ASTReader &Reader;
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
SmallVectorImpl<DeclID> &SearchDecls;
Completely re-implement (de-)serialization of redeclaration chains, again. The prior implementation was very linked-list oriented, and the list-splicing logic was both fairly convoluted (when loading from multiple modules) and failed to preserve a reasonable ordering for the redeclaration chains. This new implementation uses a simpler strategy, where we store the ordered redeclaration chains in an array-like structure (indexed based on the first declaration), and use that ordering to add individual deserialized declarations to the end of the existing chain. That way, the chain mimics the ordering from its modules, and a bug somewhere is far less likely to result in a broken linked list. llvm-svn: 148222
2012-01-16 00:58:34 +08:00
llvm::SmallPtrSet<Decl *, 16> &Deserialized;
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
GlobalDeclID CanonID;
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<Decl *, 4> Chain;
Completely re-implement (de-)serialization of declaration chains. The previous implementation relied heavily on the declaration chain being stored as a (circular) linked list on disk, as it is in memory. However, when deserializing from multiple modules, the different chains could get mixed up, leading to broken declaration chains. The new solution keeps track of the first and last declarations in the chain for each module file. When we load a declaration, we search all of the module files for redeclarations of that declaration, then splice together all of the lists into a coherent whole (along with any redeclarations that were actually parsed). As a drive-by fix, (de-)serialize the redeclaration chains of TypedefNameDecls, which had somehow gotten missed previously. Add a test of this serialization. This new scheme creates a redeclaration table that is fairly large in the PCH file (on the order of 400k for Cocoa.h's 12MB PCH file). The table is mmap'd in and searched via a binary search, but it's still quite large. A future tweak will eliminate entries for declarations that have no redeclarations anywhere, and should drastically reduce the size of this table. llvm-svn: 146841
2011-12-18 07:38:30 +08:00
public:
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
RedeclChainVisitor(ASTReader &Reader, SmallVectorImpl<DeclID> &SearchDecls,
Completely re-implement (de-)serialization of redeclaration chains, again. The prior implementation was very linked-list oriented, and the list-splicing logic was both fairly convoluted (when loading from multiple modules) and failed to preserve a reasonable ordering for the redeclaration chains. This new implementation uses a simpler strategy, where we store the ordered redeclaration chains in an array-like structure (indexed based on the first declaration), and use that ordering to add individual deserialized declarations to the end of the existing chain. That way, the chain mimics the ordering from its modules, and a bug somewhere is far less likely to result in a broken linked list. llvm-svn: 148222
2012-01-16 00:58:34 +08:00
llvm::SmallPtrSet<Decl *, 16> &Deserialized,
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
GlobalDeclID CanonID)
Completely re-implement (de-)serialization of redeclaration chains, again. The prior implementation was very linked-list oriented, and the list-splicing logic was both fairly convoluted (when loading from multiple modules) and failed to preserve a reasonable ordering for the redeclaration chains. This new implementation uses a simpler strategy, where we store the ordered redeclaration chains in an array-like structure (indexed based on the first declaration), and use that ordering to add individual deserialized declarations to the end of the existing chain. That way, the chain mimics the ordering from its modules, and a bug somewhere is far less likely to result in a broken linked list. llvm-svn: 148222
2012-01-16 00:58:34 +08:00
: Reader(Reader), SearchDecls(SearchDecls), Deserialized(Deserialized),
When collecting all of the redeclarations of a declaration loaded from a module file, be sure to also add the first (potentially canonical) declarations to the chain. This isn't guaranteed to occur because the first declaration is not listed in the stored redeclaration chain. llvm-svn: 148314
2012-01-18 02:13:45 +08:00
CanonID(CanonID) {
for (unsigned I = 0, N = SearchDecls.size(); I != N; ++I)
addToChain(Reader.GetDecl(SearchDecls[I]));
}
Completely re-implement (de-)serialization of declaration chains. The previous implementation relied heavily on the declaration chain being stored as a (circular) linked list on disk, as it is in memory. However, when deserializing from multiple modules, the different chains could get mixed up, leading to broken declaration chains. The new solution keeps track of the first and last declarations in the chain for each module file. When we load a declaration, we search all of the module files for redeclarations of that declaration, then splice together all of the lists into a coherent whole (along with any redeclarations that were actually parsed). As a drive-by fix, (de-)serialize the redeclaration chains of TypedefNameDecls, which had somehow gotten missed previously. Add a test of this serialization. This new scheme creates a redeclaration table that is fairly large in the PCH file (on the order of 400k for Cocoa.h's 12MB PCH file). The table is mmap'd in and searched via a binary search, but it's still quite large. A future tweak will eliminate entries for declarations that have no redeclarations anywhere, and should drastically reduce the size of this table. llvm-svn: 146841
2011-12-18 07:38:30 +08:00
static bool visit(ModuleFile &M, bool Preorder, void *UserData) {
if (Preorder)
return false;
return static_cast<RedeclChainVisitor *>(UserData)->visit(M);
}
Completely re-implement (de-)serialization of redeclaration chains, again. The prior implementation was very linked-list oriented, and the list-splicing logic was both fairly convoluted (when loading from multiple modules) and failed to preserve a reasonable ordering for the redeclaration chains. This new implementation uses a simpler strategy, where we store the ordered redeclaration chains in an array-like structure (indexed based on the first declaration), and use that ordering to add individual deserialized declarations to the end of the existing chain. That way, the chain mimics the ordering from its modules, and a bug somewhere is far less likely to result in a broken linked list. llvm-svn: 148222
2012-01-16 00:58:34 +08:00
void addToChain(Decl *D) {
if (!D)
return;
Reduce duplicated hash map lookups. llvm-svn: 162361
2012-08-22 23:37:55 +08:00
if (Deserialized.erase(D))
Completely re-implement (de-)serialization of redeclaration chains, again. The prior implementation was very linked-list oriented, and the list-splicing logic was both fairly convoluted (when loading from multiple modules) and failed to preserve a reasonable ordering for the redeclaration chains. This new implementation uses a simpler strategy, where we store the ordered redeclaration chains in an array-like structure (indexed based on the first declaration), and use that ordering to add individual deserialized declarations to the end of the existing chain. That way, the chain mimics the ordering from its modules, and a bug somewhere is far less likely to result in a broken linked list. llvm-svn: 148222
2012-01-16 00:58:34 +08:00
Chain.push_back(D);
}
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
void searchForID(ModuleFile &M, GlobalDeclID GlobalID) {
Completely re-implement (de-)serialization of declaration chains. The previous implementation relied heavily on the declaration chain being stored as a (circular) linked list on disk, as it is in memory. However, when deserializing from multiple modules, the different chains could get mixed up, leading to broken declaration chains. The new solution keeps track of the first and last declarations in the chain for each module file. When we load a declaration, we search all of the module files for redeclarations of that declaration, then splice together all of the lists into a coherent whole (along with any redeclarations that were actually parsed). As a drive-by fix, (de-)serialize the redeclaration chains of TypedefNameDecls, which had somehow gotten missed previously. Add a test of this serialization. This new scheme creates a redeclaration table that is fairly large in the PCH file (on the order of 400k for Cocoa.h's 12MB PCH file). The table is mmap'd in and searched via a binary search, but it's still quite large. A future tweak will eliminate entries for declarations that have no redeclarations anywhere, and should drastically reduce the size of this table. llvm-svn: 146841
2011-12-18 07:38:30 +08:00
// Map global ID of the first declaration down to the local ID
// used in this module file.
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
DeclID ID = Reader.mapGlobalIDToModuleFileGlobalID(M, GlobalID);
if (!ID)
return;
Completely re-implement (de-)serialization of declaration chains. The previous implementation relied heavily on the declaration chain being stored as a (circular) linked list on disk, as it is in memory. However, when deserializing from multiple modules, the different chains could get mixed up, leading to broken declaration chains. The new solution keeps track of the first and last declarations in the chain for each module file. When we load a declaration, we search all of the module files for redeclarations of that declaration, then splice together all of the lists into a coherent whole (along with any redeclarations that were actually parsed). As a drive-by fix, (de-)serialize the redeclaration chains of TypedefNameDecls, which had somehow gotten missed previously. Add a test of this serialization. This new scheme creates a redeclaration table that is fairly large in the PCH file (on the order of 400k for Cocoa.h's 12MB PCH file). The table is mmap'd in and searched via a binary search, but it's still quite large. A future tweak will eliminate entries for declarations that have no redeclarations anywhere, and should drastically reduce the size of this table. llvm-svn: 146841
2011-12-18 07:38:30 +08:00
// Perform a binary search to find the local redeclarations for this
// declaration (if any).
Serialization: Directly compare objects instead of using a functor duplicating the compare operators. No functionality change. llvm-svn: 204006
2014-03-15 22:21:58 +08:00
const LocalRedeclarationsInfo Compare = { ID, 0 };
Completely re-implement (de-)serialization of declaration chains. The previous implementation relied heavily on the declaration chain being stored as a (circular) linked list on disk, as it is in memory. However, when deserializing from multiple modules, the different chains could get mixed up, leading to broken declaration chains. The new solution keeps track of the first and last declarations in the chain for each module file. When we load a declaration, we search all of the module files for redeclarations of that declaration, then splice together all of the lists into a coherent whole (along with any redeclarations that were actually parsed). As a drive-by fix, (de-)serialize the redeclaration chains of TypedefNameDecls, which had somehow gotten missed previously. Add a test of this serialization. This new scheme creates a redeclaration table that is fairly large in the PCH file (on the order of 400k for Cocoa.h's 12MB PCH file). The table is mmap'd in and searched via a binary search, but it's still quite large. A future tweak will eliminate entries for declarations that have no redeclarations anywhere, and should drastically reduce the size of this table. llvm-svn: 146841
2011-12-18 07:38:30 +08:00
const LocalRedeclarationsInfo *Result
Completely re-implement (de-)serialization of redeclaration chains, again. The prior implementation was very linked-list oriented, and the list-splicing logic was both fairly convoluted (when loading from multiple modules) and failed to preserve a reasonable ordering for the redeclaration chains. This new implementation uses a simpler strategy, where we store the ordered redeclaration chains in an array-like structure (indexed based on the first declaration), and use that ordering to add individual deserialized declarations to the end of the existing chain. That way, the chain mimics the ordering from its modules, and a bug somewhere is far less likely to result in a broken linked list. llvm-svn: 148222
2012-01-16 00:58:34 +08:00
= std::lower_bound(M.RedeclarationsMap,
M.RedeclarationsMap + M.LocalNumRedeclarationsInMap,
Serialization: Directly compare objects instead of using a functor duplicating the compare operators. No functionality change. llvm-svn: 204006
2014-03-15 22:21:58 +08:00
Compare);
Completely re-implement (de-)serialization of redeclaration chains, again. The prior implementation was very linked-list oriented, and the list-splicing logic was both fairly convoluted (when loading from multiple modules) and failed to preserve a reasonable ordering for the redeclaration chains. This new implementation uses a simpler strategy, where we store the ordered redeclaration chains in an array-like structure (indexed based on the first declaration), and use that ordering to add individual deserialized declarations to the end of the existing chain. That way, the chain mimics the ordering from its modules, and a bug somewhere is far less likely to result in a broken linked list. llvm-svn: 148222
2012-01-16 00:58:34 +08:00
if (Result == M.RedeclarationsMap + M.LocalNumRedeclarationsInMap ||
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
Result->FirstID != ID) {
// If we have a previously-canonical singleton declaration that was
// merged into another redeclaration chain, create a trivial chain
// for this single declaration so that it will get wired into the
// complete redeclaration chain.
if (GlobalID != CanonID &&
GlobalID - NUM_PREDEF_DECL_IDS >= M.BaseDeclID &&
GlobalID - NUM_PREDEF_DECL_IDS < M.BaseDeclID + M.LocalNumDecls) {
Completely re-implement (de-)serialization of redeclaration chains, again. The prior implementation was very linked-list oriented, and the list-splicing logic was both fairly convoluted (when loading from multiple modules) and failed to preserve a reasonable ordering for the redeclaration chains. This new implementation uses a simpler strategy, where we store the ordered redeclaration chains in an array-like structure (indexed based on the first declaration), and use that ordering to add individual deserialized declarations to the end of the existing chain. That way, the chain mimics the ordering from its modules, and a bug somewhere is far less likely to result in a broken linked list. llvm-svn: 148222
2012-01-16 00:58:34 +08:00
addToChain(Reader.GetDecl(GlobalID));
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
}
return;
}
Reimplement (de-)serialization of Objective-C categories to eliminate the direct serialization of the linked-list structure. Instead, use a scheme similar to how we handle redeclarations, with redeclaration lists on the side. This addresses several issues: - In cases involving mixing and matching of many categories across many modules, the linked-list structure would not be consistent across different modules, and categories would get lost. - If a module is loaded after the class definition and its other categories have already been loaded, we wouldn't see any categories in the newly-loaded module. llvm-svn: 149112
2012-01-27 09:47:08 +08:00
// Dig out all of the redeclarations.
Completely re-implement (de-)serialization of redeclaration chains, again. The prior implementation was very linked-list oriented, and the list-splicing logic was both fairly convoluted (when loading from multiple modules) and failed to preserve a reasonable ordering for the redeclaration chains. This new implementation uses a simpler strategy, where we store the ordered redeclaration chains in an array-like structure (indexed based on the first declaration), and use that ordering to add individual deserialized declarations to the end of the existing chain. That way, the chain mimics the ordering from its modules, and a bug somewhere is far less likely to result in a broken linked list. llvm-svn: 148222
2012-01-16 00:58:34 +08:00
unsigned Offset = Result->Offset;
unsigned N = M.RedeclarationChains[Offset];
M.RedeclarationChains[Offset++] = 0; // Don't try to deserialize again
for (unsigned I = 0; I != N; ++I)
addToChain(Reader.GetLocalDecl(M, M.RedeclarationChains[Offset++]));
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
}
bool visit(ModuleFile &M) {
// Visit each of the declarations.
for (unsigned I = 0, N = SearchDecls.size(); I != N; ++I)
searchForID(M, SearchDecls[I]);
Completely re-implement (de-)serialization of declaration chains. The previous implementation relied heavily on the declaration chain being stored as a (circular) linked list on disk, as it is in memory. However, when deserializing from multiple modules, the different chains could get mixed up, leading to broken declaration chains. The new solution keeps track of the first and last declarations in the chain for each module file. When we load a declaration, we search all of the module files for redeclarations of that declaration, then splice together all of the lists into a coherent whole (along with any redeclarations that were actually parsed). As a drive-by fix, (de-)serialize the redeclaration chains of TypedefNameDecls, which had somehow gotten missed previously. Add a test of this serialization. This new scheme creates a redeclaration table that is fairly large in the PCH file (on the order of 400k for Cocoa.h's 12MB PCH file). The table is mmap'd in and searched via a binary search, but it's still quite large. A future tweak will eliminate entries for declarations that have no redeclarations anywhere, and should drastically reduce the size of this table. llvm-svn: 146841
2011-12-18 07:38:30 +08:00
return false;
}
Completely re-implement (de-)serialization of redeclaration chains, again. The prior implementation was very linked-list oriented, and the list-splicing logic was both fairly convoluted (when loading from multiple modules) and failed to preserve a reasonable ordering for the redeclaration chains. This new implementation uses a simpler strategy, where we store the ordered redeclaration chains in an array-like structure (indexed based on the first declaration), and use that ordering to add individual deserialized declarations to the end of the existing chain. That way, the chain mimics the ordering from its modules, and a bug somewhere is far less likely to result in a broken linked list. llvm-svn: 148222
2012-01-16 00:58:34 +08:00
ArrayRef<Decl *> getChain() const {
return Chain;
Completely re-implement (de-)serialization of declaration chains. The previous implementation relied heavily on the declaration chain being stored as a (circular) linked list on disk, as it is in memory. However, when deserializing from multiple modules, the different chains could get mixed up, leading to broken declaration chains. The new solution keeps track of the first and last declarations in the chain for each module file. When we load a declaration, we search all of the module files for redeclarations of that declaration, then splice together all of the lists into a coherent whole (along with any redeclarations that were actually parsed). As a drive-by fix, (de-)serialize the redeclaration chains of TypedefNameDecls, which had somehow gotten missed previously. Add a test of this serialization. This new scheme creates a redeclaration table that is fairly large in the PCH file (on the order of 400k for Cocoa.h's 12MB PCH file). The table is mmap'd in and searched via a binary search, but it's still quite large. A future tweak will eliminate entries for declarations that have no redeclarations anywhere, and should drastically reduce the size of this table. llvm-svn: 146841
2011-12-18 07:38:30 +08:00
}
};
}
void ASTReader::loadPendingDeclChain(serialization::GlobalDeclID ID) {
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
Decl *D = GetDecl(ID);
Decl *CanonDecl = D->getCanonicalDecl();
Serialize the AST reader's mapping from canonical declarations to the set of (previously-canonical) declaration IDs to the module file, so that future AST reader instances that load the module know which declarations are merged. This is important in the fairly tricky case where a declaration of an entity, e.g., @class X; occurs before the import of a module that also declares that entity. We merge the declarations, and record the fact that the declaration of X loaded from the module was merged into the (now canonical) declaration of X that we parsed. llvm-svn: 147181
2011-12-23 05:40:42 +08:00
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
// Determine the set of declaration IDs we'll be searching for.
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<DeclID, 1> SearchDecls;
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
GlobalDeclID CanonID = 0;
if (D == CanonDecl) {
SearchDecls.push_back(ID); // Always first.
CanonID = ID;
}
Serialize the AST reader's mapping from canonical declarations to the set of (previously-canonical) declaration IDs to the module file, so that future AST reader instances that load the module know which declarations are merged. This is important in the fairly tricky case where a declaration of an entity, e.g., @class X; occurs before the import of a module that also declares that entity. We merge the declarations, and record the fact that the declaration of X loaded from the module was merged into the (now canonical) declaration of X that we parsed. llvm-svn: 147181
2011-12-23 05:40:42 +08:00
MergedDeclsMap::iterator MergedPos = combineStoredMergedDecls(CanonDecl, ID);
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
if (MergedPos != MergedDecls.end())
Also merge template redeclarations. Don't require specializations (of existing and read template) to be unique. llvm-svn: 164931
2012-10-01 17:18:00 +08:00
SearchDecls.append(MergedPos->second.begin(), MergedPos->second.end());
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
Completely re-implement (de-)serialization of redeclaration chains, again. The prior implementation was very linked-list oriented, and the list-splicing logic was both fairly convoluted (when loading from multiple modules) and failed to preserve a reasonable ordering for the redeclaration chains. This new implementation uses a simpler strategy, where we store the ordered redeclaration chains in an array-like structure (indexed based on the first declaration), and use that ordering to add individual deserialized declarations to the end of the existing chain. That way, the chain mimics the ordering from its modules, and a bug somewhere is far less likely to result in a broken linked list. llvm-svn: 148222
2012-01-16 00:58:34 +08:00
// Build up the list of redeclarations.
RedeclChainVisitor Visitor(*this, SearchDecls, RedeclsDeserialized, CanonID);
Completely re-implement (de-)serialization of declaration chains. The previous implementation relied heavily on the declaration chain being stored as a (circular) linked list on disk, as it is in memory. However, when deserializing from multiple modules, the different chains could get mixed up, leading to broken declaration chains. The new solution keeps track of the first and last declarations in the chain for each module file. When we load a declaration, we search all of the module files for redeclarations of that declaration, then splice together all of the lists into a coherent whole (along with any redeclarations that were actually parsed). As a drive-by fix, (de-)serialize the redeclaration chains of TypedefNameDecls, which had somehow gotten missed previously. Add a test of this serialization. This new scheme creates a redeclaration table that is fairly large in the PCH file (on the order of 400k for Cocoa.h's 12MB PCH file). The table is mmap'd in and searched via a binary search, but it's still quite large. A future tweak will eliminate entries for declarations that have no redeclarations anywhere, and should drastically reduce the size of this table. llvm-svn: 146841
2011-12-18 07:38:30 +08:00
ModuleMgr.visitDepthFirst(&RedeclChainVisitor::visit, &Visitor);
// Retrieve the chains.
Completely re-implement (de-)serialization of redeclaration chains, again. The prior implementation was very linked-list oriented, and the list-splicing logic was both fairly convoluted (when loading from multiple modules) and failed to preserve a reasonable ordering for the redeclaration chains. This new implementation uses a simpler strategy, where we store the ordered redeclaration chains in an array-like structure (indexed based on the first declaration), and use that ordering to add individual deserialized declarations to the end of the existing chain. That way, the chain mimics the ordering from its modules, and a bug somewhere is far less likely to result in a broken linked list. llvm-svn: 148222
2012-01-16 00:58:34 +08:00
ArrayRef<Decl *> Chain = Visitor.getChain();
if (Chain.empty())
Completely re-implement (de-)serialization of declaration chains. The previous implementation relied heavily on the declaration chain being stored as a (circular) linked list on disk, as it is in memory. However, when deserializing from multiple modules, the different chains could get mixed up, leading to broken declaration chains. The new solution keeps track of the first and last declarations in the chain for each module file. When we load a declaration, we search all of the module files for redeclarations of that declaration, then splice together all of the lists into a coherent whole (along with any redeclarations that were actually parsed). As a drive-by fix, (de-)serialize the redeclaration chains of TypedefNameDecls, which had somehow gotten missed previously. Add a test of this serialization. This new scheme creates a redeclaration table that is fairly large in the PCH file (on the order of 400k for Cocoa.h's 12MB PCH file). The table is mmap'd in and searched via a binary search, but it's still quite large. A future tweak will eliminate entries for declarations that have no redeclarations anywhere, and should drastically reduce the size of this table. llvm-svn: 146841
2011-12-18 07:38:30 +08:00
return;
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
Completely re-implement (de-)serialization of redeclaration chains, again. The prior implementation was very linked-list oriented, and the list-splicing logic was both fairly convoluted (when loading from multiple modules) and failed to preserve a reasonable ordering for the redeclaration chains. This new implementation uses a simpler strategy, where we store the ordered redeclaration chains in an array-like structure (indexed based on the first declaration), and use that ordering to add individual deserialized declarations to the end of the existing chain. That way, the chain mimics the ordering from its modules, and a bug somewhere is far less likely to result in a broken linked list. llvm-svn: 148222
2012-01-16 00:58:34 +08:00
// Hook up the chains.
Introduce Decl::getPreviousDecl() and Decl::getMostRecentDecl(), virtual functions that provide previous/most recent redeclaration information for any declaration. Use this to eliminate the redundant, less efficient getPreviousDecl() functions. llvm-svn: 148184
2012-01-14 23:55:47 +08:00
Decl *MostRecent = CanonDecl->getMostRecentDecl();
Completely re-implement (de-)serialization of redeclaration chains, again. The prior implementation was very linked-list oriented, and the list-splicing logic was both fairly convoluted (when loading from multiple modules) and failed to preserve a reasonable ordering for the redeclaration chains. This new implementation uses a simpler strategy, where we store the ordered redeclaration chains in an array-like structure (indexed based on the first declaration), and use that ordering to add individual deserialized declarations to the end of the existing chain. That way, the chain mimics the ordering from its modules, and a bug somewhere is far less likely to result in a broken linked list. llvm-svn: 148222
2012-01-16 00:58:34 +08:00
for (unsigned I = 0, N = Chain.size(); I != N; ++I) {
if (Chain[I] == CanonDecl)
continue;
When merging redeclaration chains across modules, if a declaration is visible in one module but is only declared as a friend in another module, keep it visible in the result of the merge. This is incomplete on two axes: 1) Our handling of local extern declarations is basically broken (we put them in the wrong decl context, and don't find them in redeclaration lookup, unless they've previously been declared), and this results in them making friends visible after a merge. 2) Eventually we'll need to mark that this has happened, and more carefully check whether a declaration should be visible if it was only visible in some of the modules in which it was declared. Fortunately it's rare for the identifier namespace of a declaration to change along its redeclaration chain. llvm-svn: 187639
2013-08-02 09:09:12 +08:00
Completely re-implement (de-)serialization of redeclaration chains, again. The prior implementation was very linked-list oriented, and the list-splicing logic was both fairly convoluted (when loading from multiple modules) and failed to preserve a reasonable ordering for the redeclaration chains. This new implementation uses a simpler strategy, where we store the ordered redeclaration chains in an array-like structure (indexed based on the first declaration), and use that ordering to add individual deserialized declarations to the end of the existing chain. That way, the chain mimics the ordering from its modules, and a bug somewhere is far less likely to result in a broken linked list. llvm-svn: 148222
2012-01-16 00:58:34 +08:00
ASTDeclReader::attachPreviousDecl(Chain[I], MostRecent);
MostRecent = Chain[I];
Completely re-implement (de-)serialization of declaration chains. The previous implementation relied heavily on the declaration chain being stored as a (circular) linked list on disk, as it is in memory. However, when deserializing from multiple modules, the different chains could get mixed up, leading to broken declaration chains. The new solution keeps track of the first and last declarations in the chain for each module file. When we load a declaration, we search all of the module files for redeclarations of that declaration, then splice together all of the lists into a coherent whole (along with any redeclarations that were actually parsed). As a drive-by fix, (de-)serialize the redeclaration chains of TypedefNameDecls, which had somehow gotten missed previously. Add a test of this serialization. This new scheme creates a redeclaration table that is fairly large in the PCH file (on the order of 400k for Cocoa.h's 12MB PCH file). The table is mmap'd in and searched via a binary search, but it's still quite large. A future tweak will eliminate entries for declarations that have no redeclarations anywhere, and should drastically reduce the size of this table. llvm-svn: 146841
2011-12-18 07:38:30 +08:00
}
Completely re-implement (de-)serialization of redeclaration chains, again. The prior implementation was very linked-list oriented, and the list-splicing logic was both fairly convoluted (when loading from multiple modules) and failed to preserve a reasonable ordering for the redeclaration chains. This new implementation uses a simpler strategy, where we store the ordered redeclaration chains in an array-like structure (indexed based on the first declaration), and use that ordering to add individual deserialized declarations to the end of the existing chain. That way, the chain mimics the ordering from its modules, and a bug somewhere is far less likely to result in a broken linked list. llvm-svn: 148222
2012-01-16 00:58:34 +08:00
ASTDeclReader::attachLatestDecl(CanonDecl, MostRecent);
Completely re-implement (de-)serialization of declaration chains. The previous implementation relied heavily on the declaration chain being stored as a (circular) linked list on disk, as it is in memory. However, when deserializing from multiple modules, the different chains could get mixed up, leading to broken declaration chains. The new solution keeps track of the first and last declarations in the chain for each module file. When we load a declaration, we search all of the module files for redeclarations of that declaration, then splice together all of the lists into a coherent whole (along with any redeclarations that were actually parsed). As a drive-by fix, (de-)serialize the redeclaration chains of TypedefNameDecls, which had somehow gotten missed previously. Add a test of this serialization. This new scheme creates a redeclaration table that is fairly large in the PCH file (on the order of 400k for Cocoa.h's 12MB PCH file). The table is mmap'd in and searched via a binary search, but it's still quite large. A future tweak will eliminate entries for declarations that have no redeclarations anywhere, and should drastically reduce the size of this table. llvm-svn: 146841
2011-12-18 07:38:30 +08:00
}
Support importing of ObjC categories from modules. The initial incentive was to fix a crash when PCH chaining categories to an interface, but the fix was done in the "modules way" that I hear is popular with the kids these days. Each module stores the local chain of categories and we combine them when the interface is loaded. We also warn if non-dependent modules introduce duplicate named categories. llvm-svn: 138926
2011-09-01 08:58:55 +08:00
namespace {
/// \brief Given an ObjC interface, goes through the modules and links to the
/// interface all the categories for it.
Reimplement (de-)serialization of Objective-C categories to eliminate the direct serialization of the linked-list structure. Instead, use a scheme similar to how we handle redeclarations, with redeclaration lists on the side. This addresses several issues: - In cases involving mixing and matching of many categories across many modules, the linked-list structure would not be consistent across different modules, and categories would get lost. - If a module is loaded after the class definition and its other categories have already been loaded, we wouldn't see any categories in the newly-loaded module. llvm-svn: 149112
2012-01-27 09:47:08 +08:00
class ObjCCategoriesVisitor {
Support importing of ObjC categories from modules. The initial incentive was to fix a crash when PCH chaining categories to an interface, but the fix was done in the "modules way" that I hear is popular with the kids these days. Each module stores the local chain of categories and we combine them when the interface is loaded. We also warn if non-dependent modules introduce duplicate named categories. llvm-svn: 138926
2011-09-01 08:58:55 +08:00
ASTReader &Reader;
serialization::GlobalDeclID InterfaceID;
ObjCInterfaceDecl *Interface;
Reimplement (de-)serialization of Objective-C categories to eliminate the direct serialization of the linked-list structure. Instead, use a scheme similar to how we handle redeclarations, with redeclaration lists on the side. This addresses several issues: - In cases involving mixing and matching of many categories across many modules, the linked-list structure would not be consistent across different modules, and categories would get lost. - If a module is loaded after the class definition and its other categories have already been loaded, we wouldn't see any categories in the newly-loaded module. llvm-svn: 149112
2012-01-27 09:47:08 +08:00
llvm::SmallPtrSet<ObjCCategoryDecl *, 16> &Deserialized;
unsigned PreviousGeneration;
ObjCCategoryDecl *Tail;
Support importing of ObjC categories from modules. The initial incentive was to fix a crash when PCH chaining categories to an interface, but the fix was done in the "modules way" that I hear is popular with the kids these days. Each module stores the local chain of categories and we combine them when the interface is loaded. We also warn if non-dependent modules introduce duplicate named categories. llvm-svn: 138926
2011-09-01 08:58:55 +08:00
llvm::DenseMap<DeclarationName, ObjCCategoryDecl *> NameCategoryMap;
Reimplement (de-)serialization of Objective-C categories to eliminate the direct serialization of the linked-list structure. Instead, use a scheme similar to how we handle redeclarations, with redeclaration lists on the side. This addresses several issues: - In cases involving mixing and matching of many categories across many modules, the linked-list structure would not be consistent across different modules, and categories would get lost. - If a module is loaded after the class definition and its other categories have already been loaded, we wouldn't see any categories in the newly-loaded module. llvm-svn: 149112
2012-01-27 09:47:08 +08:00
void add(ObjCCategoryDecl *Cat) {
// Only process each category once.
Reduce duplicated hash map lookups. llvm-svn: 162361
2012-08-22 23:37:55 +08:00
if (!Deserialized.erase(Cat))
Reimplement (de-)serialization of Objective-C categories to eliminate the direct serialization of the linked-list structure. Instead, use a scheme similar to how we handle redeclarations, with redeclaration lists on the side. This addresses several issues: - In cases involving mixing and matching of many categories across many modules, the linked-list structure would not be consistent across different modules, and categories would get lost. - If a module is loaded after the class definition and its other categories have already been loaded, we wouldn't see any categories in the newly-loaded module. llvm-svn: 149112
2012-01-27 09:47:08 +08:00
return;
// Check for duplicate categories.
if (Cat->getDeclName()) {
ObjCCategoryDecl *&Existing = NameCategoryMap[Cat->getDeclName()];
if (Existing &&
Reader.getOwningModuleFile(Existing)
!= Reader.getOwningModuleFile(Cat)) {
// FIXME: We should not warn for duplicates in diamond:
//
// MT //
// / \ //
// ML MR //
// \ / //
// MB //
//
// If there are duplicates in ML/MR, there will be warning when
// creating MB *and* when importing MB. We should not warn when
// importing.
Reader.Diag(Cat->getLocation(), diag::warn_dup_category_def)
<< Interface->getDeclName() << Cat->getDeclName();
Reader.Diag(Existing->getLocation(), diag::note_previous_definition);
} else if (!Existing) {
// Record this category.
Existing = Cat;
}
}
// Add this category to the end of the chain.
if (Tail)
ASTDeclReader::setNextObjCCategory(Tail, Cat);
else
Rework the traversal of Objective-C categories and extensions to consider (sub)module visibility. The bulk of this change replaces myriad hand-rolled loops over the linked list of Objective-C categories/extensions attached to an interface declaration with loops using one of the four new category iterator kinds: visible_categories_iterator: Iterates over all visible categories and extensions, hiding any that have their "hidden" bit set. This is by far the most commonly used iterator. known_categories_iterator: Iterates over all categories and extensions, ignoring the "hidden" bit. This tends to be used for redeclaration-like traversals. visible_extensions_iterator: Iterates over all visible extensions, hiding any that have their "hidden" bit set. known_extensions_iterator: Iterates over all extensions, whether they are visible to normal name lookup or not. The effect of this change is that any uses of the visible_ iterators will respect module-import visibility. See the new tests for examples. Note that the old accessors for categories and extensions are gone; there are *Raw() forms for some of them, for those (few) areas of the compiler that have to manipulate the linked list of categories directly. This is generally discouraged. Part two of <rdar://problem/10634711>. llvm-svn: 172665
2013-01-17 07:00:23 +08:00
Interface->setCategoryListRaw(Cat);
Reimplement (de-)serialization of Objective-C categories to eliminate the direct serialization of the linked-list structure. Instead, use a scheme similar to how we handle redeclarations, with redeclaration lists on the side. This addresses several issues: - In cases involving mixing and matching of many categories across many modules, the linked-list structure would not be consistent across different modules, and categories would get lost. - If a module is loaded after the class definition and its other categories have already been loaded, we wouldn't see any categories in the newly-loaded module. llvm-svn: 149112
2012-01-27 09:47:08 +08:00
Tail = Cat;
}
Support importing of ObjC categories from modules. The initial incentive was to fix a crash when PCH chaining categories to an interface, but the fix was done in the "modules way" that I hear is popular with the kids these days. Each module stores the local chain of categories and we combine them when the interface is loaded. We also warn if non-dependent modules introduce duplicate named categories. llvm-svn: 138926
2011-09-01 08:58:55 +08:00
public:
Reimplement (de-)serialization of Objective-C categories to eliminate the direct serialization of the linked-list structure. Instead, use a scheme similar to how we handle redeclarations, with redeclaration lists on the side. This addresses several issues: - In cases involving mixing and matching of many categories across many modules, the linked-list structure would not be consistent across different modules, and categories would get lost. - If a module is loaded after the class definition and its other categories have already been loaded, we wouldn't see any categories in the newly-loaded module. llvm-svn: 149112
2012-01-27 09:47:08 +08:00
ObjCCategoriesVisitor(ASTReader &Reader,
serialization::GlobalDeclID InterfaceID,
ObjCInterfaceDecl *Interface,
llvm::SmallPtrSet<ObjCCategoryDecl *, 16> &Deserialized,
unsigned PreviousGeneration)
Support importing of ObjC categories from modules. The initial incentive was to fix a crash when PCH chaining categories to an interface, but the fix was done in the "modules way" that I hear is popular with the kids these days. Each module stores the local chain of categories and we combine them when the interface is loaded. We also warn if non-dependent modules introduce duplicate named categories. llvm-svn: 138926
2011-09-01 08:58:55 +08:00
: Reader(Reader), InterfaceID(InterfaceID), Interface(Interface),
Reimplement (de-)serialization of Objective-C categories to eliminate the direct serialization of the linked-list structure. Instead, use a scheme similar to how we handle redeclarations, with redeclaration lists on the side. This addresses several issues: - In cases involving mixing and matching of many categories across many modules, the linked-list structure would not be consistent across different modules, and categories would get lost. - If a module is loaded after the class definition and its other categories have already been loaded, we wouldn't see any categories in the newly-loaded module. llvm-svn: 149112
2012-01-27 09:47:08 +08:00
Deserialized(Deserialized), PreviousGeneration(PreviousGeneration),
Tail(0)
{
// Populate the name -> category map with the set of known categories.
[C++11] Replacing ObjCInterfaceDecl iterators known_categories_begin() and known_categories_end() with iterator_range known_categories(). Updating all of the usages of the iterators with range-based for loops. llvm-svn: 203854
2014-03-14 05:35:02 +08:00
for (auto *Cat : Interface->known_categories()) {
Reimplement (de-)serialization of Objective-C categories to eliminate the direct serialization of the linked-list structure. Instead, use a scheme similar to how we handle redeclarations, with redeclaration lists on the side. This addresses several issues: - In cases involving mixing and matching of many categories across many modules, the linked-list structure would not be consistent across different modules, and categories would get lost. - If a module is loaded after the class definition and its other categories have already been loaded, we wouldn't see any categories in the newly-loaded module. llvm-svn: 149112
2012-01-27 09:47:08 +08:00
if (Cat->getDeclName())
[C++11] Replacing ObjCInterfaceDecl iterators known_categories_begin() and known_categories_end() with iterator_range known_categories(). Updating all of the usages of the iterators with range-based for loops. llvm-svn: 203854
2014-03-14 05:35:02 +08:00
NameCategoryMap[Cat->getDeclName()] = Cat;
Reimplement (de-)serialization of Objective-C categories to eliminate the direct serialization of the linked-list structure. Instead, use a scheme similar to how we handle redeclarations, with redeclaration lists on the side. This addresses several issues: - In cases involving mixing and matching of many categories across many modules, the linked-list structure would not be consistent across different modules, and categories would get lost. - If a module is loaded after the class definition and its other categories have already been loaded, we wouldn't see any categories in the newly-loaded module. llvm-svn: 149112
2012-01-27 09:47:08 +08:00
// Keep track of the tail of the category list.
[C++11] Replacing ObjCInterfaceDecl iterators known_categories_begin() and known_categories_end() with iterator_range known_categories(). Updating all of the usages of the iterators with range-based for loops. llvm-svn: 203854
2014-03-14 05:35:02 +08:00
Tail = Cat;
Reimplement (de-)serialization of Objective-C categories to eliminate the direct serialization of the linked-list structure. Instead, use a scheme similar to how we handle redeclarations, with redeclaration lists on the side. This addresses several issues: - In cases involving mixing and matching of many categories across many modules, the linked-list structure would not be consistent across different modules, and categories would get lost. - If a module is loaded after the class definition and its other categories have already been loaded, we wouldn't see any categories in the newly-loaded module. llvm-svn: 149112
2012-01-27 09:47:08 +08:00
}
}
Support importing of ObjC categories from modules. The initial incentive was to fix a crash when PCH chaining categories to an interface, but the fix was done in the "modules way" that I hear is popular with the kids these days. Each module stores the local chain of categories and we combine them when the interface is loaded. We also warn if non-dependent modules introduce duplicate named categories. llvm-svn: 138926
2011-09-01 08:58:55 +08:00
Promote ModuleMap::Module to a namespace-scope class in the Basic library, since modules cut across all of the libraries. Rename serialization::Module to serialization::ModuleFile to side-step the annoying naming conflict. Prune a bunch of ModuleMap.h includes that are no longer needed (most files only needed the Module type). llvm-svn: 145538
2011-12-01 07:21:26 +08:00
static bool visit(ModuleFile &M, void *UserData) {
Reimplement (de-)serialization of Objective-C categories to eliminate the direct serialization of the linked-list structure. Instead, use a scheme similar to how we handle redeclarations, with redeclaration lists on the side. This addresses several issues: - In cases involving mixing and matching of many categories across many modules, the linked-list structure would not be consistent across different modules, and categories would get lost. - If a module is loaded after the class definition and its other categories have already been loaded, we wouldn't see any categories in the newly-loaded module. llvm-svn: 149112
2012-01-27 09:47:08 +08:00
return static_cast<ObjCCategoriesVisitor *>(UserData)->visit(M);
Support importing of ObjC categories from modules. The initial incentive was to fix a crash when PCH chaining categories to an interface, but the fix was done in the "modules way" that I hear is popular with the kids these days. Each module stores the local chain of categories and we combine them when the interface is loaded. We also warn if non-dependent modules introduce duplicate named categories. llvm-svn: 138926
2011-09-01 08:58:55 +08:00
}
Promote ModuleMap::Module to a namespace-scope class in the Basic library, since modules cut across all of the libraries. Rename serialization::Module to serialization::ModuleFile to side-step the annoying naming conflict. Prune a bunch of ModuleMap.h includes that are no longer needed (most files only needed the Module type). llvm-svn: 145538
2011-12-01 07:21:26 +08:00
bool visit(ModuleFile &M) {
Reimplement (de-)serialization of Objective-C categories to eliminate the direct serialization of the linked-list structure. Instead, use a scheme similar to how we handle redeclarations, with redeclaration lists on the side. This addresses several issues: - In cases involving mixing and matching of many categories across many modules, the linked-list structure would not be consistent across different modules, and categories would get lost. - If a module is loaded after the class definition and its other categories have already been loaded, we wouldn't see any categories in the newly-loaded module. llvm-svn: 149112
2012-01-27 09:47:08 +08:00
// If we've loaded all of the category information we care about from
// this module file, we're done.
if (M.Generation <= PreviousGeneration)
return true;
// Map global ID of the definition down to the local ID used in this
// module file. If there is no such mapping, we'll find nothing here
// (or in any module it imports).
DeclID LocalID = Reader.mapGlobalIDToModuleFileGlobalID(M, InterfaceID);
if (!LocalID)
return true;
Support importing of ObjC categories from modules. The initial incentive was to fix a crash when PCH chaining categories to an interface, but the fix was done in the "modules way" that I hear is popular with the kids these days. Each module stores the local chain of categories and we combine them when the interface is loaded. We also warn if non-dependent modules introduce duplicate named categories. llvm-svn: 138926
2011-09-01 08:58:55 +08:00
Reimplement (de-)serialization of Objective-C categories to eliminate the direct serialization of the linked-list structure. Instead, use a scheme similar to how we handle redeclarations, with redeclaration lists on the side. This addresses several issues: - In cases involving mixing and matching of many categories across many modules, the linked-list structure would not be consistent across different modules, and categories would get lost. - If a module is loaded after the class definition and its other categories have already been loaded, we wouldn't see any categories in the newly-loaded module. llvm-svn: 149112
2012-01-27 09:47:08 +08:00
// Perform a binary search to find the local redeclarations for this
// declaration (if any).
Serialization: Directly compare objects instead of using a functor duplicating the compare operators. No functionality change. llvm-svn: 204006
2014-03-15 22:21:58 +08:00
const ObjCCategoriesInfo Compare = { LocalID, 0 };
Reimplement (de-)serialization of Objective-C categories to eliminate the direct serialization of the linked-list structure. Instead, use a scheme similar to how we handle redeclarations, with redeclaration lists on the side. This addresses several issues: - In cases involving mixing and matching of many categories across many modules, the linked-list structure would not be consistent across different modules, and categories would get lost. - If a module is loaded after the class definition and its other categories have already been loaded, we wouldn't see any categories in the newly-loaded module. llvm-svn: 149112
2012-01-27 09:47:08 +08:00
const ObjCCategoriesInfo *Result
= std::lower_bound(M.ObjCCategoriesMap,
M.ObjCCategoriesMap + M.LocalNumObjCCategoriesInMap,
Serialization: Directly compare objects instead of using a functor duplicating the compare operators. No functionality change. llvm-svn: 204006
2014-03-15 22:21:58 +08:00
Compare);
Reimplement (de-)serialization of Objective-C categories to eliminate the direct serialization of the linked-list structure. Instead, use a scheme similar to how we handle redeclarations, with redeclaration lists on the side. This addresses several issues: - In cases involving mixing and matching of many categories across many modules, the linked-list structure would not be consistent across different modules, and categories would get lost. - If a module is loaded after the class definition and its other categories have already been loaded, we wouldn't see any categories in the newly-loaded module. llvm-svn: 149112
2012-01-27 09:47:08 +08:00
if (Result == M.ObjCCategoriesMap + M.LocalNumObjCCategoriesInMap ||
Result->DefinitionID != LocalID) {
// We didn't find anything. If the class definition is in this module
// file, then the module files it depends on cannot have any categories,
// so suppress further lookup.
return Reader.isDeclIDFromModule(InterfaceID, M);
Support importing of ObjC categories from modules. The initial incentive was to fix a crash when PCH chaining categories to an interface, but the fix was done in the "modules way" that I hear is popular with the kids these days. Each module stores the local chain of categories and we combine them when the interface is loaded. We also warn if non-dependent modules introduce duplicate named categories. llvm-svn: 138926
2011-09-01 08:58:55 +08:00
}
Reimplement (de-)serialization of Objective-C categories to eliminate the direct serialization of the linked-list structure. Instead, use a scheme similar to how we handle redeclarations, with redeclaration lists on the side. This addresses several issues: - In cases involving mixing and matching of many categories across many modules, the linked-list structure would not be consistent across different modules, and categories would get lost. - If a module is loaded after the class definition and its other categories have already been loaded, we wouldn't see any categories in the newly-loaded module. llvm-svn: 149112
2012-01-27 09:47:08 +08:00
// We found something. Dig out all of the categories.
unsigned Offset = Result->Offset;
unsigned N = M.ObjCCategories[Offset];
M.ObjCCategories[Offset++] = 0; // Don't try to deserialize again
for (unsigned I = 0; I != N; ++I)
add(cast_or_null<ObjCCategoryDecl>(
Reader.GetLocalDecl(M, M.ObjCCategories[Offset++])));
return true;
Support importing of ObjC categories from modules. The initial incentive was to fix a crash when PCH chaining categories to an interface, but the fix was done in the "modules way" that I hear is popular with the kids these days. Each module stores the local chain of categories and we combine them when the interface is loaded. We also warn if non-dependent modules introduce duplicate named categories. llvm-svn: 138926
2011-09-01 08:58:55 +08:00
}
};
}
Reimplement (de-)serialization of Objective-C categories to eliminate the direct serialization of the linked-list structure. Instead, use a scheme similar to how we handle redeclarations, with redeclaration lists on the side. This addresses several issues: - In cases involving mixing and matching of many categories across many modules, the linked-list structure would not be consistent across different modules, and categories would get lost. - If a module is loaded after the class definition and its other categories have already been loaded, we wouldn't see any categories in the newly-loaded module. llvm-svn: 149112
2012-01-27 09:47:08 +08:00
void ASTReader::loadObjCCategories(serialization::GlobalDeclID ID,
ObjCInterfaceDecl *D,
unsigned PreviousGeneration) {
ObjCCategoriesVisitor Visitor(*this, ID, D, CategoriesDeserialized,
PreviousGeneration);
ModuleMgr.visit(ObjCCategoriesVisitor::visit, &Visitor);
Support importing of ObjC categories from modules. The initial incentive was to fix a crash when PCH chaining categories to an interface, but the fix was done in the "modules way" that I hear is popular with the kids these days. Each module stores the local chain of categories and we combine them when the interface is loaded. We also warn if non-dependent modules introduce duplicate named categories. llvm-svn: 138926
2011-09-01 08:58:55 +08:00
}
In the serialized AST format, make the translation unit a "predefined" declaration that never actually gets serialized. Instead, serialize the various kinds of update records (lexical decls, visible decls, the addition of an anonymous namespace) for the translation unit, even if we're not chaining. This way, we won't have to deal with multiple loaded translation unit declarations. llvm-svn: 137395
2011-08-12 08:15:20 +08:00
Promote ModuleMap::Module to a namespace-scope class in the Basic library, since modules cut across all of the libraries. Rename serialization::Module to serialization::ModuleFile to side-step the annoying naming conflict. Prune a bunch of ModuleMap.h includes that are no longer needed (most files only needed the Module type). llvm-svn: 145538
2011-12-01 07:21:26 +08:00
void ASTDeclReader::UpdateDecl(Decl *D, ModuleFile &ModuleFile,
Add a decl update when a static data member of a class template is instantiated in a different PCH than its containing class. Otherwise we get double definition errors. Fixes a Boost.MPL problem that affects Boost.Accumulators and probably a lot more of Boost. llvm-svn: 130488
2011-04-29 16:19:30 +08:00
const RecordData &Record) {
Start fleshing out ASTMutationListener; notify when a tag definition is completed. In that case a chained PCH will record the updates to the DefinitionData pointer of forward references. If a forward reference mutated into a definition re-write it into the chained PCH, this is too big of a change. llvm-svn: 117239
2010-10-25 01:26:50 +08:00
while (Idx < Record.size()) {
switch ((DeclUpdateKind)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
case UPD_CXX_ADDED_IMPLICIT_MEMBER: {
Decl *MD = Reader.ReadDecl(ModuleFile, Record, Idx);
assert(MD && "couldn't read decl from update record");
cast<CXXRecordDecl>(D)->addedMember(MD);
Keep track in chained PCH of implicit members that were added after the definition was completed. llvm-svn: 117240
2010-10-25 01:26:54 +08:00
break;
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
}
Use the ASTMutationListener to track added template specializations in a chained PCH. llvm-svn: 117533
2010-10-28 15:38:42 +08:00
case UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION:
// It will be added to the template's specializations set when loaded.
Promote ModuleMap::Module to a namespace-scope class in the Basic library, since modules cut across all of the libraries. Rename serialization::Module to serialization::ModuleFile to side-step the annoying naming conflict. Prune a bunch of ModuleMap.h includes that are no longer needed (most files only needed the Module type). llvm-svn: 145538
2011-12-01 07:21:26 +08:00
(void)Reader.ReadDecl(ModuleFile, Record, Idx);
Fix adding an anonymous namespace in a chained PCH to a namespace from a previous PCH. Fix anonymous namespaces in PCH. llvm-svn: 130104
2011-04-25 00:28:13 +08:00
break;
case UPD_CXX_ADDED_ANONYMOUS_NAMESPACE: {
Introduce the local -> global declaration ID mapping into the AST reader, to allow AST files to be loaded with their declarations remapped to different ID numbers. Fix a number of places where we were either failing to map local declaration IDs into global declaration IDs or where interpreting the local declaration IDs within the wrong module. I've tested this via the usual "random gaps" method. It works well except for the preamble tests, because our handling of the precompiled preamble requires declaration and preprocessed entity to be stable when parsing code and then loading that back into memory. This property will hold in general, but my randomized testing naturally breaks this property to get more coverage. In the future, I expect that the precompiled preamble logic won't need this property. I am very unhappy with the current handling of the translation unit, which is a rather egregious hack. We're going to have to do something very different here for loading multiple AST files, because we don't want to have to cope with merging two translation units. Likely, we'll just handle translation units entirely via "update" records, and predefine a single, fixed declaration ID for the translation unit. That will come later. llvm-svn: 136779
2011-08-03 23:48:04 +08:00
NamespaceDecl *Anon
Promote ModuleMap::Module to a namespace-scope class in the Basic library, since modules cut across all of the libraries. Rename serialization::Module to serialization::ModuleFile to side-step the annoying naming conflict. Prune a bunch of ModuleMap.h includes that are no longer needed (most files only needed the Module type). llvm-svn: 145538
2011-12-01 07:21:26 +08:00
= Reader.ReadDeclAs<NamespaceDecl>(ModuleFile, Record, Idx);
When deserializing an anonymous namespace from a module, do not attach the anonymous namespace to its parent. Semantically, this means that the anonymous namespaces defined in one module are distinct from the anonymous namespaces defined in another module. llvm-svn: 147782
2012-01-10 02:07:24 +08:00
// Each module has its own anonymous namespace, which is disjoint from
// any other module's anonymous namespaces, so don't attach the anonymous
// namespace at all.
if (ModuleFile.Kind != MK_Module) {
if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(D))
TU->setAnonymousNamespace(Anon);
else
cast<NamespaceDecl>(D)->setAnonymousNamespace(Anon);
}
Fix adding an anonymous namespace in a chained PCH to a namespace from a previous PCH. Fix anonymous namespaces in PCH. llvm-svn: 130104
2011-04-25 00:28:13 +08:00
break;
}
Add a decl update when a static data member of a class template is instantiated in a different PCH than its containing class. Otherwise we get double definition errors. Fixes a Boost.MPL problem that affects Boost.Accumulators and probably a lot more of Boost. llvm-svn: 130488
2011-04-29 16:19:30 +08:00
case UPD_CXX_INSTANTIATED_STATIC_DATA_MEMBER:
cast<VarDecl>(D)->getMemberSpecializationInfo()->setPointOfInstantiation(
Promote ModuleMap::Module to a namespace-scope class in the Basic library, since modules cut across all of the libraries. Rename serialization::Module to serialization::ModuleFile to side-step the annoying naming conflict. Prune a bunch of ModuleMap.h includes that are no longer needed (most files only needed the Module type). llvm-svn: 145538
2011-12-01 07:21:26 +08:00
Reader.ReadSourceLocation(ModuleFile, Record, Idx));
Add a decl update when a static data member of a class template is instantiated in a different PCH than its containing class. Otherwise we get double definition errors. Fixes a Boost.MPL problem that affects Boost.Accumulators and probably a lot more of Boost. llvm-svn: 130488
2011-04-29 16:19:30 +08:00
break;
C++1y deduced return types: when we deduce a return type for a function which we loaded from PCH, if we're building another PCH, create an update record to patch the return type of the earlier declaration. llvm-svn: 181659
2013-05-11 13:45:24 +08:00
Emit an update record if we instantiate the definition of a function template specialization from a module. (This can also happen for function template specializations in PCHs if they're instantiated eagerly, because they're constexpr or have a deduced return type.) llvm-svn: 204547
2014-03-23 07:33:22 +08:00
case UPD_CXX_INSTANTIATED_FUNCTION_DEFINITION: {
FunctionDecl *FD = cast<FunctionDecl>(D);
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 (Reader.PendingBodies[FD]) {
Emit an update record if we instantiate the definition of a function template specialization from a module. (This can also happen for function template specializations in PCHs if they're instantiated eagerly, because they're constexpr or have a deduced return type.) llvm-svn: 204547
2014-03-23 07:33:22 +08:00
// FIXME: Maybe check for ODR violations.
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
// It's safe to stop now because this update record is always last.
return;
}
Emit an update record if we instantiate the definition of a function template specialization from a module. (This can also happen for function template specializations in PCHs if they're instantiated eagerly, because they're constexpr or have a deduced return type.) llvm-svn: 204547
2014-03-23 07:33:22 +08:00
if (Record[Idx++])
FD->setImplicitlyInline();
FD->setInnerLocStart(Reader.ReadSourceLocation(ModuleFile, Record, Idx));
if (auto *CD = dyn_cast<CXXConstructorDecl>(FD))
std::tie(CD->CtorInitializers, CD->NumCtorInitializers) =
Reader.ReadCXXCtorInitializers(ModuleFile, Record, Idx);
// Store the offset of the body so we can lazily load it later.
Reader.PendingBodies[FD] = GetCurrentCursorOffset();
If an update record makes a declaration interesting, pass it to the consumer. llvm-svn: 204550
2014-03-23 08:27:18 +08:00
HasPendingBody = true;
Emit an update record if we instantiate the definition of a function template specialization from a module. (This can also happen for function template specializations in PCHs if they're instantiated eagerly, because they're constexpr or have a deduced return type.) llvm-svn: 204547
2014-03-23 07:33:22 +08:00
assert(Idx == Record.size() && "lazy body must be last");
break;
}
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
case UPD_CXX_INSTANTIATED_CLASS_DEFINITION: {
auto *RD = cast<CXXRecordDecl>(D);
bool HadDefinition = RD->getDefinition();
ReadCXXRecordDefinition(RD);
// Visible update is handled separately.
uint64_t LexicalOffset = Record[Idx++];
if (!HadDefinition && LexicalOffset) {
RD->setHasExternalLexicalStorage(true);
Reader.ReadDeclContextStorage(ModuleFile, ModuleFile.DeclsCursor,
std::make_pair(LexicalOffset, 0),
ModuleFile.DeclContextInfos[RD]);
}
auto TSK = (TemplateSpecializationKind)Record[Idx++];
SourceLocation POI = Reader.ReadSourceLocation(ModuleFile, Record, Idx);
if (MemberSpecializationInfo *MSInfo =
RD->getMemberSpecializationInfo()) {
MSInfo->setTemplateSpecializationKind(TSK);
MSInfo->setPointOfInstantiation(POI);
} else {
ClassTemplateSpecializationDecl *Spec =
cast<ClassTemplateSpecializationDecl>(RD);
Spec->setTemplateSpecializationKind(TSK);
Spec->setPointOfInstantiation(POI);
}
RD->setTagKind((TagTypeKind)Record[Idx++]);
RD->setLocation(Reader.ReadSourceLocation(ModuleFile, Record, Idx));
RD->setLocStart(Reader.ReadSourceLocation(ModuleFile, Record, Idx));
RD->setRBraceLoc(Reader.ReadSourceLocation(ModuleFile, Record, Idx));
if (Record[Idx++]) {
AttrVec Attrs;
Reader.ReadAttributes(F, Attrs, Record, Idx);
D->setAttrsImpl(Attrs, Reader.getContext());
}
break;
}
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
case UPD_CXX_RESOLVED_EXCEPTION_SPEC: {
auto *FD = cast<FunctionDecl>(D);
auto *FPT = FD->getType()->castAs<FunctionProtoType>();
auto EPI = FPT->getExtProtoInfo();
SmallVector<QualType, 8> ExceptionStorage;
Reader.readExceptionSpec(ModuleFile, ExceptionStorage, EPI, Record, Idx);
FD->setType(Reader.Context.getFunctionType(FPT->getReturnType(),
FPT->getParamTypes(), EPI));
break;
}
C++1y deduced return types: when we deduce a return type for a function which we loaded from PCH, if we're building another PCH, create an update record to patch the return type of the earlier declaration. llvm-svn: 181659
2013-05-11 13:45:24 +08:00
case UPD_CXX_DEDUCED_RETURN_TYPE: {
FunctionDecl *FD = cast<FunctionDecl>(D);
Reader.Context.adjustDeducedFunctionResultType(
FD, Reader.readType(ModuleFile, Record, Idx));
break;
}
Note when a decl is used in AST files. When an AST file is built based on another AST file, it can use a decl from the fist file, and therefore mark the "isUsed" bit. We need to note this in the AST file so that the bit is set correctly when the second AST file is loaded. This patch introduces the distinction between setIsUsed() and markUsed() so that we don't call into the ASTMutationListener callback when it wouldn't be appropriate. Fixes PR16635. llvm-svn: 190016
2013-09-05 08:02:25 +08:00
case UPD_DECL_MARKED_USED: {
Fix regression from r190016. I don't have a reduced testcase yet. llvm-svn: 190094
2013-09-06 04:13:32 +08:00
// FIXME: This doesn't send the right notifications if there are
// ASTMutationListeners other than an ASTWriter.
A decl never becomes unused. Make that explicit in the API. llvm-svn: 193248
2013-10-24 00:46:34 +08:00
D->Used = true;
Note when a decl is used in AST files. When an AST file is built based on another AST file, it can use a decl from the fist file, and therefore mark the "isUsed" bit. We need to note this in the AST file so that the bit is set correctly when the second AST file is loaded. This patch introduces the distinction between setIsUsed() and markUsed() so that we don't call into the ASTMutationListener callback when it wouldn't be appropriate. Fixes PR16635. llvm-svn: 190016
2013-09-05 08:02:25 +08:00
break;
}
Serialize and deserialize mangling numbers. llvm-svn: 204423
2014-03-21 09:48:23 +08:00
case UPD_MANGLING_NUMBER:
Reader.Context.setManglingNumber(cast<NamedDecl>(D), Record[Idx++]);
break;
case UPD_STATIC_LOCAL_NUMBER:
Reader.Context.setStaticLocalNumber(cast<VarDecl>(D), Record[Idx++]);
break;
Start fleshing out ASTMutationListener; notify when a tag definition is completed. In that case a chained PCH will record the updates to the DefinitionData pointer of forward references. If a forward reference mutated into a definition re-write it into the chained PCH, this is too big of a change. llvm-svn: 117239
2010-10-25 01:26:50 +08:00
}
}
Put the mechanism in place to track modifications in an AST entity that were committed after its initial creation/deserialization and store the changes in a chained PCH. The idea is that the AST entities call methods on the ASTMutationListener to give notifications of changes; the PCHWriter implements the ASTMutationListener interface and stores the incremental changes of the updated entity. WIP llvm-svn: 117235
2010-10-25 01:26:36 +08:00
}