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

2479 lines
92 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.
//
//===----------------------------------------------------------------------===//
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"
Rename the ASTReader header files. llvm-svn: 111474
2010-08-19 07:57:17 +08:00
#include "clang/Serialization/ASTReader.h"
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
#include "clang/Sema/IdentifierResolver.h"
#include "clang/Sema/Sema.h"
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
#include "clang/Sema/SemaDiagnostic.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"
#include "clang/AST/DeclVisitor.h"
#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/DeclCXX.h"
#include "clang/AST/DeclTemplate.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"
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;
Thread bitstream cursors all the way through the AST reading stuff. This way, reading a trivial 2-element chained file actually works. llvm-svn: 109191
2010-07-23 06:43:28 +08:00
llvm::BitstreamCursor &Cursor;
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
DeclID DeclContextIDForTemplateParmDecl;
DeclID LexicalDeclContextIDForTemplateParmDecl;
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
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));
}
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 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;
RedeclarableResult &operator=(RedeclarableResult&); // DO NOT IMPLEMENT
public:
RedeclarableResult(ASTReader &Reader, GlobalDeclID FirstID)
: Reader(Reader), FirstID(FirstID), Owning(true) { }
RedeclarableResult(const RedeclarableResult &Other)
: Reader(Other.Reader), FirstID(Other.FirstID), Owning(Other.Owning)
{
Other.Owning = false;
}
~RedeclarableResult() {
Make a note for an optimization that I'd like to implement, when the ASTs for local externs are sound llvm-svn: 147185
2011-12-23 06:05:07 +08:00
// FIXME: We want to suppress this when the declaration is local to
// a function, since there's no reason to search other AST files
// for redeclarations (they can't exist). However, this is hard to
// do locally because the declaration hasn't necessarily loaded its
// declaration context yet. Also, local externs still have the function
// as their (semantic) declaration context, which is wrong and would
// break this optimize.
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 (FirstID && Owning && Reader.PendingDeclChainsKnown.insert(FirstID))
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;
}
};
/// \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;
FindExistingResult &operator=(FindExistingResult&); // DO NOT IMPLEMENT
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,
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 &Cursor, 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)
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
: Reader(Reader), F(F), Cursor(Cursor), 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),
TypeIDForTypeDecl(0) { }
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
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);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
void VisitTagDecl(TagDecl *TD);
void VisitEnumDecl(EnumDecl *ED);
void VisitRecordDecl(RecordDecl *RD);
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 VisitCXXRecordDecl(CXXRecordDecl *D);
void VisitClassTemplateSpecializationDecl(
ClassTemplateSpecializationDecl *D);
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);
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);
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);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
void VisitVarDecl(VarDecl *VD);
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);
void 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);
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);
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 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
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 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>
void mergeRedeclarable(Redeclarable<T> *D, RedeclarableResult &Redecl);
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);
};
}
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)) {
Speculatively revert r110610 " Make ObjCInterfaceDecl redeclarable, and create separate decl nodes for forward declarations and the definition," which appears to be causing significant Objective-C breakage. llvm-svn: 110803
2010-08-11 20:19:30 +08:00
// if we have a fully initialized TypeDecl, we can safely 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.
if (Record[Idx++])
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
FD->setLazyBody(GetCurrentCursorOffset());
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 if (D->isTemplateParameter()) {
// If we have a fully initialized template parameter, we can now
// set its DeclContext.
[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 = cast<DeclContext>(
Reader.GetDecl(DeclContextIDForTemplateParmDecl));
DeclContext *LexicalDC = cast<DeclContext>(
Reader.GetDecl(LexicalDeclContextIDForTemplateParmDecl));
D->setDeclContextsImpl(SemaDC, LexicalDC, Reader.getContext());
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) {
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
if (D->isTemplateParameter()) {
// We don't want to deserialize the DeclContext of a template
// parameter immediately, because the template parameter might be
// used in the formulation of its DeclContext. Use the translation
// unit DeclContext as a placeholder.
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
DeclContextIDForTemplateParmDecl = ReadDeclID(Record, Idx);
LexicalDeclContextIDForTemplateParmDecl = ReadDeclID(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
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);
[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.
[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->setDeclContextsImpl(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++]);
Keep track of when declarations are "used" according to C and C++. This logic is required to trigger implicit instantiation of function templates and member functions of class templates, which will be implemented separately. This commit includes support for -Wunused-parameter, printing warnings for named parameters that are not used within a function/Objective-C method/block. Fixes <rdar://problem/6505209>. llvm-svn: 73797
2009-06-20 07:52:42 +08:00
D->setUsed(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.
Reader.HiddenNamesMap[Owner].push_back(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
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);
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
TD->setTypeSourceInfo(GetTypeSourceInfo(Record, Idx));
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
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void 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++]);
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);
Support for C++11 (non-template) alias declarations. llvm-svn: 129567
2011-04-15 22:24:37 +08:00
TD->TypedefNameDeclOrQualifier = Info;
Read/write to/from PCH DeclarationNameLocs, DeclarationNameInfos and QualifierInfos (rdar://8513756). llvm-svn: 116598
2010-10-16 02:21:24 +08:00
} else
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
TD->setTypedefNameForAnonDecl(ReadDeclAs<TypedefNameDecl>(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
mergeRedeclarable(TD, 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
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
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitRecordDecl(RecordDecl *RD) {
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
VisitTagDecl(RD);
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++]);
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));
}
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.
FD->SClass = (StorageClass)Record[Idx++];
FD->SClassAsWritten = (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++];
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:
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
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:
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);
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;
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
CanonTemplate->getSpecializations().FindNodeOrInsertPos(ID, InsertPos);
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
assert(InsertPos && "Another specialization already inserted!");
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
CanonTemplate->getSpecializations().InsertNode(FTInfo, InsertPos);
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);
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++]) {
// In practice, this won't be executed (since method definitions
// don't occur in header files).
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
MD->setBody(Reader.ReadStmt(F));
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
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++]);
MD->setSynthesized(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++]);
[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++]);
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
MD->setResultType(Reader.readType(F, Record, Idx));
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
MD->setResultTypeSourceInfo(GetTypeSourceInfo(Record, Idx));
MD->setEndLoc(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);
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());
Support for IRGen of synthesize bitfield ivars in objc-nonfragile-abi2 (radar 7824380). llvm-svn: 111823
2010-08-24 02:51:39 +08:00
CD->setHasSynthBitfield(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::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));
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));
Support ObjC implementation decls for PCH. Strictly speaking, implementations don't go in headers but there's no law against it. llvm-svn: 110567
2010-08-09 18:54:20 +08:00
llvm::tie(D->IvarInitializers, D->NumIvarInitializers)
Renamed CXXBaseOrMemberInitializer to CXXCtorInitializer. This is both shorter, more accurate, and makes it make sense for it to hold a delegating constructor call. llvm-svn: 123084
2011-01-09 04:30:50 +08:00
= Reader.ReadCXXCtorInitializers(F, Record, Idx);
Support for IRGen of synthesize bitfield ivars in objc-nonfragile-abi2 (radar 7824380). llvm-svn: 111823
2010-08-24 02:51:39 +08:00
D->setHasSynthBitfield(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);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
FD->setMutable(Record[Idx++]);
Implement support for C++11 in-class initialization of non-static data members. llvm-svn: 132878
2011-06-12 01:19:42 +08:00
int BitWidthOrInitializer = Record[Idx++];
if (BitWidthOrInitializer == 1)
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
FD->setBitWidth(Reader.ReadExpr(F));
Implement support for C++11 in-class initialization of non-static data members. llvm-svn: 132878
2011-06-12 01:19:42 +08:00
else if (BitWidthOrInitializer == 2)
FD->setInClassInitializer(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
}
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
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
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitVarDecl(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);
Implement declaration merging for variables in disjoint modules. llvm-svn: 147535
2012-01-05 01:21:36 +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++];
VD->VarDeclBits.SClassAsWritten = (StorageClass)Record[Idx++];
VD->VarDeclBits.ThreadSpecified = 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++];
(Implicit) parameters deserialized as part of a function type must not get added to the identifier chains as part of deserialization, because they should not be visible to name lookup. llvm-svn: 148159
2012-01-14 07:49:34 +08:00
// Only true variables (not parameters or implicit parameters) can be merged.
if (VD->getKind() == Decl::Var)
mergeRedeclarable(VD, Redecl);
Implement declaration merging for variables in disjoint modules. llvm-svn: 147535
2012-01-05 01:21:36 +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
if (Record[Idx++]) { // 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);
Read/write specialization info of static data members for PCH. llvm-svn: 107593
2010-07-05 05:44:00 +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::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));
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
}
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);
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.
D->AnonOrFirstNamespaceAndInline.setPointer(D->getFirstDeclaration());
}
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);
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
D->setUsingLocation(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));
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +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) {
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);
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++];
Data.UserDeclaredCopyConstructor = Record[Idx++];
Finish implementing (de-)serialization of the CXXDefinitionData bits needed for implicit move constructors and move assignment operators. Fixes PR10847. llvm-svn: 139144
2011-09-07 00:38:46 +08:00
Data.UserDeclaredMoveConstructor = Record[Idx++];
Minor refactoring; Pull reading/writing DefinitionData out into a function. llvm-svn: 117233
2010-10-25 01:26:27 +08:00
Data.UserDeclaredCopyAssignment = Record[Idx++];
Finish implementing (de-)serialization of the CXXDefinitionData bits needed for implicit move constructors and move assignment operators. Fixes PR10847. llvm-svn: 139144
2011-09-07 00:38:46 +08:00
Data.UserDeclaredMoveAssignment = Record[Idx++];
Minor refactoring; Pull reading/writing DefinitionData out into a function. llvm-svn: 117233
2010-10-25 01:26:27 +08:00
Data.UserDeclaredDestructor = Record[Idx++];
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++];
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++];
Rename "hasTrivialConstructor" to "hasTrivialDefaultConstructor" and modify the semantics slightly to accomodate default constructors (I hope). llvm-svn: 131087
2011-05-10 02:22:59 +08:00
Data.HasTrivialDefaultConstructor = 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.DefaultedCopyConstructorIsConstexpr = Record[Idx++];
Data.DefaultedMoveConstructorIsConstexpr = Record[Idx++];
Data.HasConstexprDefaultConstructor = Record[Idx++];
Data.HasConstexprCopyConstructor = Record[Idx++];
Data.HasConstexprMoveConstructor = Record[Idx++];
Minor refactoring; Pull reading/writing DefinitionData out into a function. llvm-svn: 117233
2010-10-25 01:26:27 +08:00
Data.HasTrivialCopyConstructor = Record[Idx++];
Begin tracking trivialness of move constructors and move assignment operators in C++ record declarations. This patch starts off by updating a bunch of the standard citations to refer to the draft 0x standard so that the semantics intended for move varianst is clear. Where necessary these are duplicated so they'll be available in doxygen. It adds bit fields to keep track of the state for the move constructs, and updates all the code necessary to track this state (I think) as members are declared for a class. It also wires the state into the various trait-like accessors in the AST's API, and tests that the type trait expressions now behave correctly in the presence of move constructors and move assignment operators. This isn't complete yet due to these glaring FIXMEs: 1) No synthesis of implicit move constructors or assignment operators. 2) I don't think we correctly enforce the new logic for both copy and move trivial checks: that the *selected* copy/move constructor/operator is trivial. Currently this requires *all* of them to be trivial. 3) Some of the trait logic needs to be folded into the fine-grained trivial bits to more closely match the wording of the standard. For example, many of the places we currently set a bit to track POD-ness could be removed by querying other more fine grained traits on demand. llvm-svn: 130076
2011-04-24 07:10:33 +08:00
Data.HasTrivialMoveConstructor = Record[Idx++];
Minor refactoring; Pull reading/writing DefinitionData out into a function. llvm-svn: 117233
2010-10-25 01:26:27 +08:00
Data.HasTrivialCopyAssignment = Record[Idx++];
Begin tracking trivialness of move constructors and move assignment operators in C++ record declarations. This patch starts off by updating a bunch of the standard citations to refer to the draft 0x standard so that the semantics intended for move varianst is clear. Where necessary these are duplicated so they'll be available in doxygen. It adds bit fields to keep track of the state for the move constructs, and updates all the code necessary to track this state (I think) as members are declared for a class. It also wires the state into the various trait-like accessors in the AST's API, and tests that the type trait expressions now behave correctly in the presence of move constructors and move assignment operators. This isn't complete yet due to these glaring FIXMEs: 1) No synthesis of implicit move constructors or assignment operators. 2) I don't think we correctly enforce the new logic for both copy and move trivial checks: that the *selected* copy/move constructor/operator is trivial. Currently this requires *all* of them to be trivial. 3) Some of the trait logic needs to be folded into the fine-grained trivial bits to more closely match the wording of the standard. For example, many of the places we currently set a bit to track POD-ness could be removed by querying other more fine grained traits on demand. llvm-svn: 130076
2011-04-24 07:10:33 +08:00
Data.HasTrivialMoveAssignment = Record[Idx++];
Minor refactoring; Pull reading/writing DefinitionData out into a function. llvm-svn: 117233
2010-10-25 01:26:27 +08:00
Data.HasTrivialDestructor = 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.HasIrrelevantDestructor = 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++];
Minor refactoring; Pull reading/writing DefinitionData out into a function. llvm-svn: 117233
2010-10-25 01:26:27 +08:00
Data.DeclaredDefaultConstructor = Record[Idx++];
Data.DeclaredCopyConstructor = Record[Idx++];
Finish implementing (de-)serialization of the CXXDefinitionData bits needed for implicit move constructors and move assignment operators. Fixes PR10847. llvm-svn: 139144
2011-09-07 00:38:46 +08:00
Data.DeclaredMoveConstructor = Record[Idx++];
Minor refactoring; Pull reading/writing DefinitionData out into a function. llvm-svn: 117233
2010-10-25 01:26:27 +08:00
Data.DeclaredCopyAssignment = Record[Idx++];
Finish implementing (de-)serialization of the CXXDefinitionData bits needed for implicit move constructors and move assignment operators. Fixes PR10847. llvm-svn: 139144
2011-09-07 00:38:46 +08:00
Data.DeclaredMoveAssignment = Record[Idx++];
Minor refactoring; Pull reading/writing DefinitionData out into a function. llvm-svn: 117233
2010-10-25 01:26:27 +08:00
Data.DeclaredDestructor = Record[Idx++];
Serialize the new bits in CXXRecordDecl::DefinitionData. llvm-svn: 138855
2011-08-31 21:59:56 +08:00
Data.FailedImplicitMoveConstructor = Record[Idx++];
Data.FailedImplicitMoveAssignment = 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!");
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
Data.FirstFriend = ReadDeclAs<FriendDecl>(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++];
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;
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++]);
VarDecl *Var = ReadDeclAs<VarDecl>(Record, Idx);
SourceLocation EllipsisLoc = ReadSourceLocation(Record, Idx);
*ToCapture++ = Capture(Loc, IsImplicit, Kind, Var, EllipsisLoc);
}
}
Minor refactoring; Pull reading/writing DefinitionData out into a function. llvm-svn: 117233
2010-10-25 01:26:27 +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
void ASTDeclReader::VisitCXXRecordDecl(CXXRecordDecl *D) {
VisitRecordDecl(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();
if (Record[Idx++]) {
Implement AST (de-)serialization for lambda expressions. llvm-svn: 150491
2012-02-15 01:54:36 +08:00
// Determine whether this is a lambda closure type, so that we can
// allocate the appropriate DefinitionData structure.
bool IsLambda = Record[Idx++];
if (IsLambda)
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
D->DefinitionData = new (C) CXXRecordDecl::LambdaDefinitionData(D, false);
Implement AST (de-)serialization for lambda expressions. llvm-svn: 150491
2012-02-15 01:54:36 +08:00
else
D->DefinitionData = new (C) struct CXXRecordDecl::DefinitionData(D);
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
// Propagate the DefinitionData pointer to the canonical declaration, so
// that all other deserialized declarations will see it.
// FIXME: Complain if there already is a DefinitionData!
D->getCanonicalDecl()->DefinitionData = D->DefinitionData;
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
ReadCXXDefinitionData(*D->DefinitionData, Record, Idx);
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
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
// Note that we have deserialized a definition. Any declarations
// deserialized before this one will be be given the DefinitionData pointer
// at the end.
Once we have fully deserialized a redeclaration chain for something with a definition pointer (e.g., C++ and Objective-C classes), zip through the redeclaration chain to make sure that all of the declarations point to the definition data. As part of this, realized again why the first redeclaration of an entity in a file is important, and brought back that idea. llvm-svn: 146886
2011-12-20 03:00:47 +08:00
Reader.PendingDefinitions.insert(D);
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 {
// Propagate DefinitionData pointer from the canonical declaration.
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
D->DefinitionData = D->getCanonicalDecl()->DefinitionData;
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:
break;
case CXXRecTemplate:
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->TemplateOrInstantiation = ReadDeclAs<ClassTemplateDecl>(Record, Idx);
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +08:00
break;
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;
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
// Load the key function to avoid deserializing every method so we can
// compute it.
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
if (D->IsCompleteDefinition) {
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 *Key = ReadDeclAs<CXXMethodDecl>(Record, Idx))
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
C.KeyFunctions[D] = Key;
}
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);
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++];
D->ImplicitlyDefined = Record[Idx++];
Renamed CXXBaseOrMemberInitializer to CXXCtorInitializer. This is both shorter, more accurate, and makes it make sense for it to hold a delegating constructor call. llvm-svn: 123084
2011-01-09 04:30:50 +08:00
llvm::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
D->ImplicitlyDefined = 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->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);
++Idx;
}
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);
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
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
D->Friend = GetTypeSourceInfo(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
else
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);
Lazily load the next friend in the chain of FriendDecls, to eliminate some excessive recursion and deserialization. llvm-svn: 117480
2010-10-28 04:23:41 +08:00
D->NextFriend = 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
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitTemplateDecl(TemplateDecl *D) {
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +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
NamedDecl *TemplatedDecl = ReadDeclAs<NamedDecl>(Record, Idx);
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);
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();
}
}
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
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
VisitTemplateDecl(D);
D->IdentifierNamespace = Record[Idx++];
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
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
if (SpecIDs[0]) {
typedef serialization::DeclID DeclID;
ClassTemplateDecl::Common *CommonPtr = D->getCommonPtr();
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));
}
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +08:00
// InjectedClassNameType is computed.
}
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::VisitClassTemplateSpecializationDecl(
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) {
Support C++ class template specializations and partial specializations for PCH. llvm-svn: 106625
2010-06-23 21:48:30 +08:00
VisitCXXRecordDecl(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
}
}
// Explicit info.
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
if (TypeSourceInfo *TyInfo = GetTypeSourceInfo(Record, Idx)) {
Avoid setters in ASTDeclReader::VisitClassTemplateSpecializationDecl. llvm-svn: 113742
2010-09-13 19:45:32 +08:00
ClassTemplateSpecializationDecl::ExplicitSpecializationInfo *ExplicitInfo
= new (C) ClassTemplateSpecializationDecl::ExplicitSpecializationInfo;
ExplicitInfo->TypeAsWritten = TyInfo;
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
ExplicitInfo->ExternLoc = ReadSourceLocation(Record, Idx);
ExplicitInfo->TemplateKeywordLoc = ReadSourceLocation(Record, Idx);
Avoid setters in ASTDeclReader::VisitClassTemplateSpecializationDecl. llvm-svn: 113742
2010-09-13 19:45:32 +08:00
D->ExplicitInfo = ExplicitInfo;
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++];
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
Whether the specialization should be added to template's folding set when read from PCH, is determined by a isCanonicalDecl check. llvm-svn: 108833
2010-07-20 21:59:40 +08:00
if (D->isCanonicalDecl()) { // It's kept in the folding set.
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);
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
if (ClassTemplatePartialSpecializationDecl *Partial
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
= dyn_cast<ClassTemplatePartialSpecializationDecl>(D)) {
CanonPattern->getCommonPtr()->PartialSpecializations.InsertNode(Partial);
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
} else {
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
CanonPattern->getCommonPtr()->Specializations.InsertNode(D);
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
}
}
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) {
Support C++ class template specializations and partial specializations for PCH. llvm-svn: 106625
2010-06-23 21:48:30 +08:00
VisitClassTemplateSpecializationDecl(D);
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();
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);
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
unsigned NumArgs = Record[Idx++];
Avoid setters in ASTDeclReader::VisitClassTemplatePartialSpecializationDecl. llvm-svn: 113743
2010-09-13 19:45:41 +08:00
if (NumArgs) {
D->NumArgsAsWritten = NumArgs;
D->ArgsAsWritten = new (C) TemplateArgumentLoc[NumArgs];
for (unsigned i=0; i != NumArgs; ++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->ArgsAsWritten[i] = Reader.ReadTemplateArgumentLoc(F, Record, Idx);
Avoid setters in ASTDeclReader::VisitClassTemplatePartialSpecializationDecl. llvm-svn: 113743
2010-09-13 19:45:41 +08:00
}
D->SequenceNumber = Record[Idx++];
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.
De-virtualize getPreviousDecl() and getMostRecentDecl() when we know we have a redeclarable type, and only use the new virtual versions (getPreviousDeclImpl() and getMostRecentDeclImpl()) when we don't have that type information. This keeps us from penalizing users with strict type information (and is the moral equivalent of a "final" method). Plus, settle on the names getPreviousDecl() and getMostRecentDecl() throughout. llvm-svn: 148187
2012-01-15 00:38:05 +08:00
if (D->getPreviousDecl() == 0) {
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.
Read/write function template specializations for PCH, properly this time. llvm-svn: 107665
2010-07-06 23:37:09 +08:00
// Read the function specialization declarations.
// FunctionTemplateDecl's FunctionTemplateSpecializationInfos are filled
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
// when reading the specialized FunctionDecl.
Read/write function template specializations for PCH, properly this time. llvm-svn: 107665
2010-07-06 23:37:09 +08:00
unsigned NumSpecs = Record[Idx++];
while (NumSpecs--)
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
(void)ReadDecl(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
}
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++]);
// Rest of TemplateTemplateParmDecl.
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
TemplateArgumentLoc Arg = Reader.ReadTemplateArgumentLoc(F, Record, Idx);
Support TemplateTemplateParmDecl for PCH. llvm-svn: 107884
2010-07-09 01:12:57 +08:00
bool IsInherited = Record[Idx++];
D->setDefaultArgument(Arg, IsInherited);
Implement support for template template parameter packs, e.g., template<template<class> class ...Metafunctions> struct apply_to_each; llvm-svn: 122874
2011-01-05 23:48:55 +08:00
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);
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
D->AssertExpr = Reader.ReadExpr(F);
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
}
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.
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
D->RedeclLink = typename 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.
return RedeclarableResult(Reader, FirstDeclID);
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>
void ASTDeclReader::mergeRedeclarable(Redeclarable<T> *D,
RedeclarableResult &Redecl) {
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;
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
if (FindExistingResult ExistingRes = findExisting(static_cast<T*>(D))) {
if (T *Existing = ExistingRes) {
T *ExistingCanon = Existing->getCanonicalDecl();
T *DCanon = static_cast<T*>(D)->getCanonicalDecl();
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
= typename Redeclarable<T>::PreviousDeclLink(ExistingCanon);
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
// When we merge a namespace, update its pointer to the first namespace.
if (NamespaceDecl *Namespace
= dyn_cast<NamespaceDecl>(static_cast<T*>(D))) {
Namespace->AnonOrFirstNamespaceAndInline.setPointer(
static_cast<NamespaceDecl *>(static_cast<void*>(ExistingCanon)));
}
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
// 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()) {
When we deserialize a declaration from a module file, allocate extra storage for the global declaration ID. Declarations that are parsed (rather than deserialized) are unaffected, so the number of declarations that pay this cost tends to be relatively small (since relatively few declarations are ever deserialized). This replaces a largish DenseMap within the AST reader. It's not strictly a win in terms of memory use---not every declaration was added to that DenseMap in the first place---but it's cleaner to have this information available for every deserialized declaration, so that future clients can rely on it. llvm-svn: 147617
2012-01-06 06:27:05 +08:00
GlobalDeclID ExistingCanonID = ExistingCanon->getGlobalID();
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
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.
if (DCanon == static_cast<T*>(D)) {
SmallVectorImpl<DeclID> &Merged = Reader.MergedDecls[ExistingCanon];
if (std::find(Merged.begin(), Merged.end(), Redecl.getFirstID())
== Merged.end())
Merged.push_back(Redecl.getFirstID());
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
// If ExistingCanon did not come from a module file, introduce the
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
// first declaration that *does* come from a module file to the
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
// 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
}
}
}
}
}
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.
static bool isConsumerInterestedIn(Decl *D) {
[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) ||
isa<ObjCImplDecl>(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))
Modify some deleted function methods to better reflect reality: - New isDefined() function checks for deletedness - isThisDeclarationADefinition checks for deletedness - New doesThisDeclarationHaveABody() does what isThisDeclarationADefinition() used to do - The IsDeleted bit is not propagated across redeclarations - isDeleted() now checks the canoncial declaration - New isDeletedAsWritten() does what it says on the tin. - isUserProvided() now correct (thanks Richard!) This fixes the bug that we weren't catching void foo() = delete; void foo() {} as being a redefinition. llvm-svn: 131013
2011-05-07 04:44:56 +08:00
return Func->doesThisDeclarationHaveABody();
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;
}
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;
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.
if (TagDecl *TagX = dyn_cast<TagDecl>(X)) {
TagDecl *TagY = cast<TagDecl>(Y);
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
return (TagX->getTagKind() == TagY->getTagKind()) ||
((TagX->getTagKind() == TTK_Struct || TagX->getTagKind() == TTK_Class) &&
(TagY->getTagKind() == TTK_Struct || TagY->getTagKind() == TTK_Class));
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
}
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
// Functions with the same type and linkage match.
Implement declaration merging for variables in disjoint modules. llvm-svn: 147535
2012-01-05 01:21:36 +08:00
// FIXME: This needs to cope with function templates, 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);
return (FuncX->getLinkage() == FuncY->getLinkage()) &&
FuncX->getASTContext().hasSameType(FuncX->getType(), FuncY->getType());
}
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);
return (VarX->getLinkage() == VarY->getLinkage()) &&
VarX->getASTContext().hasSameType(VarX->getType(), VarY->getType());
}
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
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();
}
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;
}
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;
DeclContext *DC = New->getDeclContext()->getRedeclContext();
if (DC->isTranslationUnit() && Reader.SemaObj) {
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
Reader.SemaObj->IdResolver.tryAddTopLevelDecl(New, New->getDeclName());
} else if (DC->isNamespace()) {
DC->addDecl(New);
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;
}
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->isFileContext())
return FindExistingResult(Reader);
if (DC->isTranslationUnit() && Reader.SemaObj) {
IdentifierResolver &IdResolver = Reader.SemaObj->IdResolver;
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);
}
}
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 (DC->isNamespace()) {
for (DeclContext::lookup_result R = DC->lookup(Name);
R.first != R.second; ++R.first) {
if (isSameEntity(*R.first, D))
return FindExistingResult(Reader, D, *R.first);
}
}
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 FindExistingResult(Reader, D, /*Existing=*/0);
}
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)) {
TD->RedeclLink.setPointer(cast<TagDecl>(previous));
} else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
FD->RedeclLink.setPointer(cast<FunctionDecl>(previous));
} else if (VarDecl *VD = dyn_cast<VarDecl>(D)) {
VD->RedeclLink.setPointer(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)) {
TD->RedeclLink.setPointer(cast<TypedefNameDecl>(previous));
} else if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
Fix chaining of ObjCInterfaceDecl redeclarations llvm-svn: 146722
2011-12-16 11:12:41 +08:00
ID->RedeclLink.setPointer(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)) {
PD->RedeclLink.setPointer(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)) {
ND->RedeclLink.setPointer(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);
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.setPointer(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
}
}
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)) {
FD->RedeclLink
= 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));
} 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;
}
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 ASTReader::loadAndAttachPreviousDecl(Decl *D, serialization::DeclID ID) {
Decl *previous = GetDecl(ID);
ASTDeclReader::attachPreviousDecl(D, previous);
}
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;
[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
ASTDeclReader Reader(*this, *Loc.F, DeclsCursor, 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;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
switch ((DeclCode)DeclsCursor.ReadRecord(Code, Record)) {
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:
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 = FriendDecl::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_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;
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;
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;
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;
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)) {
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)
DC->setHasExternalVisibleStorage(true);
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.
DC->setHasExternalVisibleStorage(true);
DeclContextVisibleUpdates &U = I->second;
for (DeclContextVisibleUpdates::iterator UI = U.begin(), UE = U.end();
UI != UE; ++UI) {
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
UI->second->DeclContextInfos[DC].NameLookupTableData = UI->first;
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
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.
loadDeclUpdateRecords(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.
[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
if (isConsumerInterestedIn(D))
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);
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
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;
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();
unsigned RecCode = Cursor.ReadRecord(Code, Record);
(void)RecCode;
assert(RecCode == DECL_UPDATES && "Expected DECL_UPDATES record!");
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;
[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
ASTDeclReader Reader(*this, *F, Cursor, 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);
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 {
struct CompareLocalRedeclarationsInfoToID {
bool operator()(const LocalRedeclarationsInfo &X, DeclID Y) {
return X.FirstID < Y;
}
bool operator()(DeclID X, const LocalRedeclarationsInfo &Y) {
return X < Y.FirstID;
}
bool operator()(const LocalRedeclarationsInfo &X,
const LocalRedeclarationsInfo &Y) {
return X.FirstID < Y.FirstID;
}
bool operator()(DeclID X, DeclID Y) {
return X < Y;
}
};
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;
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::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;
if (Deserialized.count(D)) {
Deserialized.erase(D);
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).
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,
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
ID, CompareLocalRedeclarationsInfoToID());
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.
llvm::SmallVector<DeclID, 1> SearchDecls;
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())
SearchDecls.append(MergedPos->second.begin(), MergedPos->second.end());
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;
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::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 {
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
struct CompareObjCCategoriesInfo {
bool operator()(const ObjCCategoriesInfo &X, DeclID Y) {
return X.DefinitionID < Y;
}
bool operator()(DeclID X, const ObjCCategoriesInfo &Y) {
return X < Y.DefinitionID;
}
bool operator()(const ObjCCategoriesInfo &X,
const ObjCCategoriesInfo &Y) {
return X.DefinitionID < Y.DefinitionID;
}
bool operator()(DeclID X, DeclID Y) {
return X < Y;
}
};
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
/// \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.
if (!Deserialized.count(Cat))
return;
Deserialized.erase(Cat);
// 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
Interface->setCategoryList(Cat);
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.
for (ObjCCategoryDecl *Cat = Interface->getCategoryList(); Cat;
Cat = Cat->getNextClassCategory()) {
if (Cat->getDeclName())
NameCategoryMap[Cat->getDeclName()] = Cat;
// Keep track of the tail of the category list.
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
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).
const ObjCCategoriesInfo *Result
= std::lower_bound(M.ObjCCategoriesMap,
M.ObjCCategoriesMap + M.LocalNumObjCCategoriesInMap,
LocalID, CompareObjCCategoriesInfo());
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
unsigned Idx = 0;
while (Idx < Record.size()) {
switch ((DeclUpdateKind)Record[Idx++]) {
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
case UPD_CXX_ADDED_IMPLICIT_MEMBER:
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
cast<CXXRecordDecl>(D)->addedMember(Reader.ReadDecl(ModuleFile, Record, Idx));
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;
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;
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
}