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

3914 lines
149 KiB
C++
Raw Normal View History

Rename the ASTReader implementation files. llvm-svn: 111473
2010-08-19 07:57:11 +08:00
//===--- ASTReaderDecl.cpp - Decl Deserialization ---------------*- C++ -*-===//
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
// This file implements the ASTReader::ReadDeclRecord method, which is the
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
// entrypoint for loading a decl.
//
//===----------------------------------------------------------------------===//
Sort all of Clang's files under 'lib', and fix up the broken headers uncovered. This required manually correcting all of the incorrect main-module headers I could find, and running the new llvm/utils/sort_includes.py script over the files. I also manually added quite a few missing headers that were uncovered by shuffling the order or moving headers up to be main-module-headers. llvm-svn: 169237
2012-12-04 17:13:33 +08:00
#include "clang/Serialization/ASTReader.h"
Put the mechanism in place to track modifications in an AST entity that were committed after its initial creation/deserialization and store the changes in a chained PCH. The idea is that the AST entities call methods on the ASTMutationListener to give notifications of changes; the PCHWriter implements the ASTMutationListener interface and stores the incremental changes of the updated entity. WIP llvm-svn: 117235
2010-10-25 01:26:36 +08:00
#include "ASTCommon.h"
Use forward declarations for ASTDeclContextNameLookupTable and add a missing delete. It would be nice to use OwningPtr here, but DeclContextInfo is stored in a DenseMap. llvm-svn: 154763
2012-04-15 20:36:49 +08:00
#include "ASTReaderInternals.h"
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
#include "clang/AST/ASTConsumer.h"
#include "clang/AST/ASTContext.h"
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
#include "clang/AST/DeclCXX.h"
Sort all of Clang's files under 'lib', and fix up the broken headers uncovered. This required manually correcting all of the incorrect main-module headers I could find, and running the new llvm/utils/sort_includes.py script over the files. I also manually added quite a few missing headers that were uncovered by shuffling the order or moving headers up to be main-module-headers. llvm-svn: 169237
2012-12-04 17:13:33 +08:00
#include "clang/AST/DeclGroup.h"
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
#include "clang/AST/DeclTemplate.h"
Sort all of Clang's files under 'lib', and fix up the broken headers uncovered. This required manually correcting all of the incorrect main-module headers I could find, and running the new llvm/utils/sort_includes.py script over the files. I also manually added quite a few missing headers that were uncovered by shuffling the order or moving headers up to be main-module-headers. llvm-svn: 169237
2012-12-04 17:13:33 +08:00
#include "clang/AST/DeclVisitor.h"
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
#include "clang/AST/Expr.h"
Sort all of Clang's files under 'lib', and fix up the broken headers uncovered. This required manually correcting all of the incorrect main-module headers I could find, and running the new llvm/utils/sort_includes.py script over the files. I also manually added quite a few missing headers that were uncovered by shuffling the order or moving headers up to be main-module-headers. llvm-svn: 169237
2012-12-04 17:13:33 +08:00
#include "clang/Sema/IdentifierResolver.h"
#include "clang/Sema/Sema.h"
#include "clang/Sema/SemaDiagnostic.h"
[PCH] Really, pinky swear, fix for PR12689 rdar://11353109 llvm-svn: 156145
2012-05-04 09:49:36 +08:00
#include "llvm/Support/SaveAndRestore.h"
Fix Clang-tidy modernize-use-nullptr warnings in source directories; other minor cleanups Patch by Eugene Zelenko! Differential Revision: http://reviews.llvm.org/D13406 llvm-svn: 249484
2015-10-07 07:40:43 +08:00
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
using namespace clang;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
using namespace clang::serialization;
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
//===----------------------------------------------------------------------===//
// Declaration deserialization
//===----------------------------------------------------------------------===//
Support C++ friend declarations for PCH. This commit 'introduces' a slightly different way to restore the state of the AST object. It makes PCHDeclReader/PCHDeclWriter friends and gives them access to the private members of the object. The rationale is to avoid using/modifying the AST interfaces for PCH read/write so that to: -Avoid complications with objects that have side-effects during creation or when using some setters. -Not 'pollute' the AST interface with methods only used by the PCH reader/writer -Allow AST objects to be read-only. llvm-svn: 107219
2010-06-30 06:47:00 +08:00
namespace clang {
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
class ASTDeclReader : public DeclVisitor<ASTDeclReader, void> {
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
ASTReader &Reader;
Promote ModuleMap::Module to a namespace-scope class in the Basic library, since modules cut across all of the libraries. Rename serialization::Module to serialization::ModuleFile to side-step the annoying naming conflict. Prune a bunch of ModuleMap.h includes that are no longer needed (most files only needed the Module type). llvm-svn: 145538
2011-12-01 07:21:26 +08:00
ModuleFile &F;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
const DeclID ThisDeclID;
[PCH] Pull the location out of the serialized declarations and put it in the array of decl bit offsets. This allows us to easily get at the location of a decl without deserializing it. It increases size of Cocoa PCH by only 0.2%. llvm-svn: 143123
2011-10-28 02:47:35 +08:00
const unsigned RawLocation;
Minor refactoring; Pull reading/writing DefinitionData out into a function. llvm-svn: 117233
2010-10-25 01:26:27 +08:00
typedef ASTReader::RecordData RecordData;
const RecordData &Record;
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
unsigned &Idx;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
TypeID TypeIDForTypeDecl;
[modules] Number anonymous declarations that are lexically within mergeable contexts, so that we can merge them when we merge the surrounding context. llvm-svn: 216639
2014-08-28 09:33:39 +08:00
unsigned AnonymousDeclNumber;
[modules] Fix deserialization cycle when loading a tag declaration with a typedef name for linkage purposes. When loading the type, delay loading its typedef until we've finished loading and merging the type. In its place, save out the name of the typedef, which we need for merging purposes. llvm-svn: 216806
2014-08-30 08:04:23 +08:00
GlobalDeclID NamedDeclForTagDecl;
IdentifierInfo *TypedefNameForLinkage;
Test commit. llvm-svn: 261999
2016-02-26 18:43:34 +08:00
When we load a function or method body from an AST file, we check whether that function/method already has a body (loaded from some other AST file), as introduced in r165137. Delay this check until after the redeclaration chains have been wired up. While I'm here, make the loading of method bodies lazy. llvm-svn: 165513
2012-10-10 01:21:28 +08:00
bool HasPendingBody;
Thread bitstream cursors all the way through the AST reading stuff. This way, reading a trivial 2-element chained file actually works. llvm-svn: 109191
2010-07-23 06:43:28 +08:00
uint64_t GetCurrentCursorOffset();
Test commit. llvm-svn: 261999
2016-02-26 18:43:34 +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);
}
Test commit. llvm-svn: 261999
2016-02-26 18:43:34 +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);
}
Test commit. llvm-svn: 261999
2016-02-26 18:43:34 +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);
}
Test commit. llvm-svn: 261999
2016-02-26 18:43:34 +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
serialization::DeclID ReadDeclID(const RecordData &R, unsigned &I) {
return Reader.ReadDeclID(F, R, I);
}
[modules] When loading in multiple canonical definitions of a template, accumulate the set of specializations rather than overwriting one list with another. llvm-svn: 230712
2015-02-27 08:25:58 +08:00
Serialize `#pragma comment`. `#pragma comment` was handled by Sema calling a function on ASTConsumer, and CodeGen then implementing this function and writing things to its output. Instead, introduce a PragmaCommentDecl AST node and hang one off the TranslationUnitDecl for every `#pragma comment` line, and then use the regular serialization machinery. (Since PragmaCommentDecl has codegen relevance, it's eagerly deserialized.) http://reviews.llvm.org/D17799 llvm-svn: 262493
2016-03-03 01:28:48 +08:00
std::string ReadString(const RecordData &R, unsigned &I) {
return Reader.ReadString(R, I);
}
[modules] When loading in multiple canonical definitions of a template, accumulate the set of specializations rather than overwriting one list with another. llvm-svn: 230712
2015-02-27 08:25:58 +08:00
void ReadDeclIDList(SmallVectorImpl<DeclID> &IDs) {
for (unsigned I = 0, Size = Record[Idx++]; I != Size; ++I)
IDs.push_back(ReadDeclID(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
Decl *ReadDecl(const RecordData &R, unsigned &I) {
return Reader.ReadDecl(F, R, I);
}
template<typename T>
T *ReadDeclAs(const RecordData &R, unsigned &I) {
return Reader.ReadDeclAs<T>(F, R, I);
}
Read/write to/from PCH DeclarationNameLocs, DeclarationNameInfos and QualifierInfos (rdar://8513756). llvm-svn: 116598
2010-10-16 02:21:24 +08:00
void ReadQualifierInfo(QualifierInfo &Info,
Minor refactoring; Pull reading/writing DefinitionData out into a function. llvm-svn: 117233
2010-10-25 01:26:27 +08:00
const RecordData &R, unsigned &I) {
Read/write to/from PCH DeclarationNameLocs, DeclarationNameInfos and QualifierInfos (rdar://8513756). llvm-svn: 116598
2010-10-16 02:21:24 +08:00
Reader.ReadQualifierInfo(F, Info, R, I);
}
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
Read/write to/from PCH DeclarationNameLocs, DeclarationNameInfos and QualifierInfos (rdar://8513756). llvm-svn: 116598
2010-10-16 02:21:24 +08:00
void ReadDeclarationNameLoc(DeclarationNameLoc &DNLoc, DeclarationName Name,
Minor refactoring; Pull reading/writing DefinitionData out into a function. llvm-svn: 117233
2010-10-25 01:26:27 +08:00
const RecordData &R, unsigned &I) {
Read/write to/from PCH DeclarationNameLocs, DeclarationNameInfos and QualifierInfos (rdar://8513756). llvm-svn: 116598
2010-10-16 02:21:24 +08:00
Reader.ReadDeclarationNameLoc(F, DNLoc, Name, R, I);
}
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
Read/write to/from PCH DeclarationNameLocs, DeclarationNameInfos and QualifierInfos (rdar://8513756). llvm-svn: 116598
2010-10-16 02:21:24 +08:00
void ReadDeclarationNameInfo(DeclarationNameInfo &NameInfo,
Minor refactoring; Pull reading/writing DefinitionData out into a function. llvm-svn: 117233
2010-10-25 01:26:27 +08:00
const RecordData &R, unsigned &I) {
Read/write to/from PCH DeclarationNameLocs, DeclarationNameInfos and QualifierInfos (rdar://8513756). llvm-svn: 116598
2010-10-16 02:21:24 +08:00
Reader.ReadDeclarationNameInfo(F, NameInfo, R, I);
}
Thread bitstream cursors all the way through the AST reading stuff. This way, reading a trivial 2-element chained file actually works. llvm-svn: 109191
2010-07-23 06:43:28 +08:00
Implement name hiding for declarations deserialized from a non-visible module. When that module becomes visible, so do those declarations. llvm-svn: 145640
2011-12-02 06:20:10 +08:00
serialization::SubmoduleID readSubmoduleID(const RecordData &R,
unsigned &I) {
if (I >= R.size())
return 0;
return Reader.getGlobalSubmoduleID(F, R[I++]);
}
Introduce a module import declaration, so that we properly represent, e.g., __import_module__ std.vector; in the AST. llvm-svn: 145725
2011-12-03 07:23:56 +08:00
Module *readModule(const RecordData &R, unsigned &I) {
return Reader.getSubmodule(readSubmoduleID(R, I));
}
When a module completes the definition of a class template specialization imported from another module, emit an update record, rather than using the broken decl rewriting mechanism. If multiple modules do this, merge the definitions together, much as we would if they were separate declarations. llvm-svn: 206680
2014-04-19 11:48:30 +08:00
[modules] Be sure to load the lexical definition of a class template specialization from an update record exactly once, even if we needed to fake up the definition. llvm-svn: 227939
2015-02-03 11:32:14 +08:00
void ReadCXXRecordDefinition(CXXRecordDecl *D, bool Update);
Refactoring. - Pass around RecordDataImpl instead of the concrete RecordData so that any SmallVector can be used. - Move ASTDeclWriter::WriteCXXDefinitionData to ASTWriter::AddCXXDefinitionData. llvm-svn: 117236
2010-10-25 01:26:40 +08:00
void ReadCXXDefinitionData(struct CXXRecordDecl::DefinitionData &Data,
const RecordData &R, unsigned &I);
When a module completes the definition of a class template specialization imported from another module, emit an update record, rather than using the broken decl rewriting mechanism. If multiple modules do this, merge the definitions together, much as we would if they were separate declarations. llvm-svn: 206680
2014-04-19 11:48:30 +08:00
void MergeDefinitionData(CXXRecordDecl *D,
[modules] Sometimes we can deserialize a class member but not have yet encountered any definition for the class; this happens when the definition is added by an update record that is not yet loaded. In such a case, eagerly pick the original parent of the member as the canonical definition of the class rather than muddling through with the canonical declaration (the latter can lead to us failing to merge properly later if the canonical definition turns out to be some other declaration). llvm-svn: 226977
2015-01-24 09:07:20 +08:00
struct CXXRecordDecl::DefinitionData &&NewDD);
Refactoring. - Pass around RecordDataImpl instead of the concrete RecordData so that any SmallVector can be used. - Move ASTDeclWriter::WriteCXXDefinitionData to ASTWriter::AddCXXDefinitionData. llvm-svn: 117236
2010-10-25 01:26:40 +08:00
[modules] Number anonymous declarations that are lexically within mergeable contexts, so that we can merge them when we merge the surrounding context. llvm-svn: 216639
2014-08-28 09:33:39 +08:00
static NamedDecl *getAnonymousDeclForMerging(ASTReader &Reader,
DeclContext *DC,
unsigned Index);
static void setAnonymousDeclForMerging(ASTReader &Reader, DeclContext *DC,
unsigned Index, NamedDecl *D);
[modules] Remove some dead code after r245779. llvm-svn: 245780
2015-08-22 10:09:38 +08:00
/// Results from loading a RedeclarableDecl.
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
class RedeclarableResult {
GlobalDeclID FirstID;
[modules] If a module declares an entity and then imports another declaration of that entity, ensure that the redeclaration chain is reordered properly on reload. Otherwise, the result of name lookup for that entity may point to an entity that is too old; if that's an injected friend name or the like, that can result in the name not being found at all. llvm-svn: 228371
2015-02-06 10:42:59 +08:00
Decl *MergeWith;
[modules] Improve performance when there is a local declaration of an entity before the first imported declaration. We don't need to track all formerly-canonical declarations of an entity; it's sufficient to track those ones for which no other formerly-canonical declaration was imported into the same module. We call those ones "key declarations", and use them as our starting points for collecting redeclarations and performing namespace lookups. llvm-svn: 241999
2015-07-13 07:43:21 +08:00
bool IsKeyDecl;
Make RedeclarableResult's ownership-transferring constructor be a move constructor. llvm-svn: 230417
2015-02-25 09:11:29 +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
public:
[modules] Remove some dead code after r245779. llvm-svn: 245780
2015-08-22 10:09:38 +08:00
RedeclarableResult(GlobalDeclID FirstID, Decl *MergeWith, bool IsKeyDecl)
: FirstID(FirstID), MergeWith(MergeWith), IsKeyDecl(IsKeyDecl) {}
[modules] Add an assert for redeclarations that we never added to their redecl chain and fix the cases where it fires. * Handle the __va_list_tag as a predefined decl. Previously we failed to merge sometimes it because it's not visible to name lookup. (In passing, remove redundant __va_list_tag typedefs that we were creating for some ABIs. These didn't affect the mangling or representation of the type.) * For Decls derived from Redeclarable that are not in fact redeclarable (implicit params, function params, ObjC type parameters), remove them from the list of expected redeclarable decls. llvm-svn: 243259
2015-07-27 13:40:23 +08:00
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 Retrieve the first ID.
GlobalDeclID getFirstID() const { return FirstID; }
[modules] If a module declares an entity and then imports another declaration of that entity, ensure that the redeclaration chain is reordered properly on reload. Otherwise, the result of name lookup for that entity may point to an entity that is too old; if that's an injected friend name or the like, that can result in the name not being found at all. llvm-svn: 228371
2015-02-06 10:42:59 +08:00
[modules] Remove some dead code after r245779. llvm-svn: 245780
2015-08-22 10:09:38 +08:00
/// \brief Is this declaration a key declaration?
[modules] Improve performance when there is a local declaration of an entity before the first imported declaration. We don't need to track all formerly-canonical declarations of an entity; it's sufficient to track those ones for which no other formerly-canonical declaration was imported into the same module. We call those ones "key declarations", and use them as our starting points for collecting redeclarations and performing namespace lookups. llvm-svn: 241999
2015-07-13 07:43:21 +08:00
bool isKeyDecl() const { return IsKeyDecl; }
[modules] If a module declares an entity and then imports another declaration of that entity, ensure that the redeclaration chain is reordered properly on reload. Otherwise, the result of name lookup for that entity may point to an entity that is too old; if that's an injected friend name or the like, that can result in the name not being found at all. llvm-svn: 228371
2015-02-06 10:42:59 +08:00
/// \brief Get a known declaration that this should be merged with, if
/// any.
Decl *getKnownMergeTarget() const { return MergeWith; }
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
};
When deserializing a declaration, don't look for redeclarations if its kind indicates that it can never be redeclared. Good for a 1% speedup, and redeclaration searching drops off the profile. llvm-svn: 173054
2013-01-22 00:16:40 +08:00
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
/// \brief Class used to capture the result of searching for an existing
/// declaration of a specific kind and name, along with the ability
/// to update the place where this result was found (the declaration
/// chain hanging off an identifier or the DeclContext we searched in)
/// if requested.
class FindExistingResult {
ASTReader &Reader;
NamedDecl *New;
NamedDecl *Existing;
mutable bool AddResult;
[modules] Fix deserialization cycle when loading a tag declaration with a typedef name for linkage purposes. When loading the type, delay loading its typedef until we've finished loading and merging the type. In its place, save out the name of the typedef, which we need for merging purposes. llvm-svn: 216806
2014-08-30 08:04:23 +08:00
[modules] Number anonymous declarations that are lexically within mergeable contexts, so that we can merge them when we merge the surrounding context. llvm-svn: 216639
2014-08-28 09:33:39 +08:00
unsigned AnonymousDeclNumber;
[modules] Fix deserialization cycle when loading a tag declaration with a typedef name for linkage purposes. When loading the type, delay loading its typedef until we've finished loading and merging the type. In its place, save out the name of the typedef, which we need for merging purposes. llvm-svn: 216806
2014-08-30 08:04:23 +08:00
IdentifierInfo *TypedefNameForLinkage;
[modules] Number anonymous declarations that are lexically within mergeable contexts, so that we can merge them when we merge the surrounding context. llvm-svn: 216639
2014-08-28 09:33:39 +08:00
Removing LLVM_DELETED_FUNCTION, as MSVC 2012 was the last reason for requiring the macro. NFC; Clang edition. llvm-svn: 229339
2015-02-16 06:54:08 +08:00
void operator=(FindExistingResult&) = delete;
[modules] Number anonymous declarations that are lexically within mergeable contexts, so that we can merge them when we merge the surrounding context. llvm-svn: 216639
2014-08-28 09:33:39 +08:00
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
public:
FindExistingResult(ASTReader &Reader)
[modules] Number anonymous declarations that are lexically within mergeable contexts, so that we can merge them when we merge the surrounding context. llvm-svn: 216639
2014-08-28 09:33:39 +08:00
: Reader(Reader), New(nullptr), Existing(nullptr), AddResult(false),
Fix Clang-tidy modernize-use-nullptr warnings in source directories; other minor cleanups Patch by Eugene Zelenko! Differential Revision: http://reviews.llvm.org/D13406 llvm-svn: 249484
2015-10-07 07:40:43 +08:00
AnonymousDeclNumber(0), TypedefNameForLinkage(nullptr) {}
[modules] Number anonymous declarations that are lexically within mergeable contexts, so that we can merge them when we merge the surrounding context. llvm-svn: 216639
2014-08-28 09:33:39 +08:00
FindExistingResult(ASTReader &Reader, NamedDecl *New, NamedDecl *Existing,
[modules] Fix deserialization cycle when loading a tag declaration with a typedef name for linkage purposes. When loading the type, delay loading its typedef until we've finished loading and merging the type. In its place, save out the name of the typedef, which we need for merging purposes. llvm-svn: 216806
2014-08-30 08:04:23 +08:00
unsigned AnonymousDeclNumber,
IdentifierInfo *TypedefNameForLinkage)
[modules] Number anonymous declarations that are lexically within mergeable contexts, so that we can merge them when we merge the surrounding context. llvm-svn: 216639
2014-08-28 09:33:39 +08:00
: Reader(Reader), New(New), Existing(Existing), AddResult(true),
[modules] Fix deserialization cycle when loading a tag declaration with a typedef name for linkage purposes. When loading the type, delay loading its typedef until we've finished loading and merging the type. In its place, save out the name of the typedef, which we need for merging purposes. llvm-svn: 216806
2014-08-30 08:04:23 +08:00
AnonymousDeclNumber(AnonymousDeclNumber),
TypedefNameForLinkage(TypedefNameForLinkage) {}
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +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
FindExistingResult(const FindExistingResult &Other)
[modules] Number anonymous declarations that are lexically within mergeable contexts, so that we can merge them when we merge the surrounding context. llvm-svn: 216639
2014-08-28 09:33:39 +08:00
: Reader(Other.Reader), New(Other.New), Existing(Other.Existing),
AddResult(Other.AddResult),
[modules] Fix deserialization cycle when loading a tag declaration with a typedef name for linkage purposes. When loading the type, delay loading its typedef until we've finished loading and merging the type. In its place, save out the name of the typedef, which we need for merging purposes. llvm-svn: 216806
2014-08-30 08:04:23 +08:00
AnonymousDeclNumber(Other.AnonymousDeclNumber),
TypedefNameForLinkage(Other.TypedefNameForLinkage) {
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.AddResult = false;
}
[modules] Number anonymous declarations that are lexically within mergeable contexts, so that we can merge them when we merge the surrounding context. llvm-svn: 216639
2014-08-28 09:33:39 +08:00
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
~FindExistingResult();
[modules] Number anonymous declarations that are lexically within mergeable contexts, so that we can merge them when we merge the surrounding context. llvm-svn: 216639
2014-08-28 09:33:39 +08:00
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; }
[modules] Number anonymous declarations that are lexically within mergeable contexts, so that we can merge them when we merge the surrounding context. llvm-svn: 216639
2014-08-28 09:33:39 +08:00
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; }
[modules] Number anonymous declarations that are lexically within mergeable contexts, so that we can merge them when we merge the surrounding context. llvm-svn: 216639
2014-08-28 09:33:39 +08:00
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
template<typename T>
operator T*() const { return dyn_cast_or_null<T>(Existing); }
};
[modules] Number anonymous declarations that are lexically within mergeable contexts, so that we can merge them when we merge the surrounding context. llvm-svn: 216639
2014-08-28 09:33:39 +08:00
[modules] Sometimes we can deserialize a class member but not have yet encountered any definition for the class; this happens when the definition is added by an update record that is not yet loaded. In such a case, eagerly pick the original parent of the member as the canonical definition of the class rather than muddling through with the canonical declaration (the latter can lead to us failing to merge properly later if the canonical definition turns out to be some other declaration). llvm-svn: 226977
2015-01-24 09:07:20 +08:00
static DeclContext *getPrimaryContextForMerging(ASTReader &Reader,
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
FindExistingResult findExisting(NamedDecl *D);
[modules] Number anonymous declarations that are lexically within mergeable contexts, so that we can merge them when we merge the surrounding context. llvm-svn: 216639
2014-08-28 09:33:39 +08:00
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
public:
[modules] Fix deserialization cycle when loading a tag declaration with a typedef name for linkage purposes. When loading the type, delay loading its typedef until we've finished loading and merging the type. In its place, save out the name of the typedef, which we need for merging purposes. llvm-svn: 216806
2014-08-30 08:04:23 +08:00
ASTDeclReader(ASTReader &Reader, ModuleFile &F, DeclID thisDeclID,
unsigned RawLocation, const RecordData &Record, unsigned &Idx)
: Reader(Reader), F(F), ThisDeclID(thisDeclID),
RawLocation(RawLocation), Record(Record), Idx(Idx),
TypeIDForTypeDecl(0), NamedDeclForTagDecl(0),
TypedefNameForLinkage(nullptr), HasPendingBody(false) {}
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
[modules] Avoid adding a redecl chain to the 'pending out of date' list as the very first step in updating it. llvm-svn: 230840
2015-02-28 13:57:02 +08:00
template <typename DeclT>
static Decl *getMostRecentDeclImpl(Redeclarable<DeclT> *D);
static Decl *getMostRecentDeclImpl(...);
static Decl *getMostRecentDecl(Decl *D);
Refactor to avoid explicitly listing all the different flavours of redeclarable declarations, and duplicating code between them. llvm-svn: 208662
2014-05-13 09:15:00 +08:00
template <typename DeclT>
[modules] Maintain an AST invariant across module load/save: if any declaration of a function has a resolved exception specification, then all declarations of the function do. We should probably improve the AST representation to make this implicit (perhaps only store the exception specification on the canonical declaration), but this fixes things for now. The testcase for this (which used to assert) also exposes the actual bug I was trying to reduce here: we sometimes fail to emit the body of an imported special member function definition. Fix for that to follow. llvm-svn: 214458
2014-08-01 07:46:44 +08:00
static void attachPreviousDeclImpl(ASTReader &Reader,
[modules] Remove redundant import of lexical decls when building a lookup table for a DeclContext, and fix propagation of exception specifications along redeclaration chains. This reverts r232905, r232907, and r232907, which reverted r232793, r232853, and r232853. One additional change is present here to resolve issues with LLDB: distinguish between whether lexical decls missing from the lookup table are local or are provided by the external AST source, and still look in the external source if that's where they came from. llvm-svn: 232928
2015-03-23 11:25:59 +08:00
Redeclarable<DeclT> *D, Decl *Previous,
Decl *Canon);
[modules] Maintain an AST invariant across module load/save: if any declaration of a function has a resolved exception specification, then all declarations of the function do. We should probably improve the AST representation to make this implicit (perhaps only store the exception specification on the canonical declaration), but this fixes things for now. The testcase for this (which used to assert) also exposes the actual bug I was trying to reduce here: we sometimes fail to emit the body of an imported special member function definition. Fix for that to follow. llvm-svn: 214458
2014-08-01 07:46:44 +08:00
static void attachPreviousDeclImpl(ASTReader &Reader, ...);
[modules] Remove redundant import of lexical decls when building a lookup table for a DeclContext, and fix propagation of exception specifications along redeclaration chains. This reverts r232905, r232907, and r232907, which reverted r232793, r232853, and r232853. One additional change is present here to resolve issues with LLDB: distinguish between whether lexical decls missing from the lookup table are local or are provided by the external AST source, and still look in the external source if that's where they came from. llvm-svn: 232928
2015-03-23 11:25:59 +08:00
static void attachPreviousDecl(ASTReader &Reader, Decl *D, Decl *Previous,
Decl *Canon);
Refactor to avoid explicitly listing all the different flavours of redeclarable declarations, and duplicating code between them. llvm-svn: 208662
2014-05-13 09:15:00 +08:00
template <typename DeclT>
static void attachLatestDeclImpl(Redeclarable<DeclT> *D, Decl *Latest);
static void attachLatestDeclImpl(...);
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
If two sibling modules declare the same entity, and we indirectly pull a declaration of that entity in from one of those modules, keep track of the fact that we've not completed the redeclaration chain yet so that we can pull the remaining declarations in from the other module if they're needed. llvm-svn: 209161
2014-05-20 04:59:20 +08:00
template <typename DeclT>
static void markIncompleteDeclChainImpl(Redeclarable<DeclT> *D);
static void markIncompleteDeclChainImpl(...);
When we load a function or method body from an AST file, we check whether that function/method already has a body (loaded from some other AST file), as introduced in r165137. Delay this check until after the redeclaration chains have been wired up. While I'm here, make the loading of method bodies lazy. llvm-svn: 165513
2012-10-10 01:21:28 +08:00
/// \brief Determine whether this declaration has a pending body.
bool hasPendingBody() const { return HasPendingBody; }
Generally types expect an initialized TypeDecl; its safer and less complicated to delay PCH reading the type of a TypeDecl. llvm-svn: 107469
2010-07-02 19:55:01 +08:00
void Visit(Decl *D);
Promote ModuleMap::Module to a namespace-scope class in the Basic library, since modules cut across all of the libraries. Rename serialization::Module to serialization::ModuleFile to side-step the annoying naming conflict. Prune a bunch of ModuleMap.h includes that are no longer needed (most files only needed the Module type). llvm-svn: 145538
2011-12-01 07:21:26 +08:00
void UpdateDecl(Decl *D, ModuleFile &ModuleFile,
Add a decl update when a static data member of a class template is instantiated in a different PCH than its containing class. Otherwise we get double definition errors. Fixes a Boost.MPL problem that affects Boost.Accumulators and probably a lot more of Boost. llvm-svn: 130488
2011-04-29 16:19:30 +08:00
const RecordData &Record);
Put the mechanism in place to track modifications in an AST entity that were committed after its initial creation/deserialization and store the changes in a chained PCH. The idea is that the AST entities call methods on the ASTMutationListener to give notifications of changes; the PCHWriter implements the ASTMutationListener interface and stores the incremental changes of the updated entity. WIP llvm-svn: 117235
2010-10-25 01:26:36 +08:00
Support importing of ObjC categories from modules. The initial incentive was to fix a crash when PCH chaining categories to an interface, but the fix was done in the "modules way" that I hear is popular with the kids these days. Each module stores the local chain of categories and we combine them when the interface is loaded. We also warn if non-dependent modules introduce duplicate named categories. llvm-svn: 138926
2011-09-01 08:58:55 +08:00
static void setNextObjCCategory(ObjCCategoryDecl *Cat,
ObjCCategoryDecl *Next) {
Cat->NextClassCategory = Next;
}
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
void VisitDecl(Decl *D);
Serialize `#pragma comment`. `#pragma comment` was handled by Sema calling a function on ASTConsumer, and CodeGen then implementing this function and writing things to its output. Instead, introduce a PragmaCommentDecl AST node and hang one off the TranslationUnitDecl for every `#pragma comment` line, and then use the regular serialization machinery. (Since PragmaCommentDecl has codegen relevance, it's eagerly deserialized.) http://reviews.llvm.org/D17799 llvm-svn: 262493
2016-03-03 01:28:48 +08:00
void VisitPragmaCommentDecl(PragmaCommentDecl *D);
Serialize `#pragma detect_mismatch`. This is like r262493, but for pragma detect_mismatch instead of pragma comment. The two pragmas have similar behavior, so use the same approach for both. llvm-svn: 262506
2016-03-03 03:28:54 +08:00
void VisitPragmaDetectMismatchDecl(PragmaDetectMismatchDecl *D);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
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);
[modules] Track the described template in an alias declaration that is the pattern of an alias template declaration. Use this to merge alias templates properly when they're members of class template specializations. llvm-svn: 216437
2014-08-26 11:52:16 +08:00
RedeclarableResult VisitTypedefNameDecl(TypedefNameDecl *TD);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
void VisitTypedefDecl(TypedefDecl *TD);
Support for C++11 (non-template) alias declarations. llvm-svn: 129567
2011-04-15 22:24:37 +08:00
void VisitTypeAliasDecl(TypeAliasDecl *TD);
Fix PCH support for UnresolvedUsingTypenameDecl and UnresolvedUsingValueDecl. llvm-svn: 107268
2010-06-30 16:49:30 +08:00
void VisitUnresolvedUsingTypenameDecl(UnresolvedUsingTypenameDecl *D);
Fix bitcode desynchronization when loading a PCH containing a class template specialization with modules enabled. Just don't merge them at all for now; we'll revisit this when support for template merging is added. In passing, make Decl::dump() a little safer to use with PCH/modules, by making it not deserialize any additional declarations. From a debugger you can call decls_begin() or similar first if you want to dump all child decls. llvm-svn: 182544
2013-05-23 09:49:11 +08:00
RedeclarableResult VisitTagDecl(TagDecl *TD);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
void VisitEnumDecl(EnumDecl *ED);
Fix bitcode desynchronization when loading a PCH containing a class template specialization with modules enabled. Just don't merge them at all for now; we'll revisit this when support for template merging is added. In passing, make Decl::dump() a little safer to use with PCH/modules, by making it not deserialize any additional declarations. From a debugger you can call decls_begin() or similar first if you want to dump all child decls. llvm-svn: 182544
2013-05-23 09:49:11 +08:00
RedeclarableResult VisitRecordDeclImpl(RecordDecl *RD);
void VisitRecordDecl(RecordDecl *RD) { VisitRecordDeclImpl(RD); }
RedeclarableResult VisitCXXRecordDeclImpl(CXXRecordDecl *D);
void VisitCXXRecordDecl(CXXRecordDecl *D) { VisitCXXRecordDeclImpl(D); }
RedeclarableResult VisitClassTemplateSpecializationDeclImpl(
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
ClassTemplateSpecializationDecl *D);
Fix bitcode desynchronization when loading a PCH containing a class template specialization with modules enabled. Just don't merge them at all for now; we'll revisit this when support for template merging is added. In passing, make Decl::dump() a little safer to use with PCH/modules, by making it not deserialize any additional declarations. From a debugger you can call decls_begin() or similar first if you want to dump all child decls. llvm-svn: 182544
2013-05-23 09:49:11 +08:00
void VisitClassTemplateSpecializationDecl(
ClassTemplateSpecializationDecl *D) {
VisitClassTemplateSpecializationDeclImpl(D);
}
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
void VisitClassTemplatePartialSpecializationDecl(
ClassTemplatePartialSpecializationDecl *D);
Serialize the new bits in CXXRecordDecl::DefinitionData. llvm-svn: 138855
2011-08-31 21:59:56 +08:00
void VisitClassScopeFunctionSpecializationDecl(
ClassScopeFunctionSpecializationDecl *D);
Started implementing variable templates. Top level declarations should be fully supported, up to some limitations documented as FIXMEs or TODO. Static data member templates work very partially. Static data member templates of class templates need particular attention... llvm-svn: 187762
2013-08-06 09:03:05 +08:00
RedeclarableResult
VisitVarTemplateSpecializationDeclImpl(VarTemplateSpecializationDecl *D);
void VisitVarTemplateSpecializationDecl(VarTemplateSpecializationDecl *D) {
VisitVarTemplateSpecializationDeclImpl(D);
}
void VisitVarTemplatePartialSpecializationDecl(
VarTemplatePartialSpecializationDecl *D);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
void VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
void VisitValueDecl(ValueDecl *VD);
void VisitEnumConstantDecl(EnumConstantDecl *ECD);
Fix PCH support for UnresolvedUsingTypenameDecl and UnresolvedUsingValueDecl. llvm-svn: 107268
2010-06-30 16:49:30 +08:00
void VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D);
Store/load type source info from/to PCH files. llvm-svn: 79396
2009-08-19 09:28:35 +08:00
void VisitDeclaratorDecl(DeclaratorDecl *DD);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
void VisitFunctionDecl(FunctionDecl *FD);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
void VisitCXXMethodDecl(CXXMethodDecl *D);
void VisitCXXConstructorDecl(CXXConstructorDecl *D);
void VisitCXXDestructorDecl(CXXDestructorDecl *D);
void VisitCXXConversionDecl(CXXConversionDecl *D);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
void VisitFieldDecl(FieldDecl *FD);
Basic support for Microsoft property declarations and references thereto. Patch by Tong Shen! llvm-svn: 179585
2013-04-16 15:28:30 +08:00
void VisitMSPropertyDecl(MSPropertyDecl *FD);
Major anonymous union/struct redesign. A new AST node is introduced: def IndirectField : DDecl<Value>; IndirectFields are injected into the anonymous's parent scope and chain back to the original field. Name lookup for anonymous entities now result in an IndirectFieldDecl instead of a FieldDecl. There is no functionality change, the code generated should be the same. llvm-svn: 119919
2010-11-21 14:08:52 +08:00
void VisitIndirectFieldDecl(IndirectFieldDecl *FD);
Started implementing variable templates. Top level declarations should be fully supported, up to some limitations documented as FIXMEs or TODO. Static data member templates work very partially. Static data member templates of class templates need particular attention... llvm-svn: 187762
2013-08-06 09:03:05 +08:00
RedeclarableResult VisitVarDeclImpl(VarDecl *D);
void VisitVarDecl(VarDecl *VD) { VisitVarDeclImpl(VD); }
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
void VisitImplicitParamDecl(ImplicitParamDecl *PD);
void VisitParmVarDecl(ParmVarDecl *PD);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
void VisitNonTypeTemplateParmDecl(NonTypeTemplateParmDecl *D);
When two templates get merged together, also merge their pattern declarations together. This is extremely hairy, because in general we need to have loaded both the template and the pattern before we can determine whether either should be merged, so we temporarily violate the rule that all merging happens before reading a decl ends, but *only* in the case where a template's pattern is being loaded while loading the template itself. In order to accomodate this for class templates, delay loading the injected class name type for the pattern of the template until after we've loaded the template itself, if we happen to load the template first. llvm-svn: 207063
2014-04-24 10:25:27 +08:00
DeclID VisitTemplateDecl(TemplateDecl *D);
During name lookup, use redecl_iterator to walk over the redeclaration chain to determine whether any declaration of the given entity is visible, eliminating the redundant (and less efficient) getPreviousDeclaration() implementation. This tweak uncovered an omission in the handling of RedeclarableTemplateDecl, where we weren't making sure to search for additional redeclarations of a template in other module files. Things would be cleaner if RedeclarableTemplateDecl actually used Redeclarable. llvm-svn: 147687
2012-01-07 06:05:37 +08:00
RedeclarableResult VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
void VisitClassTemplateDecl(ClassTemplateDecl *D);
[Sema] Implement __make_integer_seq This new builtin template allows for incredibly fast instantiations of templates like std::integer_sequence. Performance numbers follow: My work station has 64 GB of ram + 20 Xeon Cores at 2.8 GHz. __make_integer_seq<std::integer_sequence, int, 90000> takes 0.25 seconds. std::make_integer_sequence<int, 90000> takes unbound time, it is still running. Clang is consuming gigabytes of memory. Differential Revision: http://reviews.llvm.org/D13786 llvm-svn: 252036
2015-11-04 11:40:30 +08:00
void VisitBuiltinTemplateDecl(BuiltinTemplateDecl *D);
Started implementing variable templates. Top level declarations should be fully supported, up to some limitations documented as FIXMEs or TODO. Static data member templates work very partially. Static data member templates of class templates need particular attention... llvm-svn: 187762
2013-08-06 09:03:05 +08:00
void VisitVarTemplateDecl(VarTemplateDecl *D);
Support emitting/reading function templates to/from PCH. llvm-svn: 106534
2010-06-22 17:55:07 +08:00
void VisitFunctionTemplateDecl(FunctionTemplateDecl *D);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
void VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D);
Implement support for C++0x alias templates. llvm-svn: 130953
2011-05-06 05:57:07 +08:00
void VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D);
Support PCH emitting/reading of using declarations. llvm-svn: 106404
2010-06-20 22:40:59 +08:00
void VisitUsingDecl(UsingDecl *D);
void VisitUsingShadowDecl(UsingShadowDecl *D);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
void VisitLinkageSpecDecl(LinkageSpecDecl *D);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
void VisitFileScopeAsmDecl(FileScopeAsmDecl *AD);
Introduce a module import declaration, so that we properly represent, e.g., __import_module__ std.vector; in the AST. llvm-svn: 145725
2011-12-03 07:23:56 +08:00
void VisitImportDecl(ImportDecl *D);
Added AccessSpecDecl node. llvm-svn: 105525
2010-06-05 13:09:32 +08:00
void VisitAccessSpecDecl(AccessSpecDecl *D);
Support C++ friend declarations for PCH. This commit 'introduces' a slightly different way to restore the state of the AST object. It makes PCHDeclReader/PCHDeclWriter friends and gives them access to the private members of the object. The rationale is to avoid using/modifying the AST interfaces for PCH read/write so that to: -Avoid complications with objects that have side-effects during creation or when using some setters. -Not 'pollute' the AST interface with methods only used by the PCH reader/writer -Allow AST objects to be read-only. llvm-svn: 107219
2010-06-30 06:47:00 +08:00
void VisitFriendDecl(FriendDecl *D);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
void VisitFriendTemplateDecl(FriendTemplateDecl *D);
void VisitStaticAssertDecl(StaticAssertDecl *D);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
void VisitBlockDecl(BlockDecl *BD);
Sema for Captured Statements Add CapturedDecl to be the DeclContext for CapturedStmt, and perform semantic analysis. Currently captures all variables by reference. TODO: templates Author: Ben Langmuir <ben.langmuir@intel.com> Differential Revision: http://llvm-reviews.chandlerc.com/D433 llvm-svn: 179618
2013-04-17 03:37:38 +08:00
void VisitCapturedDecl(CapturedDecl *CD);
[Sema] Semantic analysis for empty-declaration and attribute-declaration. Introduce a new AST Decl node "EmptyDecl" to model empty-declaration. Have attributes from attribute-declaration appertain to the EmptyDecl node by creating the AST representations of these attributes and attach them to the EmptyDecl node so these attributes can be sema checked just as attributes attached to "normal" declarations. llvm-svn: 175900
2013-02-23 01:15:32 +08:00
void VisitEmptyDecl(EmptyDecl *D);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
std::pair<uint64_t, uint64_t> VisitDeclContext(DeclContext *DC);
When two templates get merged together, also merge their pattern declarations together. This is extremely hairy, because in general we need to have loaded both the template and the pattern before we can determine whether either should be merged, so we temporarily violate the rule that all merging happens before reading a decl ends, but *only* in the case where a template's pattern is being loaded while loading the template itself. In order to accomodate this for class templates, delay loading the injected class name type for the pattern of the template until after we've loaded the template itself, if we happen to load the template first. llvm-svn: 207063
2014-04-24 10:25:27 +08:00
template<typename T>
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
RedeclarableResult VisitRedeclarable(Redeclarable<T> *D);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
Factor the merging of declarations in the AST reader out to a separate member function template, since the behavior is identical for ObjCInterfaceDecl and ObjCProtocolDecl. It's expected that all redeclarable entities will have the same behavior. llvm-svn: 147450
2012-01-04 01:27:13 +08:00
template<typename T>
When two templates get merged together, also merge their pattern declarations together. This is extremely hairy, because in general we need to have loaded both the template and the pattern before we can determine whether either should be merged, so we temporarily violate the rule that all merging happens before reading a decl ends, but *only* in the case where a template's pattern is being loaded while loading the template itself. In order to accomodate this for class templates, delay loading the injected class name type for the pattern of the template until after we've loaded the template itself, if we happen to load the template first. llvm-svn: 207063
2014-04-24 10:25:27 +08:00
void mergeRedeclarable(Redeclarable<T> *D, RedeclarableResult &Redecl,
DeclID TemplatePatternID = 0);
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
template<typename T>
void mergeRedeclarable(Redeclarable<T> *D, T *Existing,
When two templates get merged together, also merge their pattern declarations together. This is extremely hairy, because in general we need to have loaded both the template and the pattern before we can determine whether either should be merged, so we temporarily violate the rule that all merging happens before reading a decl ends, but *only* in the case where a template's pattern is being loaded while loading the template itself. In order to accomodate this for class templates, delay loading the injected class name type for the pattern of the template until after we've loaded the template itself, if we happen to load the template first. llvm-svn: 207063
2014-04-24 10:25:27 +08:00
RedeclarableResult &Redecl,
DeclID TemplatePatternID = 0);
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
When merging class definitions across modules in C++, merge together fields. This change doesn't go all the way to making fields redeclarable; instead, it makes them 'mergeable', which means we can find the canonical declaration, but not much else (and for a declaration that's not from a module, the canonical declaration is always that declaration). llvm-svn: 192092
2013-10-07 16:02:11 +08:00
template<typename T>
void mergeMergeable(Mergeable<T> *D);
When two templates get merged together, also merge their pattern declarations together. This is extremely hairy, because in general we need to have loaded both the template and the pattern before we can determine whether either should be merged, so we temporarily violate the rule that all merging happens before reading a decl ends, but *only* in the case where a template's pattern is being loaded while loading the template itself. In order to accomodate this for class templates, delay loading the injected class name type for the pattern of the template until after we've loaded the template itself, if we happen to load the template first. llvm-svn: 207063
2014-04-24 10:25:27 +08:00
void mergeTemplatePattern(RedeclarableTemplateDecl *D,
RedeclarableTemplateDecl *Existing,
[modules] Improve performance when there is a local declaration of an entity before the first imported declaration. We don't need to track all formerly-canonical declarations of an entity; it's sufficient to track those ones for which no other formerly-canonical declaration was imported into the same module. We call those ones "key declarations", and use them as our starting points for collecting redeclarations and performing namespace lookups. llvm-svn: 241999
2015-07-13 07:43:21 +08:00
DeclID DsID, bool IsKeyDecl);
When two templates get merged together, also merge their pattern declarations together. This is extremely hairy, because in general we need to have loaded both the template and the pattern before we can determine whether either should be merged, so we temporarily violate the rule that all merging happens before reading a decl ends, but *only* in the case where a template's pattern is being loaded while loading the template itself. In order to accomodate this for class templates, delay loading the injected class name type for the pattern of the template until after we've loaded the template itself, if we happen to load the template first. llvm-svn: 207063
2014-04-24 10:25:27 +08:00
Parsing, semantic analysis, and AST for Objective-C type parameters. Produce type parameter declarations for Objective-C type parameters, and attach lists of type parameters to Objective-C classes, categories, forward declarations, and extensions as appropriate. Perform semantic analysis of type bounds for type parameters, both in isolation and across classes/categories/extensions to ensure consistency. Also handle (de-)serialization of Objective-C type parameter lists, along with sundry other things one must do to add a new declaration to Clang. Note that Objective-C type parameters are typedef name declarations, like typedefs and C++11 type aliases, in support of type erasure. Part of rdar://problem/6294649. llvm-svn: 241541
2015-07-07 11:57:15 +08:00
ObjCTypeParamList *ReadObjCTypeParamList();
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);
Parsing, semantic analysis, and AST for Objective-C type parameters. Produce type parameter declarations for Objective-C type parameters, and attach lists of type parameters to Objective-C classes, categories, forward declarations, and extensions as appropriate. Perform semantic analysis of type bounds for type parameters, both in isolation and across classes/categories/extensions to ensure consistency. Also handle (de-)serialization of Objective-C type parameter lists, along with sundry other things one must do to add a new declaration to Clang. Note that Objective-C type parameters are typedef name declarations, like typedefs and C++11 type aliases, in support of type erasure. Part of rdar://problem/6294649. llvm-svn: 241541
2015-07-07 11:57:15 +08:00
void VisitObjCTypeParamDecl(ObjCTypeParamDecl *D);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
void VisitObjCContainerDecl(ObjCContainerDecl *D);
void VisitObjCInterfaceDecl(ObjCInterfaceDecl *D);
void VisitObjCIvarDecl(ObjCIvarDecl *D);
void VisitObjCProtocolDecl(ObjCProtocolDecl *D);
void VisitObjCAtDefsFieldDecl(ObjCAtDefsFieldDecl *D);
void VisitObjCCategoryDecl(ObjCCategoryDecl *D);
void VisitObjCImplDecl(ObjCImplDecl *D);
void VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D);
void VisitObjCImplementationDecl(ObjCImplementationDecl *D);
void VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *D);
void VisitObjCPropertyDecl(ObjCPropertyDecl *D);
void VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D);
OpenMP threadprivate directive parsing and semantic analysis llvm-svn: 177705
2013-03-22 14:34:35 +08:00
void VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D);
[OPENMP 4.0] Initial support for 'omp declare reduction' construct. Add parsing, sema analysis and serialization/deserialization for 'declare reduction' construct. User-defined reductions are defined as #pragma omp declare reduction( reduction-identifier : typename-list : combiner ) [initializer ( initializer-expr )] These custom reductions may be used in 'reduction' clauses of OpenMP constructs. The combiner specifies how partial results can be combined into a single value. The combiner can use the special variable identifiers omp_in and omp_out that are of the type of the variables being reduced with this reduction-identifier. Each of them will denote one of the values to be combined before executing the combiner. It is assumed that the special omp_out identifier will refer to the storage that holds the resulting combined value after executing the combiner. As the initializer-expr value of a user-defined reduction is not known a priori the initializer-clause can be used to specify one. Then the contents of the initializer-clause will be used as the initializer for private copies of reduction list items where the omp_priv identifier will refer to the storage to be initialized. The special identifier omp_orig can also appear in the initializer-clause and it will refer to the storage of the original variable to be reduced. Differential Revision: http://reviews.llvm.org/D11182 llvm-svn: 262582
2016-03-03 13:21:39 +08:00
void VisitOMPDeclareReductionDecl(OMPDeclareReductionDecl *D);
[OPENMP] Rename OMPCapturedFieldDecl to OMPCapturedExprDecl, NFC. OMPCapturedExprDecl allows caopturing not only of fielddecls, but also other expressions. It also allows to simplify codegen for several clauses. llvm-svn: 260492
2016-02-11 13:35:55 +08:00
void VisitOMPCapturedExprDecl(OMPCapturedExprDecl *D);
[modules] Ensure that if we merge the definitions of two enumerations, that making either of them visible makes the merged definition visible. llvm-svn: 239969
2015-06-18 07:07:50 +08:00
/// We've merged the definition \p MergedDef into the existing definition
/// \p Def. Ensure that \p Def is made visible whenever \p MergedDef is made
/// visible.
void mergeDefinitionVisibility(NamedDecl *Def, NamedDecl *MergedDef) {
if (Def->isHidden()) {
// If MergedDef is visible or becomes visible, make the definition visible.
if (!MergedDef->isHidden())
Def->Hidden = false;
else if (Reader.getContext().getLangOpts().ModulesLocalVisibility) {
Reader.getContext().mergeDefinitionIntoModule(
Def, MergedDef->getImportedOwningModule(),
/*NotifyListeners*/ false);
Reader.PendingMergedDefinitionsToDeduplicate.insert(Def);
} else {
auto SubmoduleID = MergedDef->getOwningModuleID();
assert(SubmoduleID && "hidden definition in no module");
Reader.HiddenNamesMap[Reader.getSubmodule(SubmoduleID)].push_back(Def);
}
}
}
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
};
Fix Clang-tidy modernize-use-nullptr warnings in source directories; other minor cleanups Patch by Eugene Zelenko! Differential Revision: http://reviews.llvm.org/D13406 llvm-svn: 249484
2015-10-07 07:40:43 +08:00
} // end namespace clang
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
[modules] Merging support for enums with a local definition prior to the first imported definition. llvm-svn: 240068
2015-06-19 06:07:00 +08:00
namespace {
/// Iterator over the redeclarations of a declaration that have already
/// been merged into the same redeclaration chain.
template<typename DeclT>
class MergedRedeclIterator {
DeclT *Start, *Canonical, *Current;
public:
MergedRedeclIterator() : Current(nullptr) {}
MergedRedeclIterator(DeclT *Start)
: Start(Start), Canonical(nullptr), Current(Start) {}
DeclT *operator*() { return Current; }
MergedRedeclIterator &operator++() {
if (Current->isFirstDecl()) {
Canonical = Current;
Current = Current->getMostRecentDecl();
} else
Current = Current->getPreviousDecl();
// If we started in the merged portion, we'll reach our start position
// eventually. Otherwise, we'll never reach it, but the second declaration
// we reached was the canonical declaration, so stop when we see that one
// again.
if (Current == Start || Current == Canonical)
Current = nullptr;
return *this;
}
friend bool operator!=(const MergedRedeclIterator &A,
const MergedRedeclIterator &B) {
return A.Current != B.Current;
}
};
Fix Clang-tidy modernize-use-nullptr warnings in source directories; other minor cleanups Patch by Eugene Zelenko! Differential Revision: http://reviews.llvm.org/D13406 llvm-svn: 249484
2015-10-07 07:40:43 +08:00
} // end anonymous namespace
[modules] Merging support for enums with a local definition prior to the first imported definition. llvm-svn: 240068
2015-06-19 06:07:00 +08:00
template<typename DeclT>
llvm::iterator_range<MergedRedeclIterator<DeclT>> merged_redecls(DeclT *D) {
Use llvm::make_range to reduce mentions of iterator type. NFC llvm-svn: 254870
2015-12-06 13:07:12 +08:00
return llvm::make_range(MergedRedeclIterator<DeclT>(D),
MergedRedeclIterator<DeclT>());
[modules] Merging support for enums with a local definition prior to the first imported definition. llvm-svn: 240068
2015-06-19 06:07:00 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
uint64_t ASTDeclReader::GetCurrentCursorOffset() {
Introduce a global bit-offset continuous range map into the ASTReader, so that we have one, simple way to map from global bit offsets to local bit offsets. Eliminates a number of loops over the chain, and generalizes for more interesting bit remappings. Also, as an amusing oddity, we were computing global bit offsets *backwards* for preprocessed entities (e.g., the directly included PCH file in the chain would start at offset zero, rather than the original PCH that occurs first in translation unit). Even more amusingly, it made precompiled preambles work, because we were forgetting to adjust the local bit offset to a global bit offset when storing preprocessed entity offsets in the ASTUnit. Two wrongs made a right, and now they're both right. llvm-svn: 135750
2011-07-22 14:10:01 +08:00
return F.DeclsCursor.GetCurrentBitNo() + F.GlobalBitOffset;
Thread bitstream cursors all the way through the AST reading stuff. This way, reading a trivial 2-element chained file actually works. llvm-svn: 109191
2010-07-23 06:43:28 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::Visit(Decl *D) {
DeclVisitor<ASTDeclReader, void>::Visit(D);
Generally types expect an initialized TypeDecl; its safer and less complicated to delay PCH reading the type of a TypeDecl. llvm-svn: 107469
2010-07-02 19:55:01 +08:00
Improvements to abbreviations for PCH which add support for EnumDecl, ObjCIvarDecl, TypedefDecl, VarDecl and FieldDecl and improve support for ParmVarDecl. llvm-svn: 132604
2011-06-04 07:11:16 +08:00
if (DeclaratorDecl *DD = dyn_cast<DeclaratorDecl>(D)) {
if (DD->DeclInfo) {
DeclaratorDecl::ExtInfo *Info =
DD->DeclInfo.get<DeclaratorDecl::ExtInfo *>();
Info->TInfo =
GetTypeSourceInfo(Record, Idx);
}
else {
DD->DeclInfo = GetTypeSourceInfo(Record, Idx);
}
}
Handle CXXConstructorDecl, CXXDestructorDecl, and CXXConversionDecl for PCH. <vector> header can be used correctly through PCH now. llvm-svn: 107483
2010-07-02 23:58:43 +08:00
if (TypeDecl *TD = dyn_cast<TypeDecl>(D)) {
When two templates get merged together, also merge their pattern declarations together. This is extremely hairy, because in general we need to have loaded both the template and the pattern before we can determine whether either should be merged, so we temporarily violate the rule that all merging happens before reading a decl ends, but *only* in the case where a template's pattern is being loaded while loading the template itself. In order to accomodate this for class templates, delay loading the injected class name type for the pattern of the template until after we've loaded the template itself, if we happen to load the template first. llvm-svn: 207063
2014-04-24 10:25:27 +08:00
// We have a fully initialized TypeDecl. Read its type now.
Eliminate the branching in QualType::getTypePtr() by providing a common base for ExtQuals and Type that stores the underlying type pointer. This results in a 2% performance win for -emit-llvm on a typical C file, with 1% memory growth in the AST. Note that there is an API change in this optimization: QualType::getTypePtr() can no longer be invoked on a NULL QualType. If the QualType might be NULL, use QualType::getTypePtrOrNull(). I've audited all uses of getTypePtr() in the code base and changed the appropriate uses over to getTypePtrOrNull(). A future optimization opportunity would be to distinguish between cast/dyn_cast and cast_or_null/dyn_cast_or_null; for the former, we could use getTypePtr() rather than getTypePtrOrNull(), to take another branch out of the cast/dyn_cast implementation. llvm-svn: 121489
2010-12-11 01:03:06 +08:00
TD->setTypeForDecl(Reader.GetType(TypeIDForTypeDecl).getTypePtrOrNull());
[modules] Fix deserialization cycle when loading a tag declaration with a typedef name for linkage purposes. When loading the type, delay loading its typedef until we've finished loading and merging the type. In its place, save out the name of the typedef, which we need for merging purposes. llvm-svn: 216806
2014-08-30 08:04:23 +08:00
// If this is a tag declaration with a typedef name for linkage, it's safe
// to load that typedef now.
if (NamedDeclForTagDecl)
[MS ABI] Correctly mangle classes without names for linkage purposes A class without a name for linkage purposes gets a name along the lines of <unnamed-type-foo> where foo is either the name of a declarator which defined it (like a variable or field) or a typedef-name (like a typedef or alias-declaration). We handled the declarator case correctly but it would fall down during template instantiation if the declarator didn't share the tag's type. We failed to handle the typedef-name case at all. Instead, keep track of the association between the two and keep it up to date in the face of template instantiation. llvm-svn: 246469
2015-09-01 02:48:39 +08:00
cast<TagDecl>(D)->TypedefNameDeclOrQualifier =
cast<TypedefNameDecl>(Reader.GetDecl(NamedDeclForTagDecl));
Fix chaining of ObjCInterfaceDecl redeclarations llvm-svn: 146722
2011-12-16 11:12:41 +08:00
} else if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(D)) {
// if we have a fully initialized TypeDecl, we can safely read its type now.
ID->TypeForDecl = Reader.GetType(TypeIDForTypeDecl).getTypePtrOrNull();
Handle CXXConstructorDecl, CXXDestructorDecl, and CXXConversionDecl for PCH. <vector> header can be used correctly through PCH now. llvm-svn: 107483
2010-07-02 23:58:43 +08:00
} else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
// FunctionDecl's body was written last after all other Stmts/Exprs.
Revert most of the functionality in r165001. Instead, make sure that the ASTReader doesn't attach a body to a function that is already defined elsewhere. llvm-svn: 165137
2012-10-04 02:34:48 +08:00
// We only read it if FD doesn't already have a body (e.g., from another
// module).
Add some FIXMEs to the ASTReader code llvm-svn: 165138
2012-10-04 02:36:10 +08:00
// FIXME: Can we diagnose ODR violations somehow?
When we load a function or method body from an AST file, we check whether that function/method already has a body (loaded from some other AST file), as introduced in r165137. Delay this check until after the redeclaration chains have been wired up. While I'm here, make the loading of method bodies lazy. llvm-svn: 165513
2012-10-10 01:21:28 +08:00
if (Record[Idx++]) {
[modules] Deserialize CXXCtorInitializer list for a constructor lazily. Previously we'd deserialize the list of mem-initializers for a constructor when we deserialized the declaration of the constructor. That could trigger a significant amount of unnecessary work (pulling in all base classes recursively, for a start) and was causing problems for the modules buildbot due to cyclic deserializations. We now deserialize these on demand. This creates a certain amount of duplication with the handling of CXXBaseSpecifiers; I'll look into reducing that next. llvm-svn: 233052
2015-03-24 14:36:48 +08:00
if (auto *CD = dyn_cast<CXXConstructorDecl>(FD)) {
CD->NumCtorInitializers = Record[Idx++];
if (CD->NumCtorInitializers)
CD->CtorInitializers =
Reader.ReadCXXCtorInitializersRef(F, Record, Idx);
}
When we load a function or method body from an AST file, we check whether that function/method already has a body (loaded from some other AST file), as introduced in r165137. Delay this check until after the redeclaration chains have been wired up. While I'm here, make the loading of method bodies lazy. llvm-svn: 165513
2012-10-10 01:21:28 +08:00
Reader.PendingBodies[FD] = GetCurrentCursorOffset();
HasPendingBody = true;
}
Handle CXXConstructorDecl, CXXDestructorDecl, and CXXConversionDecl for PCH. <vector> header can be used correctly through PCH now. llvm-svn: 107483
2010-07-02 23:58:43 +08:00
}
Generally types expect an initialized TypeDecl; its safer and less complicated to delay PCH reading the type of a TypeDecl. llvm-svn: 107469
2010-07-02 19:55:01 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitDecl(Decl *D) {
PCH: fix a crash caused by a circular deserialization dependency We started by trying to deserialize decltype(func-param) in a trailing return type, which causes the function parameter decl to be deserialized, which pulls in the function decl, which pulls the function type, which pulls the same decltype() in the return type, and then we crashed. llvm-svn: 197644
2013-12-19 10:05:20 +08:00
if (D->isTemplateParameter() || D->isTemplateParameterPack() ||
isa<ParmVarDecl>(D)) {
When we're deserializing a template parameter declaration, temporarily use the translation unit as its declaration context, then deserialize the actual lexical and semantic DeclContexts after the template parameter is complete. This avoids problems when the DeclContext itself (e.g., a class template) is dependent on the template parameter (e.g., for the injected-class-name). llvm-svn: 127056
2011-03-05 09:35:54 +08:00
// We don't want to deserialize the DeclContext of a template
PCH: fix a crash caused by a circular deserialization dependency We started by trying to deserialize decltype(func-param) in a trailing return type, which causes the function parameter decl to be deserialized, which pulls in the function decl, which pulls the function type, which pulls the same decltype() in the return type, and then we crashed. llvm-svn: 197644
2013-12-19 10:05:20 +08:00
// parameter or of a parameter of a function template immediately. These
// entities might be used in the formulation of its DeclContext (for
// example, a function parameter can be used in decltype() in trailing
// return type of the function). Use the translation unit DeclContext as a
// placeholder.
[PCH] Deserializing the DeclContext of a template parameter is not safe until recursive loading is finished. Otherwise we may end up with a template trying to deserialize a template parameter that is in the process of getting loaded. rdar://13135282 llvm-svn: 175329
2013-02-16 08:48:59 +08:00
GlobalDeclID SemaDCIDForTemplateParmDecl = ReadDeclID(Record, Idx);
GlobalDeclID LexicalDCIDForTemplateParmDecl = ReadDeclID(Record, Idx);
[modules] If the semantic and lexical DC of a decl are the same, write out the second one as 0 instead of writing the same bits to the module file twice. This typically reduces PCM file size by about 1%. llvm-svn: 255384
2015-12-12 06:41:00 +08:00
if (!LexicalDCIDForTemplateParmDecl)
LexicalDCIDForTemplateParmDecl = SemaDCIDForTemplateParmDecl;
[PCH] Deserializing the DeclContext of a template parameter is not safe until recursive loading is finished. Otherwise we may end up with a template trying to deserialize a template parameter that is in the process of getting loaded. rdar://13135282 llvm-svn: 175329
2013-02-16 08:48:59 +08:00
Reader.addPendingDeclContextInfo(D,
SemaDCIDForTemplateParmDecl,
LexicalDCIDForTemplateParmDecl);
In ASTReader, replace the never-NULL ASTContext pointer with an ASTContext reference. Remove all of the extra checking and logic that was used to cope with a NULL ASTContext. No effective functionality change. llvm-svn: 139413
2011-09-10 05:34:22 +08:00
D->setDeclContext(Reader.getContext().getTranslationUnitDecl());
When we're deserializing a template parameter declaration, temporarily use the translation unit as its declaration context, then deserialize the actual lexical and semantic DeclContexts after the template parameter is complete. This avoids problems when the DeclContext itself (e.g., a class template) is dependent on the template parameter (e.g., for the injected-class-name). llvm-svn: 127056
2011-03-05 09:35:54 +08:00
} else {
[PCH] Avoid using Decl::setAttrs() and Decl::setLexicalDeclContext() from the ASTReaderDecl directly; they internally call Decl::getASTContext() which may crash if a declaration context parent is still deserializing. llvm-svn: 150137
2012-02-09 10:44:08 +08:00
DeclContext *SemaDC = ReadDeclAs<DeclContext>(Record, Idx);
DeclContext *LexicalDC = ReadDeclAs<DeclContext>(Record, Idx);
[modules] If the semantic and lexical DC of a decl are the same, write out the second one as 0 instead of writing the same bits to the module file twice. This typically reduces PCM file size by about 1%. llvm-svn: 255384
2015-12-12 06:41:00 +08:00
if (!LexicalDC)
LexicalDC = SemaDC;
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
DeclContext *MergedSemaDC = Reader.MergedDeclContexts.lookup(SemaDC);
[PCH] Add some comments, per Ted's request. llvm-svn: 150162
2012-02-09 15:46:54 +08:00
// Avoid calling setLexicalDeclContext() directly because it uses
// Decl::getASTContext() internally which is unsafe during derialization.
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
D->setDeclContextsImpl(MergedSemaDC ? MergedSemaDC : SemaDC, LexicalDC,
Reader.getContext());
When we're deserializing a template parameter declaration, temporarily use the translation unit as its declaration context, then deserialize the actual lexical and semantic DeclContexts after the template parameter is complete. This avoids problems when the DeclContext itself (e.g., a class template) is dependent on the template parameter (e.g., for the injected-class-name). llvm-svn: 127056
2011-03-05 09:35:54 +08:00
}
[PCH] Pull the location out of the serialized declarations and put it in the array of decl bit offsets. This allows us to easily get at the location of a decl without deserializing it. It increases size of Cocoa PCH by only 0.2%. llvm-svn: 143123
2011-10-28 02:47:35 +08:00
D->setLocation(Reader.ReadSourceLocation(F, RawLocation));
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
D->setInvalidDecl(Record[Idx++]);
Read/write declaration attributes from/to PCH properly. Embed them in the declaration block instead of trying to create another block. The new block was messing with the assumption that after decls block comes the stmts block. Fixes http://llvm.org/PR8406 llvm-svn: 116737
2010-10-19 03:20:11 +08:00
if (Record[Idx++]) { // hasAttrs
Generate Attr subclasses with TableGen. Now all classes derived from Attr are generated from TableGen. Additionally, Attr* is no longer its own linked list; SmallVectors or Attr* are used. The accompanying LLVM commit contains the updates to TableGen necessary for this. Some other notes about newly-generated attribute classes: - The constructor arguments are a SourceLocation and a Context&, followed by the attributes arguments in the order that they were defined in Attr.td - Every argument in Attr.td has an appropriate accessor named getFoo, and there are sometimes a few extra ones (such as to get the length of a variadic argument). Additionally, specific_attr_iterator has been introduced, which will iterate over an AttrVec, but only over attributes of a certain type. It can be accessed through either Decl::specific_attr_begin/end or the global functions of the same name. llvm-svn: 111455
2010-08-19 07:23:40 +08:00
AttrVec Attrs;
Read/write declaration attributes from/to PCH properly. Embed them in the declaration block instead of trying to create another block. The new block was messing with the assumption that after decls block comes the stmts block. Fixes http://llvm.org/PR8406 llvm-svn: 116737
2010-10-19 03:20:11 +08:00
Reader.ReadAttributes(F, Attrs, Record, Idx);
[PCH] Add some comments, per Ted's request. llvm-svn: 150162
2012-02-09 15:46:54 +08:00
// Avoid calling setAttrs() directly because it uses Decl::getASTContext()
// internally which is unsafe during derialization.
[PCH] Avoid using Decl::setAttrs() and Decl::setLexicalDeclContext() from the ASTReaderDecl directly; they internally call Decl::getASTContext() which may crash if a declaration context parent is still deserializing. llvm-svn: 150137
2012-02-09 10:44:08 +08:00
D->setAttrsImpl(Attrs, Reader.getContext());
Generate Attr subclasses with TableGen. Now all classes derived from Attr are generated from TableGen. Additionally, Attr* is no longer its own linked list; SmallVectors or Attr* are used. The accompanying LLVM commit contains the updates to TableGen necessary for this. Some other notes about newly-generated attribute classes: - The constructor arguments are a SourceLocation and a Context&, followed by the attributes arguments in the order that they were defined in Attr.td - Every argument in Attr.td has an appropriate accessor named getFoo, and there are sometimes a few extra ones (such as to get the length of a variadic argument). Additionally, specific_attr_iterator has been introduced, which will iterate over an AttrVec, but only over attributes of a certain type. It can be accessed through either Decl::specific_attr_begin/end or the global functions of the same name. llvm-svn: 111455
2010-08-19 07:23:40 +08:00
}
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
D->setImplicit(Record[Idx++]);
A decl never becomes unused. Make that explicit in the API. llvm-svn: 193248
2013-10-24 00:46:34 +08:00
D->Used = Record[Idx++];
We regard a function as 'unused' from the codegen perspective, so our warnings diverge from gcc's unused warnings which don't get emitted if the function is referenced even in an unevaluated context (e.g. in templates, sizeof, etc.). Also, saying that a function is 'unused' because it won't get codegen'ed is somewhat misleading. - Don't emit 'unused' warnings for functions that are referenced in any part of the user's code. - A warning that an internal function/variable won't get emitted is useful though, so introduce -Wunneeded-internal-declaration which will warn if a function/variable with internal linkage is not "needed" ('used' from the codegen perspective), e.g: static void foo() { } template <int> void bar() { foo(); } test.cpp:1:13: warning: function 'foo' is not needed and will not be emitted static void foo() { } ^ Addresses rdar://8733476. llvm-svn: 129794
2011-04-20 03:51:10 +08:00
D->setReferenced(Record[Idx++]);
Stash Decl's TopLevelDeclInObjCContainer and ModulePrivate bits into the two unused lower bits of the NextDeclInContext link, dropping the number of bits in Decl down to 32, and saving 8 bytes per declaration on x86-64. llvm-svn: 147660
2012-01-07 00:59:53 +08:00
D->setTopLevelDeclInObjCContainer(Record[Idx++]);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
D->setAccess((AccessSpecifier)Record[Idx++]);
Kill of the Decl::PCHLevel field entirely. We now only need to know whether a Decl was deserialized from an AST file (any AST file). llvm-svn: 139438
2011-09-10 08:09:20 +08:00
D->FromASTFile = true;
Stash Decl's TopLevelDeclInObjCContainer and ModulePrivate bits into the two unused lower bits of the NextDeclInContext link, dropping the number of bits in Decl down to 32, and saving 8 bytes per declaration on x86-64. llvm-svn: 147660
2012-01-07 00:59:53 +08:00
D->setModulePrivate(Record[Idx++]);
D->Hidden = D->isModulePrivate();
[modules] Add local submodule visibility support for declarations. With this change, enabling -fmodules-local-submodule-visibility results in name visibility rules being applied to submodules of the current module in addition to imported modules (that is, names no longer "leak" between submodules of the same top-level module). This also makes it much safer to textually include a non-modular library into a module: each submodule that textually includes that library will get its own "copy" of that library, and so the library becomes visible no matter which including submodule you import. llvm-svn: 237473
2015-05-16 04:05:43 +08:00
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);
[modules] Add local submodule visibility support for declarations. With this change, enabling -fmodules-local-submodule-visibility results in name visibility rules being applied to submodules of the current module in addition to imported modules (that is, names no longer "leak" between submodules of the same top-level module). This also makes it much safer to textually include a non-modular library into a module: each submodule that textually includes that library will get its own "copy" of that library, and so the library becomes visible no matter which including submodule you import. llvm-svn: 237473
2015-05-16 04:05:43 +08:00
if (D->Hidden) {
// Module-private declarations are never visible, so there is no work to do.
} else if (Reader.getContext().getLangOpts().ModulesLocalVisibility) {
// If local visibility is being tracked, this declaration will become
// hidden and visible as the owning module does. Inform Sema that this
// declaration might not be visible.
D->Hidden = true;
} else if (Module *Owner = Reader.getSubmodule(SubmoduleID)) {
if (Owner->NameVisibility != Module::AllVisible) {
// The owning module is not visible. Mark this declaration as hidden.
D->Hidden = true;
// Note that this declaration was hidden because its owning module is
// not yet visible.
Reader.HiddenNamesMap[Owner].push_back(D);
Implement name hiding for declarations deserialized from a non-visible module. When that module becomes visible, so do those declarations. llvm-svn: 145640
2011-12-02 06:20:10 +08:00
}
}
}
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Serialize `#pragma comment`. `#pragma comment` was handled by Sema calling a function on ASTConsumer, and CodeGen then implementing this function and writing things to its output. Instead, introduce a PragmaCommentDecl AST node and hang one off the TranslationUnitDecl for every `#pragma comment` line, and then use the regular serialization machinery. (Since PragmaCommentDecl has codegen relevance, it's eagerly deserialized.) http://reviews.llvm.org/D17799 llvm-svn: 262493
2016-03-03 01:28:48 +08:00
void ASTDeclReader::VisitPragmaCommentDecl(PragmaCommentDecl *D) {
VisitDecl(D);
D->setLocation(ReadSourceLocation(Record, Idx));
D->CommentKind = (PragmaMSCommentKind)Record[Idx++];
std::string Arg = ReadString(Record, Idx);
memcpy(D->getTrailingObjects<char>(), Arg.data(), Arg.size());
D->getTrailingObjects<char>()[Arg.size()] = '\0';
}
Serialize `#pragma detect_mismatch`. This is like r262493, but for pragma detect_mismatch instead of pragma comment. The two pragmas have similar behavior, so use the same approach for both. llvm-svn: 262506
2016-03-03 03:28:54 +08:00
void ASTDeclReader::VisitPragmaDetectMismatchDecl(PragmaDetectMismatchDecl *D) {
VisitDecl(D);
D->setLocation(ReadSourceLocation(Record, Idx));
std::string Name = ReadString(Record, Idx);
memcpy(D->getTrailingObjects<char>(), Name.data(), Name.size());
D->getTrailingObjects<char>()[Name.size()] = '\0';
D->ValueStart = Name.size() + 1;
std::string Value = ReadString(Record, Idx);
memcpy(D->getTrailingObjects<char>() + D->ValueStart, Value.data(),
Value.size());
D->getTrailingObjects<char>()[D->ValueStart + Value.size()] = '\0';
}
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));
[modules] Treat friend declarations that are lexically within a dependent context as anonymous for merging purposes. They can't be found by their names, so we merge them based on their position within the surrounding context. llvm-svn: 228485
2015-02-07 11:11:11 +08:00
AnonymousDeclNumber = 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
}
[modules] Track the described template in an alias declaration that is the pattern of an alias template declaration. Use this to merge alias templates properly when they're members of class template specializations. llvm-svn: 216437
2014-08-26 11:52:16 +08:00
ASTDeclReader::RedeclarableResult
ASTDeclReader::VisitTypedefNameDecl(TypedefNameDecl *TD) {
Implement declaration merging for typedefs loaded from disjoint modules, so long as the typedefs refer to the same underlying type. This ensures that the typedefs end up in the same redeclaration chain. To test this, fix name lookup for C/Objective-C to properly deal with multiple declarations with the same name in the same scope. llvm-svn: 147533
2012-01-05 00:44:10 +08:00
RedeclarableResult Redecl = VisitRedeclarable(TD);
Generally types expect an initialized TypeDecl; its safer and less complicated to delay PCH reading the type of a TypeDecl. llvm-svn: 107469
2010-07-02 19:55:01 +08:00
VisitTypeDecl(TD);
Improved source code fidelity for gcc mode attribute. llvm-svn: 184417
2013-06-20 20:46:19 +08:00
TypeSourceInfo *TInfo = GetTypeSourceInfo(Record, Idx);
if (Record[Idx++]) { // isModed
QualType modedT = Reader.readType(F, Record, Idx);
TD->setModedTypeSourceInfo(TInfo, modedT);
} else
TD->setTypeSourceInfo(TInfo);
[modules] Track the described template in an alias declaration that is the pattern of an alias template declaration. Use this to merge alias templates properly when they're members of class template specializations. llvm-svn: 216437
2014-08-26 11:52:16 +08:00
return 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) {
[modules] Track the described template in an alias declaration that is the pattern of an alias template declaration. Use this to merge alias templates properly when they're members of class template specializations. llvm-svn: 216437
2014-08-26 11:52:16 +08:00
RedeclarableResult Redecl = VisitTypedefNameDecl(TD);
mergeRedeclarable(TD, Redecl);
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) {
[modules] Track the described template in an alias declaration that is the pattern of an alias template declaration. Use this to merge alias templates properly when they're members of class template specializations. llvm-svn: 216437
2014-08-26 11:52:16 +08:00
RedeclarableResult Redecl = VisitTypedefNameDecl(TD);
if (auto *Template = ReadDeclAs<TypeAliasTemplateDecl>(Record, Idx))
// Merged when we merge the template.
TD->setDescribedAliasTemplate(Template);
else
mergeRedeclarable(TD, Redecl);
Support for C++11 (non-template) alias declarations. llvm-svn: 129567
2011-04-15 22:24:37 +08:00
}
Fix bitcode desynchronization when loading a PCH containing a class template specialization with modules enabled. Just don't merge them at all for now; we'll revisit this when support for template merging is added. In passing, make Decl::dump() a little safer to use with PCH/modules, by making it not deserialize any additional declarations. From a debugger you can call decls_begin() or similar first if you want to dump all child decls. llvm-svn: 182544
2013-05-23 09:49:11 +08:00
ASTDeclReader::RedeclarableResult ASTDeclReader::VisitTagDecl(TagDecl *TD) {
Implement cross-module declaration merging for tag declarations, so that if two modules A and B both contain a declaration of a tag such as struct X; and those two modules are unrelated, the two declarations of X will be merged into a single redeclaration chain. llvm-svn: 147488
2012-01-04 06:46:00 +08:00
RedeclarableResult Redecl = VisitRedeclarable(TD);
Eliminate a hang while loading a sequence of redeclarable entities. In essence, the redeclaration chain for a class could end up in an inconsistent state while deserializing multiple declarations in that chain, where the circular linked list was not, in fact, circular. Since only two redeclarations of the same entity will get loaded when we're in this state, restore circularity when both have been loaded. Fixes <rdar://problem/10324940> / PR11195. llvm-svn: 143037
2011-10-27 01:53:41 +08:00
VisitTypeDecl(TD);
Implement cross-module declaration merging for tag declarations, so that if two modules A and B both contain a declaration of a tag such as struct X; and those two modules are unrelated, the two declarations of X will be merged into a single redeclaration chain. llvm-svn: 147488
2012-01-04 06:46:00 +08:00
Fix C++ PCH issues. PCH got a severe beating by the boost-using test case reported here: http://llvm.org/PR8099 Fix issues like: -When PCH reading, make sure Decl's getASTContext() doesn't get called since a Decl in the parent hierarchy may be initializing. -In ASTDeclReader::VisitFunctionDecl VisitRedeclarable should be called before using FunctionDecl's isCanonicalDecl() -In ASTDeclReader::VisitRedeclarableTemplateDecl CommonOrPrev must be initialized before anything else. llvm-svn: 113391
2010-09-09 03:31:22 +08:00
TD->IdentifierNamespace = Record[Idx++];
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
TD->setTagKind((TagDecl::TagKind)Record[Idx++]);
[modules] Add an assert that we properly manage the IsCompleteDefinition flag on CXXRecordDecls when merging definitions, and make it pass by not trying to save and restore this flag across AST serialization/deserialization. For CXXRecordDecls, we have a separate mechanism to manage this. llvm-svn: 216633
2014-08-28 07:11:59 +08:00
if (!isa<CXXRecordDecl>(TD))
TD->setCompleteDefinition(Record[Idx++]);
Improve representation of tag declarations first declared or defined within the declarator of another declaration, from Enea Zaffanella! llvm-svn: 95991
2010-02-13 01:40:34 +08:00
TD->setEmbeddedInDeclarator(Record[Idx++]);
Mark a TagDecl when it is free standing (e.g. "struct foo;") llvm-svn: 140894
2011-10-01 06:11:31 +08:00
TD->setFreeStanding(Record[Idx++]);
Serialization support for TagDecl::IsCompleteDefinitionRequired Requested by Richard Smith in post-commit review of r186262 llvm-svn: 186266
2013-07-14 09:07:41 +08:00
TD->setCompleteDefinitionRequired(Record[Idx++]);
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
TD->setRBraceLoc(ReadSourceLocation(Record, Idx));
Implement cross-module declaration merging for tag declarations, so that if two modules A and B both contain a declaration of a tag such as struct X; and those two modules are unrelated, the two declarations of X will be merged into a single redeclaration chain. llvm-svn: 147488
2012-01-04 06:46:00 +08:00
[modules] Fix deserialization cycle when loading a tag declaration with a typedef name for linkage purposes. When loading the type, delay loading its typedef until we've finished loading and merging the type. In its place, save out the name of the typedef, which we need for merging purposes. llvm-svn: 216806
2014-08-30 08:04:23 +08:00
switch (Record[Idx++]) {
case 0:
break;
case 1: { // ExtInfo
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);
[MS ABI] Correctly mangle classes without names for linkage purposes A class without a name for linkage purposes gets a name along the lines of <unnamed-type-foo> where foo is either the name of a declarator which defined it (like a variable or field) or a typedef-name (like a typedef or alias-declaration). We handled the declarator case correctly but it would fall down during template instantiation if the declarator didn't share the tag's type. We failed to handle the typedef-name case at all. Instead, keep track of the association between the two and keep it up to date in the face of template instantiation. llvm-svn: 246469
2015-09-01 02:48:39 +08:00
TD->TypedefNameDeclOrQualifier = Info;
[modules] Fix deserialization cycle when loading a tag declaration with a typedef name for linkage purposes. When loading the type, delay loading its typedef until we've finished loading and merging the type. In its place, save out the name of the typedef, which we need for merging purposes. llvm-svn: 216806
2014-08-30 08:04:23 +08:00
break;
}
case 2: // TypedefNameForAnonDecl
NamedDeclForTagDecl = ReadDeclID(Record, Idx);
TypedefNameForLinkage = Reader.GetIdentifierInfo(F, Record, Idx);
break;
default:
llvm_unreachable("unexpected tag info kind");
}
Implement cross-module declaration merging for tag declarations, so that if two modules A and B both contain a declaration of a tag such as struct X; and those two modules are unrelated, the two declarations of X will be merged into a single redeclaration chain. llvm-svn: 147488
2012-01-04 06:46:00 +08:00
When a module completes the definition of a class template specialization imported from another module, emit an update record, rather than using the broken decl rewriting mechanism. If multiple modules do this, merge the definitions together, much as we would if they were separate declarations. llvm-svn: 206680
2014-04-19 11:48:30 +08:00
if (!isa<CXXRecordDecl>(TD))
mergeRedeclarable(TD, Redecl);
Fix bitcode desynchronization when loading a PCH containing a class template specialization with modules enabled. Just don't merge them at all for now; we'll revisit this when support for template merging is added. In passing, make Decl::dump() a little safer to use with PCH/modules, by making it not deserialize any additional declarations. From a debugger you can call decls_begin() or similar first if you want to dump all child decls. llvm-svn: 182544
2013-05-23 09:49:11 +08:00
return Redecl;
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitEnumDecl(EnumDecl *ED) {
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
VisitTagDecl(ED);
Implement C++0x scoped enumerations, from Daniel Wallin! (and tweaked a bit by me). llvm-svn: 116122
2010-10-09 07:50:27 +08:00
if (TypeSourceInfo *TI = Reader.GetTypeSourceInfo(F, Record, Idx))
ED->setIntegerTypeSourceInfo(TI);
else
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
ED->setIntegerType(Reader.readType(F, Record, Idx));
ED->setPromotionType(Reader.readType(F, Record, Idx));
Remember the number of positive and negative bits used by the enumerators of an enum in the enum decl itself. Use some spare bits from TagDecl for this purpose. llvm-svn: 103173
2010-05-06 16:49:23 +08:00
ED->setNumPositiveBits(Record[Idx++]);
ED->setNumNegativeBits(Record[Idx++]);
Implement C++0x scoped enumerations, from Daniel Wallin! (and tweaked a bit by me). llvm-svn: 116122
2010-10-09 07:50:27 +08:00
ED->IsScoped = Record[Idx++];
Added struct/class syntactic info for c++0x scoped enum. llvm-svn: 120828
2010-12-04 02:54:17 +08:00
ED->IsScopedUsingClassTag = Record[Idx++];
Implement C++0x scoped enumerations, from Daniel Wallin! (and tweaked a bit by me). llvm-svn: 116122
2010-10-09 07:50:27 +08:00
ED->IsFixed = Record[Idx++];
Instantiating a class template should not instantiate the definition of any scoped enumeration members. Later uses of an enumeration temploid as a nested name specifier should cause its instantiation. Plus some groundwork for explicit specialization of member enumerations of class templates. llvm-svn: 152750
2012-03-15 07:13:10 +08:00
C++ modules: merging for enumerations and enumerators with multiple definitions (eg through template instantiations in multiple modules). llvm-svn: 192740
2013-10-16 06:02:41 +08:00
// If this is a definition subject to the ODR, and we already have a
// definition, merge this one into it.
if (ED->IsCompleteDefinition &&
Reader.getContext().getLangOpts().Modules &&
Reader.getContext().getLangOpts().CPlusPlus) {
[modules] Merging support for enums with a local definition prior to the first imported definition. llvm-svn: 240068
2015-06-19 06:07:00 +08:00
EnumDecl *&OldDef = Reader.EnumDefinitions[ED->getCanonicalDecl()];
if (!OldDef) {
// This is the first time we've seen an imported definition. Look for a
// local definition before deciding that we are the first definition.
for (auto *D : merged_redecls(ED->getCanonicalDecl())) {
if (!D->isFromASTFile() && D->isCompleteDefinition()) {
OldDef = D;
break;
}
}
}
if (OldDef) {
C++ modules: merging for enumerations and enumerators with multiple definitions (eg through template instantiations in multiple modules). llvm-svn: 192740
2013-10-16 06:02:41 +08:00
Reader.MergedDeclContexts.insert(std::make_pair(ED, OldDef));
ED->IsCompleteDefinition = false;
[modules] Ensure that if we merge the definitions of two enumerations, that making either of them visible makes the merged definition visible. llvm-svn: 239969
2015-06-18 07:07:50 +08:00
mergeDefinitionVisibility(OldDef, ED);
C++ modules: merging for enumerations and enumerators with multiple definitions (eg through template instantiations in multiple modules). llvm-svn: 192740
2013-10-16 06:02:41 +08:00
} else {
OldDef = ED;
}
}
Instantiating a class template should not instantiate the definition of any scoped enumeration members. Later uses of an enumeration temploid as a nested name specifier should cause its instantiation. Plus some groundwork for explicit specialization of member enumerations of class templates. llvm-svn: 152750
2012-03-15 07:13:10 +08:00
if (EnumDecl *InstED = ReadDeclAs<EnumDecl>(Record, Idx)) {
TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
SourceLocation POI = ReadSourceLocation(Record, Idx);
ED->setInstantiationOfMemberEnum(Reader.getContext(), InstED, TSK);
ED->getMemberSpecializationInfo()->setPointOfInstantiation(POI);
}
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Fix bitcode desynchronization when loading a PCH containing a class template specialization with modules enabled. Just don't merge them at all for now; we'll revisit this when support for template merging is added. In passing, make Decl::dump() a little safer to use with PCH/modules, by making it not deserialize any additional declarations. From a debugger you can call decls_begin() or similar first if you want to dump all child decls. llvm-svn: 182544
2013-05-23 09:49:11 +08:00
ASTDeclReader::RedeclarableResult
ASTDeclReader::VisitRecordDeclImpl(RecordDecl *RD) {
RedeclarableResult Redecl = VisitTagDecl(RD);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
RD->setHasFlexibleArrayMember(Record[Idx++]);
RD->setAnonymousStructOrUnion(Record[Idx++]);
Patch adds test to my previous patch for assigning to gc'able structs in the Next runtime and adds missing PCH info. llvm-svn: 75014
2009-07-09 00:37:44 +08:00
RD->setHasObjectMember(Record[Idx++]);
patch for PR9027 and // rdar://11861085 Title: [PR9027] volatile struct bug: member is not loaded at -O; This is caused by last flag passed to @llvm.memcpy being false, not honoring that aggregate has at least one 'volatile' data member (even though aggregate itself has not been qualified as 'volatile'. As a result, optimization optimizes away the memcpy altogether. Patch review by John MaCall (I still need to fix up a test though). llvm-svn: 173535
2013-01-26 07:57:05 +08:00
RD->setHasVolatileMember(Record[Idx++]);
Fix bitcode desynchronization when loading a PCH containing a class template specialization with modules enabled. Just don't merge them at all for now; we'll revisit this when support for template merging is added. In passing, make Decl::dump() a little safer to use with PCH/modules, by making it not deserialize any additional declarations. From a debugger you can call decls_begin() or similar first if you want to dump all child decls. llvm-svn: 182544
2013-05-23 09:49:11 +08:00
return Redecl;
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitValueDecl(ValueDecl *VD) {
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
VisitNamedDecl(VD);
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
VD->setType(Reader.readType(F, Record, Idx));
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitEnumConstantDecl(EnumConstantDecl *ECD) {
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
VisitValueDecl(ECD);
if (Record[Idx++])
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
ECD->setInitExpr(Reader.ReadExpr(F));
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
ECD->setInitVal(Reader.ReadAPSInt(Record, Idx));
C++ modules: merging for enumerations and enumerators with multiple definitions (eg through template instantiations in multiple modules). llvm-svn: 192740
2013-10-16 06:02:41 +08:00
mergeMergeable(ECD);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitDeclaratorDecl(DeclaratorDecl *DD) {
Store/load type source info from/to PCH files. llvm-svn: 79396
2009-08-19 09:28:35 +08:00
VisitValueDecl(DD);
Fixed source range for all DeclaratorDecl's. llvm-svn: 127225
2011-03-08 16:55:46 +08:00
DD->setInnerLocStart(ReadSourceLocation(Record, Idx));
Read/write to/from PCH DeclarationNameLocs, DeclarationNameInfos and QualifierInfos (rdar://8513756). llvm-svn: 116598
2010-10-16 02:21:24 +08:00
if (Record[Idx++]) { // hasExtInfo
DeclaratorDecl::ExtInfo *Info
In ASTReader, replace the never-NULL ASTContext pointer with an ASTContext reference. Remove all of the extra checking and logic that was used to cope with a NULL ASTContext. No effective functionality change. llvm-svn: 139413
2011-09-10 05:34:22 +08:00
= new (Reader.getContext()) DeclaratorDecl::ExtInfo();
Read/write to/from PCH DeclarationNameLocs, DeclarationNameInfos and QualifierInfos (rdar://8513756). llvm-svn: 116598
2010-10-16 02:21:24 +08:00
ReadQualifierInfo(*Info, Record, Idx);
DD->DeclInfo = Info;
Improvements to abbreviations for PCH which add support for EnumDecl, ObjCIvarDecl, TypedefDecl, VarDecl and FieldDecl and improve support for ParmVarDecl. llvm-svn: 132604
2011-06-04 07:11:16 +08:00
}
Store/load type source info from/to PCH files. llvm-svn: 79396
2009-08-19 09:28:35 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitFunctionDecl(FunctionDecl *FD) {
Implement declaration merging for non-template functions from different modules. This implementation is a first approximation of what we want, using only the function type to determine equivalence. Later, we'll want to deal with some of the more subtle issues, including: - C allows a prototyped declaration and a non-prototyped declaration to be merged, which we should support - We may want to ignore the return type when merging, then complain if the return types differ. Or, we may want to leave it as it us, so that we only complain if overload resolution eventually fails. - C++ non-static member functions need to consider cv-qualifiers and ref-qualifiers. - Function templates need to consider the template parameters and return type. - Function template specializations will have special rules. - We can now (accidentally!) end up overloading in C, even without the "overloadable" attribute, and will need to detect this at some point. The actual detection of "is this an overload?" is implemented by Sema::IsOverload(), which will need to be moved into the AST library for re-use here. That will be a future refactor. llvm-svn: 147534
2012-01-05 01:13:46 +08:00
RedeclarableResult Redecl = VisitRedeclarable(FD);
Eliminate a hang while loading a sequence of redeclarable entities. In essence, the redeclaration chain for a class could end up in an inconsistent state while deserializing multiple declarations in that chain, where the circular linked list was not, in fact, circular. Since only two redeclarations of the same entity will get loaded when we're in this state, restore circularity when both have been loaded. Fixes <rdar://problem/10324940> / PR11195. llvm-svn: 143037
2011-10-27 01:53:41 +08:00
VisitDeclaratorDecl(FD);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
Read/write to/from PCH DeclarationNameLocs, DeclarationNameInfos and QualifierInfos (rdar://8513756). llvm-svn: 116598
2010-10-16 02:21:24 +08:00
ReadDeclarationNameLoc(FD->DNLoc, FD->getDeclName(), Record, Idx);
Read/write the identifier namespace in PCH for decls that may modify it. We can now use a PCH'ed <map>. llvm-svn: 107617
2010-07-05 18:38:01 +08:00
FD->IdentifierNamespace = Record[Idx++];
Implement declaration merging for non-template functions from different modules. This implementation is a first approximation of what we want, using only the function type to determine equivalence. Later, we'll want to deal with some of the more subtle issues, including: - C allows a prototyped declaration and a non-prototyped declaration to be merged, which we should support - We may want to ignore the return type when merging, then complain if the return types differ. Or, we may want to leave it as it us, so that we only complain if overload resolution eventually fails. - C++ non-static member functions need to consider cv-qualifiers and ref-qualifiers. - Function templates need to consider the template parameters and return type. - Function template specializations will have special rules. - We can now (accidentally!) end up overloading in C, even without the "overloadable" attribute, and will need to detect this at some point. The actual detection of "is this an overload?" is implemented by Sema::IsOverload(), which will need to be moved into the AST library for re-use here. That will be a future refactor. llvm-svn: 147534
2012-01-05 01:13:46 +08:00
// FunctionDecl's body is handled last at ASTDeclReader::Visit,
// after everything else is read.
Add 178663 back. http://lab.llvm.org:8011/builders/clang-x86_64-darwin10-gdb went back green before it processed the reverted 178663, so it could not have been the culprit. Revert "Revert 178663." This reverts commit 4f8a3eb2ce5d4ba422483439e20c8cbb4d953a41. llvm-svn: 178682
2013-04-04 03:27:57 +08:00
Implement declaration merging for non-template functions from different modules. This implementation is a first approximation of what we want, using only the function type to determine equivalence. Later, we'll want to deal with some of the more subtle issues, including: - C allows a prototyped declaration and a non-prototyped declaration to be merged, which we should support - We may want to ignore the return type when merging, then complain if the return types differ. Or, we may want to leave it as it us, so that we only complain if overload resolution eventually fails. - C++ non-static member functions need to consider cv-qualifiers and ref-qualifiers. - Function templates need to consider the template parameters and return type. - Function template specializations will have special rules. - We can now (accidentally!) end up overloading in C, even without the "overloadable" attribute, and will need to detect this at some point. The actual detection of "is this an overload?" is implemented by Sema::IsOverload(), which will need to be moved into the AST library for re-use here. That will be a future refactor. llvm-svn: 147534
2012-01-05 01:13:46 +08:00
FD->SClass = (StorageClass)Record[Idx++];
FD->IsInline = Record[Idx++];
FD->IsInlineSpecified = Record[Idx++];
FD->IsVirtualAsWritten = Record[Idx++];
FD->IsPure = Record[Idx++];
FD->HasInheritedPrototype = Record[Idx++];
FD->HasWrittenPrototype = Record[Idx++];
FD->IsDeleted = Record[Idx++];
FD->IsTrivial = Record[Idx++];
FD->IsDefaulted = Record[Idx++];
FD->IsExplicitlyDefaulted = Record[Idx++];
FD->HasImplicitReturnZero = Record[Idx++];
FD->IsConstexpr = Record[Idx++];
Add a bit on FunctionDecl/ObjCMethodDecl to indicate if there was a body that was skipped by the parser. llvm-svn: 169531
2012-12-07 02:59:10 +08:00
FD->HasSkippedBody = Record[Idx++];
PR9992: Serialize and deserialize the token sequence for a function template in -fdelayed-template-parsing mode. Patch by Will Wilson! llvm-svn: 187916
2013-08-08 05:41:30 +08:00
FD->IsLateTemplateParsed = Record[Idx++];
Fix linkage computation for derived types in inline functions. John noticed that the fix for pr15930 (r181981) didn't handle indirect uses of local types. For example, a pointer to local struct, or a function that returns it. One way to implement this would be to recursively look for local types. This would look a lot like the linkage computation itself for types. To avoid code duplication and utilize the existing linkage cache, this patch just makes the computation of "type with no linkage but externally visible because it is from an inline function" part of the linkage computation itself. llvm-svn: 182711
2013-05-26 01:16:20 +08:00
FD->setCachedLinkage(Linkage(Record[Idx++]));
Implement declaration merging for non-template functions from different modules. This implementation is a first approximation of what we want, using only the function type to determine equivalence. Later, we'll want to deal with some of the more subtle issues, including: - C allows a prototyped declaration and a non-prototyped declaration to be merged, which we should support - We may want to ignore the return type when merging, then complain if the return types differ. Or, we may want to leave it as it us, so that we only complain if overload resolution eventually fails. - C++ non-static member functions need to consider cv-qualifiers and ref-qualifiers. - Function templates need to consider the template parameters and return type. - Function template specializations will have special rules. - We can now (accidentally!) end up overloading in C, even without the "overloadable" attribute, and will need to detect this at some point. The actual detection of "is this an overload?" is implemented by Sema::IsOverload(), which will need to be moved into the AST library for re-use here. That will be a future refactor. llvm-svn: 147534
2012-01-05 01:13:46 +08:00
FD->EndRangeLoc = ReadSourceLocation(Record, Idx);
Support emitting/reading function templates to/from PCH. llvm-svn: 106534
2010-06-22 17:55:07 +08:00
switch ((FunctionDecl::TemplatedKind)Record[Idx++]) {
case FunctionDecl::TK_NonTemplate:
When a module completes the definition of a class template specialization imported from another module, emit an update record, rather than using the broken decl rewriting mechanism. If multiple modules do this, merge the definitions together, much as we would if they were separate declarations. llvm-svn: 206680
2014-04-19 11:48:30 +08:00
mergeRedeclarable(FD, Redecl);
Support emitting/reading function templates to/from PCH. llvm-svn: 106534
2010-06-22 17:55:07 +08:00
break;
case FunctionDecl::TK_FunctionTemplate:
When a module completes the definition of a class template specialization imported from another module, emit an update record, rather than using the broken decl rewriting mechanism. If multiple modules do this, merge the definitions together, much as we would if they were separate declarations. llvm-svn: 206680
2014-04-19 11:48:30 +08:00
// Merged when we merge the template.
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
FD->setDescribedFunctionTemplate(ReadDeclAs<FunctionTemplateDecl>(Record,
Idx));
Support emitting/reading function templates to/from PCH. llvm-svn: 106534
2010-06-22 17:55:07 +08:00
break;
case FunctionDecl::TK_MemberSpecialization: {
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
FunctionDecl *InstFD = ReadDeclAs<FunctionDecl>(Record, Idx);
Support emitting/reading function templates to/from PCH. llvm-svn: 106534
2010-06-22 17:55:07 +08:00
TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
SourceLocation POI = ReadSourceLocation(Record, Idx);
In ASTReader, replace the never-NULL ASTContext pointer with an ASTContext reference. Remove all of the extra checking and logic that was used to cope with a NULL ASTContext. No effective functionality change. llvm-svn: 139413
2011-09-10 05:34:22 +08:00
FD->setInstantiationOfMemberFunction(Reader.getContext(), InstFD, TSK);
Support emitting/reading function templates to/from PCH. llvm-svn: 106534
2010-06-22 17:55:07 +08:00
FD->getMemberSpecializationInfo()->setPointOfInstantiation(POI);
When a module completes the definition of a class template specialization imported from another module, emit an update record, rather than using the broken decl rewriting mechanism. If multiple modules do this, merge the definitions together, much as we would if they were separate declarations. llvm-svn: 206680
2014-04-19 11:48:30 +08:00
mergeRedeclarable(FD, Redecl);
Support emitting/reading function templates to/from PCH. llvm-svn: 106534
2010-06-22 17:55:07 +08:00
break;
}
case FunctionDecl::TK_FunctionTemplateSpecialization: {
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
FunctionTemplateDecl *Template = ReadDeclAs<FunctionTemplateDecl>(Record,
Idx);
Support emitting/reading function templates to/from PCH. llvm-svn: 106534
2010-06-22 17:55:07 +08:00
TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
// Template arguments.
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<TemplateArgument, 8> TemplArgs;
[modules] When loading a template specialization, re-canonicalize its template arguments because the reloaded form might have become non-canonical across the serialization/deserialization step (this particularly happens when the canonical form of the type involves an expression). llvm-svn: 244409
2015-08-09 09:05:31 +08:00
Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx,
/*Canonicalize*/ true);
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,
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
HasTemplateArgumentsAsWritten ? &TemplArgsInfo
: nullptr,
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
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;
Convert some function arguments to use ArrayRef. llvm-svn: 211764
2014-06-26 12:58:53 +08:00
FunctionTemplateSpecializationInfo::Profile(ID, TemplArgs, C);
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
void *InsertPos = nullptr;
Lazily deserialize function template specializations. This fixes a cycle in module deserialization / merging, and more laziness here is general goodness. llvm-svn: 185132
2013-06-28 12:37:53 +08:00
FunctionTemplateDecl::Common *CommonPtr = CanonTemplate->getCommonPtr();
[modules] Merging support for specializations of a function template. This very rarely matters, but can affect whether two dependent types are canonically equivalent. llvm-svn: 241207
2015-07-02 07:19:58 +08:00
FunctionTemplateSpecializationInfo *ExistingInfo =
CommonPtr->Specializations.FindNodeOrInsertPos(ID, InsertPos);
[PCH] Add a null check to avoid crashing. Unfortunately, no test case. rdar://11960120 llvm-svn: 163566
2012-09-11 07:28:22 +08:00
if (InsertPos)
Lazily deserialize function template specializations. This fixes a cycle in module deserialization / merging, and more laziness here is general goodness. llvm-svn: 185132
2013-06-28 12:37:53 +08:00
CommonPtr->Specializations.InsertNode(FTInfo, InsertPos);
else {
assert(Reader.getContext().getLangOpts().Modules &&
"already deserialized this template specialization");
[modules] Merging support for specializations of a function template. This very rarely matters, but can affect whether two dependent types are canonically equivalent. llvm-svn: 241207
2015-07-02 07:19:58 +08:00
mergeRedeclarable(FD, ExistingInfo->Function, Redecl);
Lazily deserialize function template specializations. This fixes a cycle in module deserialization / merging, and more laziness here is general goodness. llvm-svn: 185132
2013-06-28 12:37:53 +08:00
}
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);
[modules] Merging support for specializations of a function template. This very rarely matters, but can affect whether two dependent types are canonically equivalent. llvm-svn: 241207
2015-07-02 07:19:58 +08:00
// These are not merged; we don't need to merge redeclarations of dependent
// template friends.
Fix various bugs in recent commits for C++ PCH. llvm-svn: 106995
2010-06-28 17:31:34 +08:00
break;
Support emitting/reading function templates to/from PCH. llvm-svn: 106534
2010-06-22 17:55:07 +08:00
}
}
Fix reading FunctionDecls from PCH. llvm-svn: 107477
2010-07-02 19:55:40 +08:00
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
// Read in the parameters.
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
unsigned NumParams = Record[Idx++];
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<ParmVarDecl *, 16> Params;
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
Params.reserve(NumParams);
for (unsigned I = 0; I != NumParams; ++I)
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
Params.push_back(ReadDeclAs<ParmVarDecl>(Record, Idx));
ArrayRef-ifying Function/BlockDecl's setParams llvm-svn: 140268
2011-09-22 02:16:56 +08:00
FD->setParams(Reader.getContext(), Params);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitObjCMethodDecl(ObjCMethodDecl *MD) {
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
VisitNamedDecl(MD);
if (Record[Idx++]) {
When we load a function or method body from an AST file, we check whether that function/method already has a body (loaded from some other AST file), as introduced in r165137. Delay this check until after the redeclaration chains have been wired up. While I'm here, make the loading of method bodies lazy. llvm-svn: 165513
2012-10-10 01:21:28 +08:00
// Load the body on-demand. Most clients won't care, because method
// definitions rarely show up in headers.
Reader.PendingBodies[MD] = GetCurrentCursorOffset();
HasPendingBody = true;
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
MD->setSelfDecl(ReadDeclAs<ImplicitParamDecl>(Record, Idx));
MD->setCmdDecl(ReadDeclAs<ImplicitParamDecl>(Record, Idx));
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
MD->setInstanceMethod(Record[Idx++]);
MD->setVariadic(Record[Idx++]);
Rename ObjCMethodDecl::isSynthesized to isPropertyAccessor. This more accurately reflects its use: this flag is set when a method matches the getter or setter name for a property in the same class, and does not actually specify whether or not the definition of the method will be synthesized (either implicitly or explicitly with @synthesize). This renames the setter and backing field as well, and changes the (soon-to-be-obsolete?) XML dump format to use 'property_accessor' instead of 'synthesized'. llvm-svn: 165626
2012-10-11 00:42:25 +08:00
MD->setPropertyAccessor(Record[Idx++]);
atch for implementation of objective-c's -Wselector warning flag in clang. Little more to do for a PCH issue. Radar 6507158. llvm-svn: 109129
2010-07-23 02:24:20 +08:00
MD->setDefined(Record[Idx++]);
[AST/libclang] Speed up clang_getOverriddenCursors() considerably by reserving a bit in ObjCMethodDecl to indicate whether the method does not override any other method, which is the majority of cases. That way we can avoid unnecessary work doing lookups, especially when PCH is involved. rdar://11360082 llvm-svn: 156476
2012-05-10 00:12:57 +08:00
MD->IsOverriding = Record[Idx++];
Add a bit on FunctionDecl/ObjCMethodDecl to indicate if there was a body that was skipped by the parser. llvm-svn: 169531
2012-12-07 02:59:10 +08:00
MD->HasSkippedBody = Record[Idx++];
[PCH] Serialize info about redeclared objc methods. llvm-svn: 141964
2011-10-15 01:41:52 +08:00
MD->IsRedeclaration = Record[Idx++];
MD->HasRedeclaration = Record[Idx++];
if (MD->HasRedeclaration)
Reader.getContext().setObjCMethodRedeclaration(MD,
ReadDeclAs<ObjCMethodDecl>(Record, Idx));
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
MD->setDeclImplementation((ObjCMethodDecl::ImplementationControl)Record[Idx++]);
MD->setObjCDeclQualifier((Decl::ObjCDeclQualifier)Record[Idx++]);
Implement Objective-C Related Result Type semantics. Related result types apply Cocoa conventions to the type of message sends and property accesses to Objective-C methods that are known to always return objects whose type is the same as the type of the receiving class (or a subclass thereof), such as +alloc and -init. This tightens up static type safety for Objective-C, so that we now diagnose mistakes like this: t.m:4:10: warning: incompatible pointer types initializing 'NSSet *' with an expression of type 'NSArray *' [-Wincompatible-pointer-types] NSSet *array = [[NSArray alloc] init]; ^ ~~~~~~~~~~~~~~~~~~~~~~ /System/Library/Frameworks/Foundation.framework/Headers/NSObject.h:72:1: note: instance method 'init' is assumed to return an instance of its receiver type ('NSArray *') - (id)init; ^ It also means that we get decent type inference when writing code in Objective-C++0x: auto array = [[NSMutableArray alloc] initWithObjects:@"one", @"two",nil]; // ^ now infers NSMutableArray* rather than id llvm-svn: 132868
2011-06-11 09:09:30 +08:00
MD->SetRelatedResultType(Record[Idx++]);
Rename getResultType() on function and method declarations to getReturnType() A return type is the declared or deduced part of the function type specified in the declaration. A result type is the (potentially adjusted) type of the value of an expression that calls the function. Rule of thumb: * Declarations have return types and parameters. * Expressions have result types and arguments. llvm-svn: 200082
2014-01-26 00:55:45 +08:00
MD->setReturnType(Reader.readType(F, Record, Idx));
MD->setReturnTypeSourceInfo(GetTypeSourceInfo(Record, Idx));
[AST/libclang] Fix the selector locations that are reported for a method definition that has its '{' attached to the method name without a space. With a method like: -(id)meth{ ..... } the logic in ObjCMethodDecl that determined the selector locations got confused because it was initialized based on an end location for '{' but that end location changed to '}' after the method was finished. Fix this by having an immutable end location for the declarator and for getLocEnd() get the end location from the body itself. Fixes rdar://11659739. llvm-svn: 158583
2012-06-16 08:46:02 +08:00
MD->DeclEndLoc = ReadSourceLocation(Record, Idx);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
unsigned NumParams = Record[Idx++];
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<ParmVarDecl *, 16> Params;
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
Params.reserve(NumParams);
for (unsigned I = 0; I != NumParams; ++I)
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
Params.push_back(ReadDeclAs<ParmVarDecl>(Record, Idx));
Allow getting all source locations of selector identifiers in a ObjCMethodDecl. Instead of always storing all source locations for the selector identifiers we check whether all the identifiers are in a "standard" position; "standard" position is -Immediately before the arguments: -(id)first:(int)x second:(int)y; -With a space between the arguments: -(id)first: (int)x second: (int)y; -For nullary selectors, immediately before ';': -(void)release; In such cases we infer the locations instead of storing them. llvm-svn: 140989
2011-10-03 14:37:04 +08:00
MD->SelLocsKind = Record[Idx++];
unsigned NumStoredSelLocs = Record[Idx++];
SmallVector<SourceLocation, 16> SelLocs;
SelLocs.reserve(NumStoredSelLocs);
for (unsigned i = 0; i != NumStoredSelLocs; ++i)
SelLocs.push_back(ReadSourceLocation(Record, Idx));
MD->setParamsAndSelLocs(Reader.getContext(), Params, SelLocs);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Parsing, semantic analysis, and AST for Objective-C type parameters. Produce type parameter declarations for Objective-C type parameters, and attach lists of type parameters to Objective-C classes, categories, forward declarations, and extensions as appropriate. Perform semantic analysis of type bounds for type parameters, both in isolation and across classes/categories/extensions to ensure consistency. Also handle (de-)serialization of Objective-C type parameter lists, along with sundry other things one must do to add a new declaration to Clang. Note that Objective-C type parameters are typedef name declarations, like typedefs and C++11 type aliases, in support of type erasure. Part of rdar://problem/6294649. llvm-svn: 241541
2015-07-07 11:57:15 +08:00
void ASTDeclReader::VisitObjCTypeParamDecl(ObjCTypeParamDecl *D) {
Remove trivial dtor that was making uses of the copy ctor -Wdeprecated unclean And also remove an unused variable that's now diagnosed by -Wunused-variable since the dtor is now trivial. llvm-svn: 248759
2015-09-29 07:48:49 +08:00
VisitTypedefNameDecl(D);
[modules] Add an assert for redeclarations that we never added to their redecl chain and fix the cases where it fires. * Handle the __va_list_tag as a predefined decl. Previously we failed to merge sometimes it because it's not visible to name lookup. (In passing, remove redundant __va_list_tag typedefs that we were creating for some ABIs. These didn't affect the mangling or representation of the type.) * For Decls derived from Redeclarable that are not in fact redeclarable (implicit params, function params, ObjC type parameters), remove them from the list of expected redeclarable decls. llvm-svn: 243259
2015-07-27 13:40:23 +08:00
Implement variance for Objective-C type parameters. Introduce co- and contra-variance for Objective-C type parameters, which allows us to express that (for example) an NSArray is covariant in its type parameter. This means that NSArray<NSMutableString *> * is a subtype of NSArray<NSString *> *, which is expected of the immutable Foundation collections. Type parameters can be annotated with __covariant or __contravariant to make them co- or contra-variant, respectively. This feature can be detected by __has_feature(objc_generics_variance). Implements rdar://problem/20217490. llvm-svn: 241549
2015-07-07 11:58:54 +08:00
D->Variance = Record[Idx++];
Substitute type arguments into uses of Objective-C interface members. When messaging a method that was defined in an Objective-C class (or category or extension thereof) that has type parameters, substitute the type arguments for those type parameters. Similarly, substitute into property accesses, instance variables, and other references. This includes general infrastructure for substituting the type arguments associated with an ObjCObject(Pointer)Type into a type referenced within a particular context, handling all of the substitutions required to deal with (e.g.) inheritance involving parameterized classes. In cases where no type arguments are available (e.g., because we're messaging via some unspecialized type, id, etc.), we substitute in the type bounds for the type parameters instead. Example: @interface NSSet<T : id<NSCopying>> : NSObject <NSCopying> - (T)firstObject; @end void f(NSSet<NSString *> *stringSet, NSSet *anySet) { [stringSet firstObject]; // produces NSString* [anySet firstObject]; // produces id<NSCopying> (the bound) } When substituting for the type parameters given an unspecialized context (i.e., no specific type arguments were given), substituting the type bounds unconditionally produces type signatures that are too strong compared to the pre-generics signatures. Instead, use the following rule: - In covariant positions, such as method return types, replace type parameters with “id” or “Class” (the latter only when the type parameter bound is “Class” or qualified class, e.g, “Class<NSCopying>”) - In other positions (e.g., parameter types), replace type parameters with their type bounds. - When a specialized Objective-C object or object pointer type contains a type parameter in its type arguments (e.g., NSArray<T>*, but not NSArray<NSString *> *), replace the entire object/object pointer type with its unspecialized version (e.g., NSArray *). llvm-svn: 241543
2015-07-07 11:57:53 +08:00
D->Index = Record[Idx++];
Implement variance for Objective-C type parameters. Introduce co- and contra-variance for Objective-C type parameters, which allows us to express that (for example) an NSArray is covariant in its type parameter. This means that NSArray<NSMutableString *> * is a subtype of NSArray<NSString *> *, which is expected of the immutable Foundation collections. Type parameters can be annotated with __covariant or __contravariant to make them co- or contra-variant, respectively. This feature can be detected by __has_feature(objc_generics_variance). Implements rdar://problem/20217490. llvm-svn: 241549
2015-07-07 11:58:54 +08:00
D->VarianceLoc = ReadSourceLocation(Record, Idx);
Parsing, semantic analysis, and AST for Objective-C type parameters. Produce type parameter declarations for Objective-C type parameters, and attach lists of type parameters to Objective-C classes, categories, forward declarations, and extensions as appropriate. Perform semantic analysis of type bounds for type parameters, both in isolation and across classes/categories/extensions to ensure consistency. Also handle (de-)serialization of Objective-C type parameter lists, along with sundry other things one must do to add a new declaration to Clang. Note that Objective-C type parameters are typedef name declarations, like typedefs and C++11 type aliases, in support of type erasure. Part of rdar://problem/6294649. llvm-svn: 241541
2015-07-07 11:57:15 +08:00
D->ColonLoc = ReadSourceLocation(Record, Idx);
}
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
}
Parsing, semantic analysis, and AST for Objective-C type parameters. Produce type parameter declarations for Objective-C type parameters, and attach lists of type parameters to Objective-C classes, categories, forward declarations, and extensions as appropriate. Perform semantic analysis of type bounds for type parameters, both in isolation and across classes/categories/extensions to ensure consistency. Also handle (de-)serialization of Objective-C type parameter lists, along with sundry other things one must do to add a new declaration to Clang. Note that Objective-C type parameters are typedef name declarations, like typedefs and C++11 type aliases, in support of type erasure. Part of rdar://problem/6294649. llvm-svn: 241541
2015-07-07 11:57:15 +08:00
ObjCTypeParamList *ASTDeclReader::ReadObjCTypeParamList() {
unsigned numParams = Record[Idx++];
if (numParams == 0)
return nullptr;
SmallVector<ObjCTypeParamDecl *, 4> typeParams;
typeParams.reserve(numParams);
for (unsigned i = 0; i != numParams; ++i) {
auto typeParam = ReadDeclAs<ObjCTypeParamDecl>(Record, Idx);
if (!typeParam)
return nullptr;
typeParams.push_back(typeParam);
}
SourceLocation lAngleLoc = ReadSourceLocation(Record, Idx);
SourceLocation rAngleLoc = ReadSourceLocation(Record, Idx);
return ObjCTypeParamList::create(Reader.getContext(), lAngleLoc,
typeParams, rAngleLoc);
}
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);
Parsing, semantic analysis, and AST for Objective-C type parameters. Produce type parameter declarations for Objective-C type parameters, and attach lists of type parameters to Objective-C classes, categories, forward declarations, and extensions as appropriate. Perform semantic analysis of type bounds for type parameters, both in isolation and across classes/categories/extensions to ensure consistency. Also handle (de-)serialization of Objective-C type parameter lists, along with sundry other things one must do to add a new declaration to Clang. Note that Objective-C type parameters are typedef name declarations, like typedefs and C++11 type aliases, in support of type erasure. Part of rdar://problem/6294649. llvm-svn: 241541
2015-07-07 11:57:15 +08:00
ID->TypeParamList = ReadObjCTypeParamList();
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.
Handle Objective-C type arguments. Objective-C type arguments can be provided in angle brackets following an Objective-C interface type. Syntactically, this is the same position as one would provide protocol qualifiers (e.g., id<NSCopying>), so parse both together and let Sema sort out the ambiguous cases. This applies both when parsing types and when parsing the superclass of an Objective-C class, which can now be a specialized type (e.g., NSMutableArray<T> inherits from NSArray<T>). Check Objective-C type arguments against the type parameters of the corresponding class. Verify the length of the type argument list and that each type argument satisfies the corresponding bound. Specializations of parameterized Objective-C classes are represented in the type system as distinct types. Both specialized types (e.g., NSArray<NSString *> *) and unspecialized types (NSArray *) are represented, separately. llvm-svn: 241542
2015-07-07 11:57:35 +08:00
Data.SuperClassTInfo = GetTypeSourceInfo(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
Move ObjCInterfaceDecl's "EndLoc" into DefinitionData, since it only applies to an actual definition. Plus, clarify the purpose of this field and give the accessor a different name, since getLocEnd() is supposed to be the same as getSourceRange().getEnd(). llvm-svn: 146694
2011-12-16 06:34:59 +08:00
Data.EndLoc = ReadSourceLocation(Record, Idx);
[objc] Introduce ObjCInterfaceDecl::getDesignatedInitializers() to get the designated initializers of an interface. If the interface declaration does not have methods marked as designated initializers then the interface inherits the designated initializers of its super class. llvm-svn: 196315
2013-12-04 05:11:30 +08:00
Data.HasDesignatedInitializers = Record[Idx++];
Move ObjCInterfaceDecl's "EndLoc" into DefinitionData, since it only applies to an actual definition. Plus, clarify the purpose of this field and give the accessor a different name, since getLocEnd() is supposed to be the same as getSourceRange().getEnd(). llvm-svn: 146694
2011-12-16 06:34:59 +08:00
Move the definition-specific data of ObjCInterfaceDecl into a separately-allocated DefinitionData structure, which we manage the same way as CXXRecordDecl::DefinitionData. This prepares the way for making ObjCInterfaceDecls redeclarable, to more accurately model forward declarations of Objective-C classes and eliminate the mutation of ObjCInterfaceDecl that causes us serious trouble in the AST reader. Note that ObjCInterfaceDecl's accessors are fairly robust against being applied to forward declarations, because Clang (and Sema in particular) doesn't perform RequireCompleteType/hasDefinition() checks everywhere it has to. Each of these overly-robust cases is marked with a FIXME, which we can tackle over time. llvm-svn: 146644
2011-12-15 13:27:12 +08:00
// Read the directly referenced protocols and their SourceLocations.
unsigned NumProtocols = Record[Idx++];
SmallVector<ObjCProtocolDecl *, 16> Protocols;
Protocols.reserve(NumProtocols);
for (unsigned I = 0; I != NumProtocols; ++I)
Protocols.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
SmallVector<SourceLocation, 16> ProtoLocs;
ProtoLocs.reserve(NumProtocols);
for (unsigned I = 0; I != NumProtocols; ++I)
ProtoLocs.push_back(ReadSourceLocation(Record, Idx));
ID->setProtocolList(Protocols.data(), NumProtocols, ProtoLocs.data(),
Reader.getContext());
Split ObjCInterfaceDecl::ReferencedProtocols into two lists: ReferencedProtocols and AllReferencedProtocols. ReferencedProtocols (and thus protocol_begin(), protocol_end()) now only contains the list of protocols that were directly referenced in an @interface declaration. 'all_referenced_protocol_[begin,end]()' now returns the set of protocols that were referenced in both the @interface and class extensions. The latter is needed for semantic analysis/codegen, while the former is needed to maintain the lexical information of the original source. Fixes <rdar://problem/8380046>. llvm-svn: 112691
2010-09-01 09:21:15 +08:00
Move the definition-specific data of ObjCInterfaceDecl into a separately-allocated DefinitionData structure, which we manage the same way as CXXRecordDecl::DefinitionData. This prepares the way for making ObjCInterfaceDecls redeclarable, to more accurately model forward declarations of Objective-C classes and eliminate the mutation of ObjCInterfaceDecl that causes us serious trouble in the AST reader. Note that ObjCInterfaceDecl's accessors are fairly robust against being applied to forward declarations, because Clang (and Sema in particular) doesn't perform RequireCompleteType/hasDefinition() checks everywhere it has to. Each of these overly-robust cases is marked with a FIXME, which we can tackle over time. llvm-svn: 146644
2011-12-15 13:27:12 +08:00
// Read the transitive closure of protocols referenced by this class.
NumProtocols = Record[Idx++];
Protocols.clear();
Protocols.reserve(NumProtocols);
for (unsigned I = 0; I != NumProtocols; ++I)
Protocols.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
ID->data().AllReferencedProtocols.set(Protocols.data(), NumProtocols,
Reader.getContext());
Split ObjCInterfaceDecl::ReferencedProtocols into two lists: ReferencedProtocols and AllReferencedProtocols. ReferencedProtocols (and thus protocol_begin(), protocol_end()) now only contains the list of protocols that were directly referenced in an @interface declaration. 'all_referenced_protocol_[begin,end]()' now returns the set of protocols that were referenced in both the @interface and class extensions. The latter is needed for semantic analysis/codegen, while the former is needed to maintain the lexical information of the original source. Fixes <rdar://problem/8380046>. llvm-svn: 112691
2010-09-01 09:21:15 +08:00
Move the definition-specific data of ObjCInterfaceDecl into a separately-allocated DefinitionData structure, which we manage the same way as CXXRecordDecl::DefinitionData. This prepares the way for making ObjCInterfaceDecls redeclarable, to more accurately model forward declarations of Objective-C classes and eliminate the mutation of ObjCInterfaceDecl that causes us serious trouble in the AST reader. Note that ObjCInterfaceDecl's accessors are fairly robust against being applied to forward declarations, because Clang (and Sema in particular) doesn't perform RequireCompleteType/hasDefinition() checks everywhere it has to. Each of these overly-robust cases is marked with a FIXME, which we can tackle over time. llvm-svn: 146644
2011-12-15 13:27:12 +08:00
// We will rebuild this list lazily.
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
ID->setIvarList(nullptr);
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.
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
IVD->setNextIvar(nullptr);
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);
Parsing, semantic analysis, and AST for Objective-C type parameters. Produce type parameter declarations for Objective-C type parameters, and attach lists of type parameters to Objective-C classes, categories, forward declarations, and extensions as appropriate. Perform semantic analysis of type bounds for type parameters, both in isolation and across classes/categories/extensions to ensure consistency. Also handle (de-)serialization of Objective-C type parameter lists, along with sundry other things one must do to add a new declaration to Clang. Note that Objective-C type parameters are typedef name declarations, like typedefs and C++11 type aliases, in support of type erasure. Part of rdar://problem/6294649. llvm-svn: 241541
2015-07-07 11:57:15 +08:00
CD->TypeParamList = ReadObjCTypeParamList();
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
unsigned NumProtoRefs = Record[Idx++];
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<ObjCProtocolDecl *, 16> ProtoRefs;
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
ProtoRefs.reserve(NumProtoRefs);
for (unsigned I = 0; I != NumProtoRefs; ++I)
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
ProtoRefs.push_back(ReadDeclAs<ObjCProtocolDecl>(Record, Idx));
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<SourceLocation, 16> ProtoLocs;
Keep track of the source locations for each protocol reference in Objective-C classes, protocol definitions, forward protocol declarations, and categories. This information isn't actually used yet; that's coming next. llvm-svn: 93636
2010-01-16 23:02:53 +08:00
ProtoLocs.reserve(NumProtoRefs);
for (unsigned I = 0; I != NumProtoRefs; ++I)
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
ProtoLocs.push_back(ReadSourceLocation(Record, Idx));
Keep track of the source locations for each protocol reference in Objective-C classes, protocol definitions, forward protocol declarations, and categories. This information isn't actually used yet; that's coming next. llvm-svn: 93636
2010-01-16 23:02:53 +08:00
CD->setProtocolList(ProtoRefs.data(), NumProtoRefs, ProtoLocs.data(),
In ASTReader, replace the never-NULL ASTContext pointer with an ASTContext reference. Remove all of the extra checking and logic that was used to cope with a NULL ASTContext. No effective functionality change. llvm-svn: 139413
2011-09-10 05:34:22 +08:00
Reader.getContext());
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitObjCCompatibleAliasDecl(ObjCCompatibleAliasDecl *CAD) {
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
VisitNamedDecl(CAD);
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
CAD->setClassInterface(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx));
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitObjCPropertyDecl(ObjCPropertyDecl *D) {
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
VisitNamedDecl(D);
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
D->setAtLoc(ReadSourceLocation(Record, Idx));
objective-c: provide fixit hint when atomic property does not have matching user defined setter/getter and a warning is issued. In this case, a fixit note is displayed. // rdar://10267155 llvm-svn: 151766
2012-03-01 06:18:55 +08:00
D->setLParenLoc(ReadSourceLocation(Record, Idx));
Extend type nullability qualifiers for Objective-C. Introduce context-sensitive, non-underscored nullability specifiers (nonnull, nullable, null_unspecified) for Objective-C method return types, method parameter types, and properties. Introduce Objective-C-specific semantics, including computation of the nullability of the result of a message send, merging of nullability information from the @interface of a class into its @implementation, etc . This is the Objective-C part of rdar://problem/18868820. llvm-svn: 240154
2015-06-20 02:14:38 +08:00
QualType T = Reader.readType(F, Record, Idx);
TypeSourceInfo *TSI = GetTypeSourceInfo(Record, Idx);
D->setType(T, TSI);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
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
D->setPropertyImplementation(
(ObjCPropertyDecl::PropertyControl)Record[Idx++]);
In the AST reader, factor out the mapping of local type IDs to global type IDs into a single place, and make sure that all of the callers use the appropriate functions to do the mapping. Since the mapping is still the identity function, this is essentially a no-op. llvm-svn: 135733
2011-07-22 08:38:23 +08:00
D->setGetterName(Reader.ReadDeclarationName(F,Record, Idx).getObjCSelector());
D->setSetterName(Reader.ReadDeclarationName(F,Record, Idx).getObjCSelector());
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
D->setGetterMethodDecl(ReadDeclAs<ObjCMethodDecl>(Record, Idx));
D->setSetterMethodDecl(ReadDeclAs<ObjCMethodDecl>(Record, Idx));
D->setPropertyIvarDecl(ReadDeclAs<ObjCIvarDecl>(Record, Idx));
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitObjCImplDecl(ObjCImplDecl *D) {
Make ObjCImplDecl inherit from ObjCContainerDecl. ObjCContainerDecl now is the root class for objc decls that contain methods. llvm-svn: 77235
2009-07-28 03:04:32 +08:00
VisitObjCContainerDecl(D);
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
D->setClassInterface(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx));
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitObjCCategoryImplDecl(ObjCCategoryImplDecl *D) {
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
VisitObjCImplDecl(D);
Teach the ASTReader to perform local and global mapping of identifier IDs properly, although the mapping itself is still trivial. llvm-svn: 136391
2011-07-29 04:55:49 +08:00
D->setIdentifier(Reader.GetIdentifierInfo(F, Record, Idx));
Save category name loc in ObjCCategoryImplDecl, patch by Jason Haslam! llvm-svn: 146213
2011-12-09 08:31:40 +08:00
D->CategoryNameLoc = ReadSourceLocation(Record, Idx);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitObjCImplementationDecl(ObjCImplementationDecl *D) {
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
VisitObjCImplDecl(D);
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
D->setSuperClass(ReadDeclAs<ObjCInterfaceDecl>(Record, Idx));
Keep track of an @implementation's super class name location, if one was provided. llvm-svn: 181039
2013-05-04 02:05:44 +08:00
D->SuperLoc = ReadSourceLocation(Record, Idx);
modern objc translator. Finish off first cut of the modern meta-data translation by commenting out private ivar declarations in user source. Also, added several tests. llvm-svn: 150985
2012-02-21 04:09:20 +08:00
D->setIvarLBraceLoc(ReadSourceLocation(Record, Idx));
D->setIvarRBraceLoc(ReadSourceLocation(Record, Idx));
Set a special flag in class metadata when an Objective-C class has ivars that require destruction, but none that require anything except zero-initialization. This is common in ARC and (when true throughout a class hierarchy) permits the elimination of an unnecessary message-send during allocation. llvm-svn: 166088
2012-10-17 12:53:31 +08:00
D->setHasNonZeroConstructors(Record[Idx++]);
D->setHasDestructors(Record[Idx++]);
[modules] Deserialize CXXCtorInitializer list for a constructor lazily. Previously we'd deserialize the list of mem-initializers for a constructor when we deserialized the declaration of the constructor. That could trigger a significant amount of unnecessary work (pulling in all base classes recursively, for a start) and was causing problems for the modules buildbot due to cyclic deserializations. We now deserialize these on demand. This creates a certain amount of duplication with the handling of CXXBaseSpecifiers; I'll look into reducing that next. llvm-svn: 233052
2015-03-24 14:36:48 +08:00
D->NumIvarInitializers = Record[Idx++];
if (D->NumIvarInitializers)
D->IvarInitializers = Reader.ReadCXXCtorInitializersRef(F, Record, Idx);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitObjCPropertyImplDecl(ObjCPropertyImplDecl *D) {
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
VisitDecl(D);
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
D->setAtLoc(ReadSourceLocation(Record, Idx));
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
D->setPropertyDecl(ReadDeclAs<ObjCPropertyDecl>(Record, Idx));
D->PropertyIvarDecl = ReadDeclAs<ObjCIvarDecl>(Record, Idx);
For an Objective-C @synthesize statement, e.g., @synthesize foo = _foo; keep track of the location of the ivar ("_foo"). Teach libclang to visit the ivar as a member reference. llvm-svn: 119447
2010-11-17 09:03:52 +08:00
D->IvarLoc = ReadSourceLocation(Record, Idx);
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
D->setGetterCXXConstructor(Reader.ReadExpr(F));
D->setSetterCXXAssignment(Reader.ReadExpr(F));
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitFieldDecl(FieldDecl *FD) {
Store/load type source info from/to PCH files. llvm-svn: 79396
2009-08-19 09:28:35 +08:00
VisitDeclaratorDecl(FD);
PR13064: Store whether an in-class initializer uses direct or copy initialization, and use that information to produce the right kind of initialization during template instantiation. llvm-svn: 158288
2012-06-10 11:12:00 +08:00
FD->Mutable = Record[Idx++];
if (int BitWidthOrInitializer = Record[Idx++]) {
Change how we distinguish bitfield widths, in-class initializers, and captured VLA types so that we can answer questions like "is this a bit-field" without looking at the enclosing DeclContext. NFC. llvm-svn: 219522
2014-10-11 02:44:34 +08:00
FD->InitStorage.setInt(
static_cast<FieldDecl::InitStorageKind>(BitWidthOrInitializer - 1));
if (FD->InitStorage.getInt() == FieldDecl::ISK_CapturedVLAType) {
[C++11] Support for capturing of variable length arrays in lambda expression. Differential Revision: http://reviews.llvm.org/D4368 llvm-svn: 216649
2014-08-28 12:28:19 +08:00
// Read captured variable length array.
Change how we distinguish bitfield widths, in-class initializers, and captured VLA types so that we can answer questions like "is this a bit-field" without looking at the enclosing DeclContext. NFC. llvm-svn: 219522
2014-10-11 02:44:34 +08:00
FD->InitStorage.setPointer(
[C++11] Support for capturing of variable length arrays in lambda expression. Differential Revision: http://reviews.llvm.org/D4368 llvm-svn: 216649
2014-08-28 12:28:19 +08:00
Reader.readType(F, Record, Idx).getAsOpaquePtr());
} else {
Change how we distinguish bitfield widths, in-class initializers, and captured VLA types so that we can answer questions like "is this a bit-field" without looking at the enclosing DeclContext. NFC. llvm-svn: 219522
2014-10-11 02:44:34 +08:00
FD->InitStorage.setPointer(Reader.ReadExpr(F));
[C++11] Support for capturing of variable length arrays in lambda expression. Differential Revision: http://reviews.llvm.org/D4368 llvm-svn: 216649
2014-08-28 12:28:19 +08:00
}
PR13064: Store whether an in-class initializer uses direct or copy initialization, and use that information to produce the right kind of initialization during template instantiation. llvm-svn: 158288
2012-06-10 11:12:00 +08:00
}
Read/write more information of ASTContext for PCH. Overriden methods and instantiated-from information. llvm-svn: 107597
2010-07-05 05:44:35 +08:00
if (!FD->getDeclName()) {
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
if (FieldDecl *Tmpl = ReadDeclAs<FieldDecl>(Record, Idx))
In ASTReader, replace the never-NULL ASTContext pointer with an ASTContext reference. Remove all of the extra checking and logic that was used to cope with a NULL ASTContext. No effective functionality change. llvm-svn: 139413
2011-09-10 05:34:22 +08:00
Reader.getContext().setInstantiatedFromUnnamedFieldDecl(FD, Tmpl);
Read/write more information of ASTContext for PCH. Overriden methods and instantiated-from information. llvm-svn: 107597
2010-07-05 05:44:35 +08:00
}
When merging class definitions across modules in C++, merge together fields. This change doesn't go all the way to making fields redeclarable; instead, it makes them 'mergeable', which means we can find the canonical declaration, but not much else (and for a declaration that's not from a module, the canonical declaration is always that declaration). llvm-svn: 192092
2013-10-07 16:02:11 +08:00
mergeMergeable(FD);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Basic support for Microsoft property declarations and references thereto. Patch by Tong Shen! llvm-svn: 179585
2013-04-16 15:28:30 +08:00
void ASTDeclReader::VisitMSPropertyDecl(MSPropertyDecl *PD) {
VisitDeclaratorDecl(PD);
PD->GetterId = Reader.GetIdentifierInfo(F, Record, Idx);
PD->SetterId = Reader.GetIdentifierInfo(F, Record, Idx);
}
Major anonymous union/struct redesign. A new AST node is introduced: def IndirectField : DDecl<Value>; IndirectFields are injected into the anonymous's parent scope and chain back to the original field. Name lookup for anonymous entities now result in an IndirectFieldDecl instead of a FieldDecl. There is no functionality change, the code generated should be the same. llvm-svn: 119919
2010-11-21 14:08:52 +08:00
void ASTDeclReader::VisitIndirectFieldDecl(IndirectFieldDecl *FD) {
VisitValueDecl(FD);
FD->ChainingSize = Record[Idx++];
assert(FD->ChainingSize >= 2 && "Anonymous chaining must be >= 2");
In ASTReader, replace the never-NULL ASTContext pointer with an ASTContext reference. Remove all of the extra checking and logic that was used to cope with a NULL ASTContext. No effective functionality change. llvm-svn: 139413
2011-09-10 05:34:22 +08:00
FD->Chaining = new (Reader.getContext())NamedDecl*[FD->ChainingSize];
Major anonymous union/struct redesign. A new AST node is introduced: def IndirectField : DDecl<Value>; IndirectFields are injected into the anonymous's parent scope and chain back to the original field. Name lookup for anonymous entities now result in an IndirectFieldDecl instead of a FieldDecl. There is no functionality change, the code generated should be the same. llvm-svn: 119919
2010-11-21 14:08:52 +08:00
for (unsigned I = 0; I != FD->ChainingSize; ++I)
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
FD->Chaining[I] = ReadDeclAs<NamedDecl>(Record, Idx);
[modules] Make IndirectFieldDecl mergeable to avoid lookup ambiguity when the same anonymous union is defined across multiple modules. llvm-svn: 243940
2015-08-04 10:05:09 +08:00
mergeMergeable(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
}
Started implementing variable templates. Top level declarations should be fully supported, up to some limitations documented as FIXMEs or TODO. Static data member templates work very partially. Static data member templates of class templates need particular attention... llvm-svn: 187762
2013-08-06 09:03:05 +08:00
ASTDeclReader::RedeclarableResult ASTDeclReader::VisitVarDeclImpl(VarDecl *VD) {
Implement declaration merging for variables in disjoint modules. llvm-svn: 147535
2012-01-05 01:21:36 +08:00
RedeclarableResult Redecl = VisitRedeclarable(VD);
Eliminate a hang while loading a sequence of redeclarable entities. In essence, the redeclaration chain for a class could end up in an inconsistent state while deserializing multiple declarations in that chain, where the circular linked list was not, in fact, circular. Since only two redeclarations of the same entity will get loaded when we're in this state, restore circularity when both have been loaded. Fixes <rdar://problem/10324940> / PR11195. llvm-svn: 143037
2011-10-27 01:53:41 +08:00
VisitDeclaratorDecl(VD);
Add 178663 back. http://lab.llvm.org:8011/builders/clang-x86_64-darwin10-gdb went back green before it processed the reverted 178663, so it could not have been the culprit. Revert "Revert 178663." This reverts commit 4f8a3eb2ce5d4ba422483439e20c8cbb4d953a41. llvm-svn: 178682
2013-04-04 03:27:57 +08:00
Compress some bits. Only matters for MSVC, or if we ever devirtualize Decl (because bits can't get laid out in base classes if the base is POD). llvm-svn: 130632
2011-05-01 10:13:58 +08:00
VD->VarDeclBits.SClass = (StorageClass)Record[Idx++];
In VarDecl nodes, store the thread storage class specifier as written. llvm-svn: 181113
2013-05-04 16:27:07 +08:00
VD->VarDeclBits.TSCSpec = Record[Idx++];
Represent C++ direct initializers as ParenListExprs before semantic analysis instead of having a special-purpose function. - ActOnCXXDirectInitializer, which was mostly duplication of AddInitializerToDecl (leading e.g. to PR10620, which Eli fixed a few days ago), is dropped completely. - MultiInitializer, which was an ugly hack I added, is dropped again. - We now have the infrastructure in place to distinguish between int x = {1}; int x({1}); int x{1}; -- VarDecl now has getInitStyle(), which indicates which of the above was used. -- CXXConstructExpr now has a flag to indicate that it represents list- initialization, although this is not yet used. - InstantiateInitializer was renamed to SubstInitializer and simplified. - ActOnParenOrParenListExpr has been replaced by ActOnParenListExpr, which always produces a ParenListExpr. Placed that so far failed to convert that back to a ParenExpr containing comma operators have been fixed. I'm pretty sure I could have made a crashing test case before this. The end result is a (I hope) considerably cleaner design of initializers. More importantly, the fact that I can now distinguish between the various initialization kinds means that I can get the tricky generalized initializer test cases Johannes Schaub supplied to work. (This is not yet done.) This commit passed self-host, with the resulting compiler passing the tests. I hope it doesn't break more complicated code. It's a pretty big change, but one that I feel is necessary. llvm-svn: 150318
2012-02-12 07:51:47 +08:00
VD->VarDeclBits.InitStyle = Record[Idx++];
[AST] Put VarDeclBitfields on a diet VarDeclBitfields contained bits which are never present in parameters. Split these out so that ParmVarDeclBitfields wouldn't grow past 32-bits if another field was added. llvm-svn: 237648
2015-05-19 08:57:16 +08:00
if (!isa<ParmVarDecl>(VD)) {
VD->NonParmVarDeclBits.ExceptionVar = Record[Idx++];
VD->NonParmVarDeclBits.NRVOVariable = Record[Idx++];
VD->NonParmVarDeclBits.CXXForRangeDecl = Record[Idx++];
VD->NonParmVarDeclBits.ARCPseudoStrong = Record[Idx++];
VD->NonParmVarDeclBits.IsConstexpr = Record[Idx++];
VD->NonParmVarDeclBits.IsInitCapture = Record[Idx++];
VD->NonParmVarDeclBits.PreviousDeclInSameBlockScope = Record[Idx++];
}
Switch the semantic DeclContext for a block-scope declaration of a function or variable from being the function to being the enclosing namespace scope (in C++) or the TU (in C). This allows us to fix a selection of related issues where we would build incorrect redeclaration chains for such declarations, and fail to notice type mismatches. Such declarations are put into a new IdentifierNamespace, IDNS_LocalExtern, which is only found when searching scopes, and not found when searching DeclContexts. Such a declaration is only made visible in its DeclContext if there are no non-LocalExtern declarations. llvm-svn: 191064
2013-09-20 09:15:31 +08:00
Linkage VarLinkage = Linkage(Record[Idx++]);
VD->setCachedLinkage(VarLinkage);
// Reconstruct the one piece of the IdentifierNamespace that we need.
Fix PCH deserialization bug with local static symbols being treated as local extern. This triggered a miscompilation of code using Boost's function_template.hpp when it was included inside a PCH file. A local static within that header would be treated as local extern, resulting in the wrong mangling. This only occurred during PCH deserialization. Fixes <rdar://problem/15975816> and <rdar://problem/15926311>. llvm-svn: 201130
2014-02-11 14:29:29 +08:00
if (VD->getStorageClass() == SC_Extern && VarLinkage != NoLinkage &&
Switch the semantic DeclContext for a block-scope declaration of a function or variable from being the function to being the enclosing namespace scope (in C++) or the TU (in C). This allows us to fix a selection of related issues where we would build incorrect redeclaration chains for such declarations, and fail to notice type mismatches. Such declarations are put into a new IdentifierNamespace, IDNS_LocalExtern, which is only found when searching scopes, and not found when searching DeclContexts. Such a declaration is only made visible in its DeclContext if there are no non-LocalExtern declarations. llvm-svn: 191064
2013-09-20 09:15:31 +08:00
VD->getLexicalDeclContext()->isFunctionOrMethod())
VD->setLocalExternDecl();
Fix linkage computation for derived types in inline functions. John noticed that the fix for pr15930 (r181981) didn't handle indirect uses of local types. For example, a pointer to local struct, or a function that returns it. One way to implement this would be to recursively look for local types. This would look a lot like the linkage computation itself for types. To avoid code duplication and utilize the existing linkage cache, this patch just makes the computation of "type with no linkage but externally visible because it is from an inline function" part of the linkage computation itself. llvm-svn: 182711
2013-05-26 01:16:20 +08:00
constexpr handling improvements. Produce detailed diagnostics when a 'constexpr' variable is initialized by a non-constant expression, and pass in the variable being declared so that earlier-initialized fields' values can be used. Rearrange VarDecl init evaluation to make this possible, and in so doing fix a long-standing issue in our C++ constant expression handling, where we would mishandle cases like: extern const int a; const int n = a; const int a = 5; int arr[n]; Here, n is not initialized by a constant expression, so can't be used in an ICE, even though the initialization expression would be an ICE if it appeared later in the TU. This requires computing whether the initializer is an ICE eagerly, and saving that information in PCH files. llvm-svn: 146856
2011-12-19 14:19:21 +08:00
if (uint64_t Val = Record[Idx++]) {
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
VD->setInit(Reader.ReadExpr(F));
constexpr handling improvements. Produce detailed diagnostics when a 'constexpr' variable is initialized by a non-constant expression, and pass in the variable being declared so that earlier-initialized fields' values can be used. Rearrange VarDecl init evaluation to make this possible, and in so doing fix a long-standing issue in our C++ constant expression handling, where we would mishandle cases like: extern const int a; const int n = a; const int a = 5; int arr[n]; Here, n is not initialized by a constant expression, so can't be used in an ICE, even though the initialization expression would be an ICE if it appeared later in the TU. This requires computing whether the initializer is an ICE eagerly, and saving that information in PCH files. llvm-svn: 146856
2011-12-19 14:19:21 +08:00
if (Val > 1) {
EvaluatedStmt *Eval = VD->ensureEvaluatedStmt();
Eval->CheckedICE = true;
Eval->IsICE = Val == 3;
}
}
Read/write specialization info of static data members for PCH. llvm-svn: 107593
2010-07-05 05:44:00 +08:00
Bug fix: disallow a variable template to be redeclared as a non-templated variable llvm-svn: 188350
2013-08-14 11:09:19 +08:00
enum VarKind {
VarNotTemplate = 0, VarTemplate, StaticDataMemberSpecialization
};
switch ((VarKind)Record[Idx++]) {
case VarNotTemplate:
[modules] Add an assert for redeclarations that we never added to their redecl chain and fix the cases where it fires. * Handle the __va_list_tag as a predefined decl. Previously we failed to merge sometimes it because it's not visible to name lookup. (In passing, remove redundant __va_list_tag typedefs that we were creating for some ABIs. These didn't affect the mangling or representation of the type.) * For Decls derived from Redeclarable that are not in fact redeclarable (implicit params, function params, ObjC type parameters), remove them from the list of expected redeclarable decls. llvm-svn: 243259
2015-07-27 13:40:23 +08:00
// Only true variables (not parameters or implicit parameters) can be
// merged; the other kinds are not really redeclarable at all.
[modules] Remove some dead code after r245779. llvm-svn: 245780
2015-08-22 10:09:38 +08:00
if (!isa<ParmVarDecl>(VD) && !isa<ImplicitParamDecl>(VD) &&
!isa<VarTemplateSpecializationDecl>(VD))
When two templates get merged together, also merge their pattern declarations together. This is extremely hairy, because in general we need to have loaded both the template and the pattern before we can determine whether either should be merged, so we temporarily violate the rule that all merging happens before reading a decl ends, but *only* in the case where a template's pattern is being loaded while loading the template itself. In order to accomodate this for class templates, delay loading the injected class name type for the pattern of the template until after we've loaded the template itself, if we happen to load the template first. llvm-svn: 207063
2014-04-24 10:25:27 +08:00
mergeRedeclarable(VD, Redecl);
Bug fix: disallow a variable template to be redeclared as a non-templated variable llvm-svn: 188350
2013-08-14 11:09:19 +08:00
break;
case VarTemplate:
When two templates get merged together, also merge their pattern declarations together. This is extremely hairy, because in general we need to have loaded both the template and the pattern before we can determine whether either should be merged, so we temporarily violate the rule that all merging happens before reading a decl ends, but *only* in the case where a template's pattern is being loaded while loading the template itself. In order to accomodate this for class templates, delay loading the injected class name type for the pattern of the template until after we've loaded the template itself, if we happen to load the template first. llvm-svn: 207063
2014-04-24 10:25:27 +08:00
// Merged when we merge the template.
Bug fix: disallow a variable template to be redeclared as a non-templated variable llvm-svn: 188350
2013-08-14 11:09:19 +08:00
VD->setDescribedVarTemplate(ReadDeclAs<VarTemplateDecl>(Record, Idx));
break;
case StaticDataMemberSpecialization: { // HasMemberSpecializationInfo.
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
VarDecl *Tmpl = ReadDeclAs<VarDecl>(Record, Idx);
Read/write specialization info of static data members for PCH. llvm-svn: 107593
2010-07-05 05:44:00 +08:00
TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
SourceLocation POI = ReadSourceLocation(Record, Idx);
In ASTReader, replace the never-NULL ASTContext pointer with an ASTContext reference. Remove all of the extra checking and logic that was used to cope with a NULL ASTContext. No effective functionality change. llvm-svn: 139413
2011-09-10 05:34:22 +08:00
Reader.getContext().setInstantiatedFromStaticDataMember(VD, Tmpl, TSK,POI);
When two templates get merged together, also merge their pattern declarations together. This is extremely hairy, because in general we need to have loaded both the template and the pattern before we can determine whether either should be merged, so we temporarily violate the rule that all merging happens before reading a decl ends, but *only* in the case where a template's pattern is being loaded while loading the template itself. In order to accomodate this for class templates, delay loading the injected class name type for the pattern of the template until after we've loaded the template itself, if we happen to load the template first. llvm-svn: 207063
2014-04-24 10:25:27 +08:00
mergeRedeclarable(VD, Redecl);
Bug fix: disallow a variable template to be redeclared as a non-templated variable llvm-svn: 188350
2013-08-14 11:09:19 +08:00
break;
}
Read/write specialization info of static data members for PCH. llvm-svn: 107593
2010-07-05 05:44:00 +08:00
}
Started implementing variable templates. Top level declarations should be fully supported, up to some limitations documented as FIXMEs or TODO. Static data member templates work very partially. Static data member templates of class templates need particular attention... llvm-svn: 187762
2013-08-06 09:03:05 +08:00
return Redecl;
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitImplicitParamDecl(ImplicitParamDecl *PD) {
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
VisitVarDecl(PD);
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitParmVarDecl(ParmVarDecl *PD) {
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
VisitVarDecl(PD);
Revise the representation of parameter scope data so that the scope depth overlaps with the ObjCDeclQualifier, dropping memory usage back to previous levels. llvm-svn: 130671
2011-05-02 08:30:12 +08:00
unsigned isObjCMethodParam = Record[Idx++];
unsigned scopeDepth = Record[Idx++];
unsigned scopeIndex = Record[Idx++];
unsigned declQualifier = Record[Idx++];
if (isObjCMethodParam) {
assert(scopeDepth == 0);
PD->setObjCMethodScopeInfo(scopeIndex);
PD->ParmVarDeclBits.ScopeDepthOrObjCQuals = declQualifier;
} else {
PD->setScopeInfo(scopeDepth, scopeIndex);
}
Compress some bits. Only matters for MSVC, or if we ever devirtualize Decl (because bits can't get laid out in base classes if the base is POD). llvm-svn: 130632
2011-05-01 10:13:58 +08:00
PD->ParmVarDeclBits.IsKNRPromoted = Record[Idx++];
PD->ParmVarDeclBits.HasInheritedDefaultArg = Record[Idx++];
Write/read ParmVarDecl's UninstantiatedDefaultArg for PCH. llvm-svn: 107594
2010-07-05 05:44:07 +08:00
if (Record[Idx++]) // hasUninstantiatedDefaultArg.
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
PD->setUninstantiatedDefaultArg(Reader.ReadExpr(F));
Check for matching template-parameter-lists when merging template declarations. llvm-svn: 184791
2013-06-25 06:51:00 +08:00
// FIXME: If this is a redeclaration of a function from another module, handle
// inheritance of default arguments.
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitFileScopeAsmDecl(FileScopeAsmDecl *AD) {
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
VisitDecl(AD);
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
AD->setAsmString(cast<StringLiteral>(Reader.ReadExpr(F)));
Fixed source range for FileScopeAsmDecl. Others source range fixes will follow. llvm-svn: 126939
2011-03-03 22:20:18 +08:00
AD->setRParenLoc(ReadSourceLocation(Record, Idx));
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitBlockDecl(BlockDecl *BD) {
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
VisitDecl(BD);
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
BD->setBody(cast_or_null<CompoundStmt>(Reader.ReadStmt(F)));
BD->setSignatureAsWritten(GetTypeSourceInfo(Record, Idx));
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
unsigned NumParams = Record[Idx++];
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<ParmVarDecl *, 16> Params;
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
Params.reserve(NumParams);
for (unsigned I = 0; I != NumParams; ++I)
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
Params.push_back(ReadDeclAs<ParmVarDecl>(Record, Idx));
ArrayRef-ifying Function/BlockDecl's setParams llvm-svn: 140268
2011-09-22 02:16:56 +08:00
BD->setParams(Params);
An insomniac stab at making block declarations list the variables they close on, as well as more reliably limiting invalid references to locals from nested scopes. llvm-svn: 124721
2011-02-02 21:00:07 +08:00
Serialize and deserialize some missing bits from BlockDecl. llvm-svn: 154676
2012-04-14 01:33:29 +08:00
BD->setIsVariadic(Record[Idx++]);
BD->setBlockMissingReturnType(Record[Idx++]);
BD->setIsConversionFromLambda(Record[Idx++]);
An insomniac stab at making block declarations list the variables they close on, as well as more reliably limiting invalid references to locals from nested scopes. llvm-svn: 124721
2011-02-02 21:00:07 +08:00
bool capturesCXXThis = Record[Idx++];
A few more tweaks to the blocks AST representation: - BlockDeclRefExprs always store VarDecls - BDREs no longer store copy expressions - BlockDecls now store a list of captured variables, information about how they're captured, and a copy expression if necessary With that in hand, change IR generation to use the captures data in blocks instead of walking the block independently. Additionally, optimize block layout by emitting fields in descending alignment order, with a heuristic for filling in words when alignment of the end of the block header is insufficient for the most aligned field. llvm-svn: 125005
2011-02-07 18:33:21 +08:00
unsigned numCaptures = Record[Idx++];
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<BlockDecl::Capture, 16> captures;
A few more tweaks to the blocks AST representation: - BlockDeclRefExprs always store VarDecls - BDREs no longer store copy expressions - BlockDecls now store a list of captured variables, information about how they're captured, and a copy expression if necessary With that in hand, change IR generation to use the captures data in blocks instead of walking the block independently. Additionally, optimize block layout by emitting fields in descending alignment order, with a heuristic for filling in words when alignment of the end of the block header is insufficient for the most aligned field. llvm-svn: 125005
2011-02-07 18:33:21 +08:00
captures.reserve(numCaptures);
for (unsigned i = 0; i != numCaptures; ++i) {
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
VarDecl *decl = ReadDeclAs<VarDecl>(Record, Idx);
A few more tweaks to the blocks AST representation: - BlockDeclRefExprs always store VarDecls - BDREs no longer store copy expressions - BlockDecls now store a list of captured variables, information about how they're captured, and a copy expression if necessary With that in hand, change IR generation to use the captures data in blocks instead of walking the block independently. Additionally, optimize block layout by emitting fields in descending alignment order, with a heuristic for filling in words when alignment of the end of the block header is insufficient for the most aligned field. llvm-svn: 125005
2011-02-07 18:33:21 +08:00
unsigned flags = Record[Idx++];
bool byRef = (flags & 1);
bool nested = (flags & 2);
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
Expr *copyExpr = ((flags & 4) ? Reader.ReadExpr(F) : nullptr);
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.push_back(BlockDecl::Capture(decl, byRef, nested, copyExpr));
}
[AST] ArrayRefize BlockDecl::setCaptures. No functionality change intended. llvm-svn: 244027
2015-08-05 17:40:35 +08:00
BD->setCaptures(Reader.getContext(), captures, capturesCXXThis);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Serialization for captured statements Add serialization for captured statements and captured decls. Also add a const_capture_iterator to CapturedStmt. Test contributed by Wei Pan Differential Revision: http://llvm-reviews.chandlerc.com/D727 llvm-svn: 181048
2013-05-04 03:20:19 +08:00
void ASTDeclReader::VisitCapturedDecl(CapturedDecl *CD) {
VisitDecl(CD);
[OPENMP] Initial codegen for '#pragma omp parallel' llvm-svn: 208077
2014-05-06 18:08:46 +08:00
unsigned ContextParamPos = Record[Idx++];
CD->setNothrow(Record[Idx++] != 0);
Serialization for captured statements Add serialization for captured statements and captured decls. Also add a const_capture_iterator to CapturedStmt. Test contributed by Wei Pan Differential Revision: http://llvm-reviews.chandlerc.com/D727 llvm-svn: 181048
2013-05-04 03:20:19 +08:00
// Body is set by VisitCapturedStmt.
[OPENMP] Initial codegen for '#pragma omp parallel' llvm-svn: 208077
2014-05-06 18:08:46 +08:00
for (unsigned I = 0; I < CD->NumParams; ++I) {
if (I != ContextParamPos)
CD->setParam(I, ReadDeclAs<ImplicitParamDecl>(Record, Idx));
else
CD->setContextParam(I, ReadDeclAs<ImplicitParamDecl>(Record, Idx));
}
Sema for Captured Statements Add CapturedDecl to be the DeclContext for CapturedStmt, and perform semantic analysis. Currently captures all variables by reference. TODO: templates Author: Ben Langmuir <ben.langmuir@intel.com> Differential Revision: http://llvm-reviews.chandlerc.com/D433 llvm-svn: 179618
2013-04-17 03:37:38 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitLinkageSpecDecl(LinkageSpecDecl *D) {
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
VisitDecl(D);
D->setLanguage((LinkageSpecDecl::LanguageIDs)Record[Idx++]);
Fixed source range for StaticAssertDecl and LinkageSpecDecl. Fixed source range for declarations using postfix types. llvm-svn: 127251
2011-03-09 00:41:52 +08:00
D->setExternLoc(ReadSourceLocation(Record, Idx));
Fixed end source location for LinkageSpecDecl. llvm-svn: 126943
2011-03-03 22:52:38 +08:00
D->setRBraceLoc(ReadSourceLocation(Record, Idx));
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
}
Step #1/N of implementing support for __label__: split labels into LabelDecl and LabelStmt. There is a 1-1 correspondence between the two, but this simplifies a bunch of code by itself. This is because labels are the only place where we previously had references to random other statements, causing grief for AST serialization and other stuff. This does cause one regression (attr(unused) doesn't silence unused label warnings) which I'll address next. This does fix some minor bugs: 1. "The only valid attribute " diagnostic was capitalized. 2. Various diagnostics printed as ''labelname'' instead of 'labelname' 3. This reduces duplication of label checking between functions and blocks. Review appreciated, particularly for the cindex and template bits. llvm-svn: 125733
2011-02-17 15:39:24 +08:00
void ASTDeclReader::VisitLabelDecl(LabelDecl *D) {
VisitNamedDecl(D);
Fixed LabelDecl source range and cleaned creation code. llvm-svn: 127094
2011-03-06 02:21:20 +08:00
D->setLocStart(ReadSourceLocation(Record, Idx));
Step #1/N of implementing support for __label__: split labels into LabelDecl and LabelStmt. There is a 1-1 correspondence between the two, but this simplifies a bunch of code by itself. This is because labels are the only place where we previously had references to random other statements, causing grief for AST serialization and other stuff. This does cause one regression (attr(unused) doesn't silence unused label warnings) which I'll address next. This does fix some minor bugs: 1. "The only valid attribute " diagnostic was capitalized. 2. Various diagnostics printed as ''labelname'' instead of 'labelname' 3. This reduces duplication of label checking between functions and blocks. Review appreciated, particularly for the cindex and template bits. llvm-svn: 125733
2011-02-17 15:39:24 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitNamespaceDecl(NamespaceDecl *D) {
Switch NamespaceDecl from its own hand-rolled redeclaration chain over to Redeclarable<NamespaceDecl>, so that we benefit from the improveed redeclaration deserialization and merging logic provided by Redeclarable<T>. Otherwise, no functionality change. As a drive-by fix, collapse the "inline" bit into the low bit of the original namespace/anonymous namespace, saving 8 bytes per NamespaceDecl on x86_64. llvm-svn: 147729
2012-01-07 17:11:48 +08:00
RedeclarableResult Redecl = VisitRedeclarable(D);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
VisitNamedDecl(D);
Switch NamespaceDecl from its own hand-rolled redeclaration chain over to Redeclarable<NamespaceDecl>, so that we benefit from the improveed redeclaration deserialization and merging logic provided by Redeclarable<T>. Otherwise, no functionality change. As a drive-by fix, collapse the "inline" bit into the low bit of the original namespace/anonymous namespace, saving 8 bytes per NamespaceDecl on x86_64. llvm-svn: 147729
2012-01-07 17:11:48 +08:00
D->setInline(Record[Idx++]);
Fixed NamespaceDecl source range. llvm-svn: 127242
2011-03-08 20:38:20 +08:00
D->LocStart = ReadSourceLocation(Record, Idx);
D->RBraceLoc = ReadSourceLocation(Record, Idx);
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
[modules] Fix bug where an anonymous namespace could cause the containing namespace to not merge properly. We have an invariant here: after a declaration reads its canonical declaration, it can assume the canonical declaration is fully merged. This invariant can be violated if deserializing some declaration triggers the deserialization of a later declaration, because that later declaration can in turn deserialize a redeclaration of that first declaration before it is fully merged. The anonymous namespace for a namespace gets stored with the first declaration of that namespace, which may be before its parent namespace, so defer loading it until after we've finished merging the surrounding namespace. llvm-svn: 232455
2015-03-17 10:23:11 +08:00
// Defer loading the anonymous namespace until we've finished merging
// this namespace; loading it might load a later declaration of the
// same namespace, and we have an invariant that older declarations
// get merged before newer ones try to merge.
GlobalDeclID AnonNamespace = 0;
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) {
[modules] Fix bug where an anonymous namespace could cause the containing namespace to not merge properly. We have an invariant here: after a declaration reads its canonical declaration, it can assume the canonical declaration is fully merged. This invariant can be violated if deserializing some declaration triggers the deserialization of a later declaration, because that later declaration can in turn deserialize a redeclaration of that first declaration before it is fully merged. The anonymous namespace for a namespace gets stored with the first declaration of that namespace, which may be before its parent namespace, so defer loading it until after we've finished merging the surrounding namespace. llvm-svn: 232455
2015-03-17 10:23:11 +08:00
AnonNamespace = ReadDeclID(Record, Idx);
Switch NamespaceDecl from its own hand-rolled redeclaration chain over to Redeclarable<NamespaceDecl>, so that we benefit from the improveed redeclaration deserialization and merging logic provided by Redeclarable<T>. Otherwise, no functionality change. As a drive-by fix, collapse the "inline" bit into the low bit of the original namespace/anonymous namespace, saving 8 bytes per NamespaceDecl on x86_64. llvm-svn: 147729
2012-01-07 17:11:48 +08:00
} else {
// Link this namespace back to the first declaration, which has already
// been deserialized.
Rename some functions for consistency. Every other function in Redeclarable.h was using Decl instead of Declaration. llvm-svn: 192900
2013-10-17 23:37:26 +08:00
D->AnonOrFirstNamespaceAndInline.setPointer(D->getFirstDecl());
Switch NamespaceDecl from its own hand-rolled redeclaration chain over to Redeclarable<NamespaceDecl>, so that we benefit from the improveed redeclaration deserialization and merging logic provided by Redeclarable<T>. Otherwise, no functionality change. As a drive-by fix, collapse the "inline" bit into the low bit of the original namespace/anonymous namespace, saving 8 bytes per NamespaceDecl on x86_64. llvm-svn: 147729
2012-01-07 17:11:48 +08:00
}
[modules] Rearrange and unify the way we determine if we need to pull in redeclaration chains when pulling in a declaration. We need the redecl chain unless we know some other declaration will trigger it to be pulled in; that happens if our originally-canonical declaration had all the knowledge that we have (and isn't us). llvm-svn: 213043
2014-07-15 11:37:06 +08:00
mergeRedeclarable(D, Redecl);
[modules] Fix bug where an anonymous namespace could cause the containing namespace to not merge properly. We have an invariant here: after a declaration reads its canonical declaration, it can assume the canonical declaration is fully merged. This invariant can be violated if deserializing some declaration triggers the deserialization of a later declaration, because that later declaration can in turn deserialize a redeclaration of that first declaration before it is fully merged. The anonymous namespace for a namespace gets stored with the first declaration of that namespace, which may be before its parent namespace, so defer loading it until after we've finished merging the surrounding namespace. llvm-svn: 232455
2015-03-17 10:23:11 +08:00
if (AnonNamespace) {
// 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 = cast<NamespaceDecl>(Reader.GetDecl(AnonNamespace));
if (F.Kind != MK_ImplicitModule && F.Kind != MK_ExplicitModule)
D->setAnonymousNamespace(Anon);
}
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) {
[modules] Make NamespaceAliasDecl redeclarable, as it should be. This fixes merging of namespace aliases across modules and improves source fidelity. Incidentally also fixes PR20816. llvm-svn: 217103
2014-09-04 07:11:22 +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);
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);
[modules] Make NamespaceAliasDecl redeclarable, as it should be. This fixes merging of namespace aliases across modules and improves source fidelity. Incidentally also fixes PR20816. llvm-svn: 217103
2014-09-04 07:11:22 +08:00
mergeRedeclarable(D, Redecl);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitUsingDecl(UsingDecl *D) {
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
VisitNamedDecl(D);
Improve clarity/consistency of a few UsingDecl methods and related helpers. No functionality change. In Sema helper functions: * renamed isTypeName as HasTypenameKeyword In UsingDecl: * renamed get/setUsingLocation to get/setUsingLoc * renamed is/setTypeName as has/setTypename llvm-svn: 186816
2013-07-22 18:54:09 +08:00
D->setUsingLoc(ReadSourceLocation(Record, Idx));
Update UsingDecl, UnresolvedUsingTypenameDecl, and UnresolvedUsingValueDecl to use NestedNameSpecifierLoc rather than the extremely-lossy NestedNameSpecifier/SourceRange pair it used to use, improving source-location information. Various infrastructure updates to support NestedNameSpecifierLoc: - AST/PCH (de-)serialization - Recursive AST visitor - libclang traversal (including the first tests of this functionality) llvm-svn: 126459
2011-02-25 08:36:19 +08:00
D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
Read/write to/from PCH DeclarationNameLocs, DeclarationNameInfos and QualifierInfos (rdar://8513756). llvm-svn: 116598
2010-10-16 02:21:24 +08:00
ReadDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record, Idx);
Pack UsingDecl more. 88 -> 80 bytes on x86_64. llvm-svn: 147736
2012-01-08 03:09:05 +08:00
D->FirstUsingShadow.setPointer(ReadDeclAs<UsingShadowDecl>(Record, Idx));
Improve clarity/consistency of a few UsingDecl methods and related helpers. No functionality change. In Sema helper functions: * renamed isTypeName as HasTypenameKeyword In UsingDecl: * renamed get/setUsingLocation to get/setUsingLoc * renamed is/setTypeName as has/setTypename llvm-svn: 186816
2013-07-22 18:54:09 +08:00
D->setTypename(Record[Idx++]);
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
if (NamedDecl *Pattern = ReadDeclAs<NamedDecl>(Record, Idx))
In ASTReader, replace the never-NULL ASTContext pointer with an ASTContext reference. Remove all of the extra checking and logic that was used to cope with a NULL ASTContext. No effective functionality change. llvm-svn: 139413
2011-09-10 05:34:22 +08:00
Reader.getContext().setInstantiatedFromUsingDecl(D, Pattern);
[modules] Merging for class-scope using-declarations. llvm-svn: 219657
2014-10-14 10:00:47 +08:00
mergeMergeable(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
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitUsingShadowDecl(UsingShadowDecl *D) {
Make UsingShadowDecls redeclarable. This fixes some visibility problems with modules. With this fixed, I no longer see any test regressions in the libc++ test suite when enabling a single-module module.map for libc++ (other than issues with my system headers). llvm-svn: 193219
2013-10-23 10:17:46 +08:00
RedeclarableResult Redecl = VisitRedeclarable(D);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
VisitNamedDecl(D);
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
D->setTargetDecl(ReadDeclAs<NamedDecl>(Record, Idx));
D->UsingOrNextShadow = ReadDeclAs<NamedDecl>(Record, Idx);
UsingShadowDecl *Pattern = ReadDeclAs<UsingShadowDecl>(Record, Idx);
Read/write more information of ASTContext for PCH. Overriden methods and instantiated-from information. llvm-svn: 107597
2010-07-05 05:44:35 +08:00
if (Pattern)
In ASTReader, replace the never-NULL ASTContext pointer with an ASTContext reference. Remove all of the extra checking and logic that was used to cope with a NULL ASTContext. No effective functionality change. llvm-svn: 139413
2011-09-10 05:34:22 +08:00
Reader.getContext().setInstantiatedFromUsingShadowDecl(D, Pattern);
Make UsingShadowDecls redeclarable. This fixes some visibility problems with modules. With this fixed, I no longer see any test regressions in the libc++ test suite when enabling a single-module module.map for libc++ (other than issues with my system headers). llvm-svn: 193219
2013-10-23 10:17:46 +08:00
mergeRedeclarable(D, Redecl);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitUsingDirectiveDecl(UsingDirectiveDecl *D) {
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
VisitNamedDecl(D);
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
D->UsingLoc = ReadSourceLocation(Record, Idx);
D->NamespaceLoc = ReadSourceLocation(Record, Idx);
Push nested-name-specifier source location information into using directives. llvm-svn: 126489
2011-02-26 00:33:46 +08:00
D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
D->NominatedNamespace = ReadDeclAs<NamedDecl>(Record, Idx);
D->CommonAncestor = ReadDeclAs<DeclContext>(Record, Idx);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitUnresolvedUsingValueDecl(UnresolvedUsingValueDecl *D) {
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
VisitValueDecl(D);
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
D->setUsingLoc(ReadSourceLocation(Record, Idx));
Update UsingDecl, UnresolvedUsingTypenameDecl, and UnresolvedUsingValueDecl to use NestedNameSpecifierLoc rather than the extremely-lossy NestedNameSpecifier/SourceRange pair it used to use, improving source-location information. Various infrastructure updates to support NestedNameSpecifierLoc: - AST/PCH (de-)serialization - Recursive AST visitor - libclang traversal (including the first tests of this functionality) llvm-svn: 126459
2011-02-25 08:36:19 +08:00
D->QualifierLoc = Reader.ReadNestedNameSpecifierLoc(F, Record, Idx);
Read/write to/from PCH DeclarationNameLocs, DeclarationNameInfos and QualifierInfos (rdar://8513756). llvm-svn: 116598
2010-10-16 02:21:24 +08:00
ReadDeclarationNameLoc(D->DNLoc, D->getDeclName(), Record, Idx);
[modules] Merging for class-scope using-declarations. llvm-svn: 219657
2014-10-14 10:00:47 +08:00
mergeMergeable(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
}
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);
[modules] Merging for class-scope using-declarations. llvm-svn: 219657
2014-10-14 10:00:47 +08:00
mergeMergeable(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
}
Minor refactoring; Pull reading/writing DefinitionData out into a function. llvm-svn: 117233
2010-10-25 01:26:27 +08:00
void ASTDeclReader::ReadCXXDefinitionData(
Refactoring. - Pass around RecordDataImpl instead of the concrete RecordData so that any SmallVector can be used. - Move ASTDeclWriter::WriteCXXDefinitionData to ASTWriter::AddCXXDefinitionData. llvm-svn: 117236
2010-10-25 01:26:40 +08:00
struct CXXRecordDecl::DefinitionData &Data,
const RecordData &Record, unsigned &Idx) {
Implement AST (de-)serialization for lambda expressions. llvm-svn: 150491
2012-02-15 01:54:36 +08:00
// Note: the caller has deserialized the IsLambda bit already.
Minor refactoring; Pull reading/writing DefinitionData out into a function. llvm-svn: 117233
2010-10-25 01:26:27 +08:00
Data.UserDeclaredConstructor = Record[Idx++];
Refactor to reduce duplication in handling of special member functions. No functionality change. llvm-svn: 168977
2012-11-30 13:11:39 +08:00
Data.UserDeclaredSpecialMembers = Record[Idx++];
Minor refactoring; Pull reading/writing DefinitionData out into a function. llvm-svn: 117233
2010-10-25 01:26:27 +08:00
Data.Aggregate = Record[Idx++];
Data.PlainOldData = Record[Idx++];
Data.Empty = Record[Idx++];
Data.Polymorphic = Record[Idx++];
Data.Abstract = Record[Idx++];
Rename the last '[hH]asStandardLayout' entites to '[iI]sStandardLayout' based on Doug's preferences when we discussed this in IRC. This brings the wording more in line with the standard. llvm-svn: 130603
2011-04-30 18:07:30 +08:00
Data.IsStandardLayout = Record[Idx++];
Completely re-implement the core logic behind the __is_standard_layout type trait. The previous implementation suffered from several problems: 1) It implemented all of the logic in RecordType by walking over every base and field in a CXXRecordDecl and validating the constraints of the standard. This made for very straightforward code, but is extremely inefficient. It also is conceptually wrong, the logic tied to the C++ definition of standard-layout classes should be in CXXRecordDecl, not RecordType. 2) To address the performance problems with #1, a cache bit was added to CXXRecordDecl, and at the completion of every C++ class, the RecordType was queried to determine if it was a standard layout class, and that state was cached. Two things went very very wrong with this. First, the caching version of the query *was never called*. Even within the recursive steps of the walk over all fields and bases the caching variant was not called, making each query a full *recursive* walk. Second, despite the cache not being used, it was computed for every class declared, even when the trait was never used in the program. This probably significantly regressed compile time performance for edge-case files. 3) An ASTContext was required merely to query the type trait because querying it performed the actual computations. 4) The caching bit wasn't managed correctly (uninitialized). The new implementation follows the system for all the other traits on C++ classes by encoding all the state needed in the definition data and building up the trait incrementally as each base and member are added to the definition of the class. The idiosyncracies of the specification of standard-layout classes requires more state than I would like; currently 5 bits. I could eliminate one of the bits easily at the expense of both clarity and resilience of the code. I might be able to eliminate one of the other bits by computing its state in terms of other state bits in the definition. I've already done that in one place where there was a fairly simple way to achieve it. It's possible some of the bits could be moved out of the definition data and into some other structure which isn't serialized if the serialized bloat is a problem. That would preclude serialization of a partial class declaration, but that's likely already precluded. Comments on any of these issues welcome. llvm-svn: 130601
2011-04-30 17:17:45 +08:00
Data.HasNoNonEmptyBases = Record[Idx++];
Data.HasPrivateFields = Record[Idx++];
Data.HasProtectedFields = Record[Idx++];
Data.HasPublicFields = Record[Idx++];
When determining whether we can make a declaration into a global constant, also consider whether it's a class type that has any mutable fields. If so, it can't be a global constant. llvm-svn: 131276
2011-05-13 09:05:07 +08:00
Data.HasMutableFields = Record[Idx++];
Implement DR1460: fix handling of default initializers in unions; don't allow more than one such initializer in a union, make mem-initializers override default initializers for other union members, handle anonymous unions with anonymous struct members better. Fix a couple of semi-related bugs exposed by the tests for same. llvm-svn: 196892
2013-12-10 16:25:00 +08:00
Data.HasVariantMembers = Record[Idx++];
Teach CXXRecordDecl::hasIrrelevantDestructor to check the base classes and data members for deleted or user-provided destructors. Now it's computed in advance, serialize it, and in passing fix all the other record DefinitionData flags whose serialization was missing. llvm-svn: 151441
2012-02-25 15:33:38 +08:00
Data.HasOnlyCMembers = Record[Idx++];
A union can have a constexpr defaulted default constructor, if it has an in-class initializer for one of its fields. Value-initialization of such a type should use the in-class initializer! The former was just a bug, the latter is a (reported) standard defect. llvm-svn: 156274
2012-05-07 09:07:30 +08:00
Data.HasInClassInitializer = Record[Idx++];
Implement C++03 [dcl.init]p5's checking for value-initialization of references properly, rather than faking it up by pretending that a reference member makes the default constructor non-trivial. That leads to rejects-valids when putting such types inside unions. llvm-svn: 169662
2012-12-08 10:01:17 +08:00
Data.HasUninitializedReferenceMember = Record[Idx++];
Implement the likely resolution of core issue 253. C++11 requires const objects to have a user-provided constructor, even for classes without any fields. DR 253 relaxes this to say "If the implicit default constructor initializes all subobjects, no initializer should be required." clang is currently the only compiler that implements this C++11 rule, and e.g. libstdc++ relies on something like DR 253 to compile in newer versions. This change makes it possible to build code that says `const vector<int> v;' again when using libstdc++5.2 and _GLIBCXX_DEBUG (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=60284). Fixes PR23381. http://reviews.llvm.org/D16552 llvm-svn: 261297
2016-02-19 09:52:46 +08:00
Data.HasUninitializedFields = Record[Idx++];
Finish implementing 'selected constructor' rules for triviality in C++11. In the cases where we can't determine whether special members would be trivial while building the class, we eagerly declare those special members. The impact of this is bounded, since it does not trigger implicit declarations of special members in classes which merely *use* those classes. In order to determine whether we need to apply this rule, we also need to eagerly declare move operations and destructors in cases where they might be deleted. If a move operation were supposed to be deleted, it would instead be suppressed, and we could need overload resolution to determine if we fall back to a trivial copy operation. If a destructor were implicitly deleted, it would cause the move constructor of any derived classes to be suppressed. As discussed on cxx-abi-dev, C++11's selected constructor rules are also retroactively applied as a defect resolution in C++03 mode, in order to identify that class B has a non-trivial copy constructor (since it calls A's constructor template, not A's copy constructor): struct A { template<typename T> A(T &); }; struct B { mutable A a; }; llvm-svn: 169673
2012-12-08 16:32:28 +08:00
Data.NeedOverloadResolutionForMoveConstructor = Record[Idx++];
Data.NeedOverloadResolutionForMoveAssignment = Record[Idx++];
Data.NeedOverloadResolutionForDestructor = Record[Idx++];
Data.DefaultedMoveConstructorIsDeleted = Record[Idx++];
Data.DefaultedMoveAssignmentIsDeleted = Record[Idx++];
Data.DefaultedDestructorIsDeleted = Record[Idx++];
Refactor to reduce duplication in handling of special member functions. No functionality change. llvm-svn: 168977
2012-11-30 13:11:39 +08:00
Data.HasTrivialSpecialMembers = Record[Idx++];
Add missing serialization code for one of the CXXRecordDecl definition flags. llvm-svn: 206493
2014-04-18 04:33:01 +08:00
Data.DeclaredNonTrivialSpecialMembers = Record[Idx++];
Refactor to reduce duplication in handling of special member functions. No functionality change. llvm-svn: 168977
2012-11-30 13:11:39 +08:00
Data.HasIrrelevantDestructor = Record[Idx++];
Renamings to consistently use 'Constexpr' not 'ConstExpr' when referring to the C++0x 'constexpr' keyword. llvm-svn: 137230
2011-08-11 02:11:37 +08:00
Data.HasConstexprNonCopyMoveConstructor = Record[Idx++];
Fix rejects-valid caused by r261297. r261297 called hasUserProvidedDefaultConstructor() to check if defining a const object is ok. This is incorrect for this example: struct X { template<typename ...T> X(T...); int n; }; const X x; // formerly OK, now bogus error Instead, track if a class has a defaulted default constructor, and disallow a const object for classes that either have defaulted default constructors or if they need an implicit constructor. Bug report and fix approach by Richard Smith, thanks! llvm-svn: 261770
2016-02-25 04:58:14 +08:00
Data.HasDefaultedDefaultConstructor = Record[Idx++];
Teach CXXRecordDecl::hasIrrelevantDestructor to check the base classes and data members for deleted or user-provided destructors. Now it's computed in advance, serialize it, and in passing fix all the other record DefinitionData flags whose serialization was missing. llvm-svn: 151441
2012-02-25 15:33:38 +08:00
Data.DefaultedDefaultConstructorIsConstexpr = Record[Idx++];
Data.HasConstexprDefaultConstructor = Record[Idx++];
Implement most of the remaining logic in __is_literal type trait. This should now support all of the C++98 types, and all of the C++0x types Clang supports. llvm-svn: 130079
2011-04-24 10:49:34 +08:00
Data.HasNonLiteralTypeFieldsOrBases = Record[Idx++];
Minor refactoring; Pull reading/writing DefinitionData out into a function. llvm-svn: 117233
2010-10-25 01:26:27 +08:00
Data.ComputedVisibleConversions = Record[Idx++];
Implement implicit deletion of default constructors. Yes, I'm aware that the diagnostics are awful. Tests to follow. llvm-svn: 131203
2011-05-12 06:34:38 +08:00
Data.UserProvidedDefaultConstructor = Record[Idx++];
Refactor to reduce duplication in handling of special member functions. No functionality change. llvm-svn: 168977
2012-11-30 13:11:39 +08:00
Data.DeclaredSpecialMembers = Record[Idx++];
Store on the CXXRecordDecl whether the class has, or would have, a copy constructor/assignment operator with a const-qualified parameter type. The prior method for determining this incorrectly used overload resolution. llvm-svn: 168775
2012-11-28 14:23:12 +08:00
Data.ImplicitCopyConstructorHasConstParam = Record[Idx++];
Data.ImplicitCopyAssignmentHasConstParam = Record[Idx++];
Data.HasDeclaredCopyConstructorWithConstParam = Record[Idx++];
Data.HasDeclaredCopyAssignmentWithConstParam = Record[Idx++];
Serialize and deserialize IsMarkedFinal/IsMarkedExplicit. llvm-svn: 124041
2011-01-23 02:11:02 +08:00
Minor refactoring; Pull reading/writing DefinitionData out into a function. llvm-svn: 117233
2010-10-25 01:26:27 +08:00
Data.NumBases = Record[Idx++];
Make the deserialization of C++ base class specifiers lazy, improving the performance of C++ PCH and reducing stack depth in the reader. llvm-svn: 117732
2010-10-30 06:39:52 +08:00
if (Data.NumBases)
Don't introduce a local -> global mapping for CXXBaseSpecifiers. The IDs will never cross module boundaries, since they're tied to the CXXDefinitionData, so just use a local mapping throughout. Eliminate the global -> local tables and supporting data. llvm-svn: 136847
2011-08-04 08:01:48 +08:00
Data.Bases = Reader.readCXXBaseSpecifiers(F, Record, Idx);
Minor refactoring; Pull reading/writing DefinitionData out into a function. llvm-svn: 117233
2010-10-25 01:26:27 +08:00
Data.NumVBases = Record[Idx++];
Make the deserialization of C++ base class specifiers lazy, improving the performance of C++ PCH and reducing stack depth in the reader. llvm-svn: 117732
2010-10-30 06:39:52 +08:00
if (Data.NumVBases)
Don't introduce a local -> global mapping for CXXBaseSpecifiers. The IDs will never cross module boundaries, since they're tied to the CXXDefinitionData, so just use a local mapping throughout. Eliminate the global -> local tables and supporting data. llvm-svn: 136847
2011-08-04 08:01:48 +08:00
Data.VBases = Reader.readCXXBaseSpecifiers(F, Record, Idx);
Make the deserialization of C++ base class specifiers lazy, improving the performance of C++ PCH and reducing stack depth in the reader. llvm-svn: 117732
2010-10-30 06:39:52 +08:00
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
Reader.ReadUnresolvedSet(F, Data.Conversions, Record, Idx);
Reader.ReadUnresolvedSet(F, Data.VisibleConversions, Record, Idx);
Minor refactoring; Pull reading/writing DefinitionData out into a function. llvm-svn: 117233
2010-10-25 01:26:27 +08:00
assert(Data.Definition && "Data.Definition should be already set!");
Map from local decl IDs to global decl IDs when lazily deserializing friend decl chains. llvm-svn: 189629
2013-08-30 08:23:29 +08:00
Data.FirstFriend = ReadDeclID(Record, Idx);
Implement AST (de-)serialization for lambda expressions. llvm-svn: 150491
2012-02-15 01:54:36 +08:00
if (Data.IsLambda) {
Decouple ExprCXX.h and DeclCXX.h and clean up includes a bit. Required pulling LambdaExpr::Capture into its own header. No functionality change. llvm-svn: 208470
2014-05-11 00:31:55 +08:00
typedef LambdaCapture Capture;
Implement AST (de-)serialization for lambda expressions. llvm-svn: 150491
2012-02-15 01:54:36 +08:00
CXXRecordDecl::LambdaDefinitionData &Lambda
= static_cast<CXXRecordDecl::LambdaDefinitionData &>(Data);
Improve our handling of lambda expressions that occur within default arguments. There are two aspects to this: - Make sure that when marking the declarations referenced in a default argument, we don't try to mark local variables, both because it's a waste of time and because the semantics are wrong: we're not in a place where we could capture these variables again even if it did make sense. - When a lambda expression occurs in a default argument of a function template, make sure that the corresponding closure type is considered dependent, so that it will get properly instantiated. The second bit is a bit of a hack; to fix it properly, we may have to rearchitect our handling of default arguments, parsing them only after creating the function definition. However, I'd like to separate that work from the lambdas work. llvm-svn: 151076
2012-02-22 03:11:17 +08:00
Lambda.Dependent = Record[Idx++];
Refactor out the circular reference to LambdaExpr in CXXRecordDecl. A prior commit of this patch was reverted because it was within the blamelist's purview of a failing test. The failure of that test has been addressed here: http://lists.cs.uiuc.edu/pipermail/cfe-commits/Week-of-Mon-20131021/091546.html. Therefore I am recommitting this patch (all tests pass on windows, except for the usual modules & index suspects that never pass on my box). Some background: Both Doug and Richard had asked me in Chicago to remove the circular reference in CXXRecordDecl to LambdaExpr by factoring out and storing the needed information from LambdaExpr directly into CXXRecordDecl. In addition, I have added an IsGenericLambda flag - this makes life a little easier when we implement capturing, and are Sema-analyzing the body of a lambda (and the calloperator hasn't been wired to the closure class yet). Any inner lambdas can have potential captures that could require walking up the scope chain and checking if any generic lambdas are capture-ready. This 'bit' makes some of that checking easier. No change in functionality. This patch was approved by Doug with minor modifications (comments were cleaned up, and all data members were converted from bool/enum to unsigned, as requested): http://llvm-reviews.chandlerc.com/D1856 Thanks! llvm-svn: 193246
2013-10-24 00:10:50 +08:00
Lambda.IsGenericLambda = Record[Idx++];
Lambda.CaptureDefault = Record[Idx++];
Implement AST (de-)serialization for lambda expressions. llvm-svn: 150491
2012-02-15 01:54:36 +08:00
Lambda.NumCaptures = Record[Idx++];
Lambda.NumExplicitCaptures = Record[Idx++];
Basic support for name mangling of C++11 lambda expressions. Because name mangling in the Itanium C++ ABI for lambda expressions is so dependent on context, we encode the number used to encode each lambda as part of the lambda closure type, and maintain this value within Sema. Note that there are a several pieces still missing: - We still get the linkage of lambda expressions wrong - We aren't properly numbering or mangling lambda expressions that occur in default function arguments or in data member initializers. - We aren't (de-)serializing the lambda numbering tables llvm-svn: 150982
2012-02-21 03:44:39 +08:00
Lambda.ManglingNumber = Record[Idx++];
Implement name mangling for lambda expressions that occur within the default arguments of function parameters. This simple-sounding task is complicated greatly by two issues: (1) Default arguments aren't actually a real context, so we need to maintain extra state within lambda expressions to track when a lambda was actually in a default argument. (2) At the time that we parse a default argument, the FunctionDecl doesn't exist yet, so lambda closure types end up in the enclosing context. It's not clear that we ever want to change that, so instead we introduce the notion of the "effective" context of a declaration for the purposes of name mangling. llvm-svn: 151011
2012-02-21 08:37:24 +08:00
Lambda.ContextDecl = ReadDecl(Record, Idx);
Implement AST (de-)serialization for lambda expressions. llvm-svn: 150491
2012-02-15 01:54:36 +08:00
Lambda.Captures
= (Capture*)Reader.Context.Allocate(sizeof(Capture)*Lambda.NumCaptures);
Capture *ToCapture = Lambda.Captures;
Add the TypeSourceInfo for the lambda call operator to the lambda's definition info; it needs to be there because the mangler needs to access it before we're finished defining the lambda class. PR12808. llvm-svn: 164186
2012-09-19 09:18:11 +08:00
Lambda.MethodTyInfo = GetTypeSourceInfo(Record, Idx);
Implement AST (de-)serialization for lambda expressions. llvm-svn: 150491
2012-02-15 01:54:36 +08:00
for (unsigned I = 0, N = Lambda.NumCaptures; I != N; ++I) {
SourceLocation Loc = ReadSourceLocation(Record, Idx);
bool IsImplicit = Record[Idx++];
LambdaCaptureKind Kind = static_cast<LambdaCaptureKind>(Record[Idx++]);
First pass of semantic analysis for init-captures: check the initializer, build a FieldDecl from it, and propagate both into the closure type and the LambdaExpr. You can't do much useful with them yet -- you can't use them within the body of the lambda, because we don't have a representation for "the this of the lambda, not the this of the enclosing context". We also don't have support or a representation for a nested capture of an init-capture yet, which was intended to work despite not being allowed by the current standard wording. llvm-svn: 181985
2013-05-16 14:20:58 +08:00
switch (Kind) {
[Cxx1z] Implement Lambda Capture of *this by Value as [=,*this] (P0018R3) Implement lambda capture of *this by copy. For e.g.: struct A { int d = 10; auto foo() { return [*this] (auto a) mutable { d+=a; return d; }; } }; auto L = A{}.foo(); // A{}'s lifetime is gone. // Below is still ok, because *this was captured by value. assert(L(10) == 20); assert(L(100) == 120); If the capture was implicit, or [this] (i.e. *this was captured by reference), this code would be otherwise undefined. Implementation Strategy: - amend the parser to accept *this in the lambda introducer - add a new king of capture LCK_StarThis - teach Sema::CheckCXXThisCapture to handle by copy captures of the enclosing object (i.e. *this) - when CheckCXXThisCapture does capture by copy, the corresponding initializer expression for the closure's data member direct-initializes it thus making a copy of '*this'. - in codegen, when assigning to CXXThisValue, if *this was captured by copy, make sure it points to the corresponding field member, and not, unlike when captured by reference, what the field member points to. - mark feature as implemented in svn Much gratitude to Richard Smith for his carefully illuminating reviews! llvm-svn: 263921
2016-03-21 17:25:37 +08:00
case LCK_StarThis:
First pass of semantic analysis for init-captures: check the initializer, build a FieldDecl from it, and propagate both into the closure type and the LambdaExpr. You can't do much useful with them yet -- you can't use them within the body of the lambda, because we don't have a representation for "the this of the lambda, not the this of the enclosing context". We also don't have support or a representation for a nested capture of an init-capture yet, which was intended to work despite not being allowed by the current standard wording. llvm-svn: 181985
2013-05-16 14:20:58 +08:00
case LCK_This:
[C++11] Support for capturing of variable length arrays in lambda expression. Differential Revision: http://reviews.llvm.org/D4368 llvm-svn: 216649
2014-08-28 12:28:19 +08:00
case LCK_VLAType:
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
*ToCapture++ = Capture(Loc, IsImplicit, Kind, nullptr,SourceLocation());
First pass of semantic analysis for init-captures: check the initializer, build a FieldDecl from it, and propagate both into the closure type and the LambdaExpr. You can't do much useful with them yet -- you can't use them within the body of the lambda, because we don't have a representation for "the this of the lambda, not the this of the enclosing context". We also don't have support or a representation for a nested capture of an init-capture yet, which was intended to work despite not being allowed by the current standard wording. llvm-svn: 181985
2013-05-16 14:20:58 +08:00
break;
case LCK_ByCopy:
Per latest drafting, switch to implementing init-captures as if by declaring and capturing a variable declaration, and complete the implementation of them. llvm-svn: 191605
2013-09-28 12:02:39 +08:00
case LCK_ByRef:
First pass of semantic analysis for init-captures: check the initializer, build a FieldDecl from it, and propagate both into the closure type and the LambdaExpr. You can't do much useful with them yet -- you can't use them within the body of the lambda, because we don't have a representation for "the this of the lambda, not the this of the enclosing context". We also don't have support or a representation for a nested capture of an init-capture yet, which was intended to work despite not being allowed by the current standard wording. llvm-svn: 181985
2013-05-16 14:20:58 +08:00
VarDecl *Var = ReadDeclAs<VarDecl>(Record, Idx);
SourceLocation EllipsisLoc = ReadSourceLocation(Record, Idx);
*ToCapture++ = Capture(Loc, IsImplicit, Kind, Var, EllipsisLoc);
break;
}
Implement AST (de-)serialization for lambda expressions. llvm-svn: 150491
2012-02-15 01:54:36 +08:00
}
}
Minor refactoring; Pull reading/writing DefinitionData out into a function. llvm-svn: 117233
2010-10-25 01:26:27 +08:00
}
When a module completes the definition of a class template specialization imported from another module, emit an update record, rather than using the broken decl rewriting mechanism. If multiple modules do this, merge the definitions together, much as we would if they were separate declarations. llvm-svn: 206680
2014-04-19 11:48:30 +08:00
void ASTDeclReader::MergeDefinitionData(
[modules] Sometimes we can deserialize a class member but not have yet encountered any definition for the class; this happens when the definition is added by an update record that is not yet loaded. In such a case, eagerly pick the original parent of the member as the canonical definition of the class rather than muddling through with the canonical declaration (the latter can lead to us failing to merge properly later if the canonical definition turns out to be some other declaration). llvm-svn: 226977
2015-01-24 09:07:20 +08:00
CXXRecordDecl *D, struct CXXRecordDecl::DefinitionData &&MergeDD) {
If a declaration is loaded, and then a module import adds a redeclaration, then ensure that querying the first declaration for its most recent declaration checks for redeclarations from the imported module. This works as follows: * The 'most recent' pointer on a canonical declaration grows a pointer to the external AST source and a generation number (space- and time-optimized for the case where there is no external source). * Each time the 'most recent' pointer is queried, if it has an external source, we check whether it's up to date, and update it if not. * The ancillary data stored on the canonical declaration is allocated lazily to avoid filling it in for declarations that end up being non-canonical. We'll still perform a redundant (ASTContext) allocation if someone asks for the most recent declaration from a decl before setPreviousDecl is called, but such cases are probably all bugs, and are now easy to find. Some finessing is still in order here -- in particular, we use a very general mechanism for handling the DefinitionData pointer on CXXRecordData, and a more targeted approach would be more compact. Also, the MayHaveOutOfDateDef mechanism should now be expunged, since it was addressing only a corner of the full problem space here. That's not covered by this patch. Early performance benchmarks show that this makes no measurable difference to Clang performance without modules enabled (and fixes a major correctness issue with modules enabled). I'll revert if a full performance comparison shows any problems. llvm-svn: 209046
2014-05-17 07:01:30 +08:00
assert(D->DefinitionData.getNotUpdated() &&
"merging class definition into non-definition");
auto &DD = *D->DefinitionData.getNotUpdated();
When a module completes the definition of a class template specialization imported from another module, emit an update record, rather than using the broken decl rewriting mechanism. If multiple modules do this, merge the definitions together, much as we would if they were separate declarations. llvm-svn: 206680
2014-04-19 11:48:30 +08:00
[modules] When merging class definitions, make the retained definition visible if the merged definition is visible, and perform lookups into all merged copies of the definition (not just for special members) so that we can complete the redecl chains for members of the class. llvm-svn: 233420
2015-03-28 05:16:39 +08:00
if (DD.Definition != MergeDD.Definition) {
[modules] Refactor and slightly simplify class definition merging. llvm-svn: 240200
2015-06-20 08:22:34 +08:00
// Track that we merged the definitions.
Reader.MergedDeclContexts.insert(std::make_pair(MergeDD.Definition,
DD.Definition));
Reader.PendingDefinitions.erase(MergeDD.Definition);
MergeDD.Definition->IsCompleteDefinition = false;
[modules] Ensure that if we merge the definitions of two enumerations, that making either of them visible makes the merged definition visible. llvm-svn: 239969
2015-06-18 07:07:50 +08:00
mergeDefinitionVisibility(DD.Definition, MergeDD.Definition);
Re-commit r246497 (and dependent changes r246524 and r246521), reverted in r246546, with a workaround for an MSVC 2013 miscompile and an MSVC 2015 rejects-valid. Original commit message: [modules] Rework serialized DeclContext lookup table management. Instead of walking the loaded ModuleFiles looking for lookup tables for the context, store them all in one place, and merge them together if we find we have too many (currently, more than 4). If we do merge, include the merged form in our serialized lookup table, so that downstream readers never need to look at our imports' tables. This gives a huge performance improvement to builds with very large numbers of modules (in some cases, more than a 2x speedup was observed). llvm-svn: 246582
2015-09-02 04:35:42 +08:00
assert(Reader.Lookups.find(MergeDD.Definition) == Reader.Lookups.end() &&
"already loaded pending lookups for merged definition");
[modules] When merging class definitions, make the retained definition visible if the merged definition is visible, and perform lookups into all merged copies of the definition (not just for special members) so that we can complete the redecl chains for members of the class. llvm-svn: 233420
2015-03-28 05:16:39 +08:00
}
[modules] Be sure to load the lexical definition of a class template specialization from an update record exactly once, even if we needed to fake up the definition. llvm-svn: 227939
2015-02-03 11:32:14 +08:00
auto PFDI = Reader.PendingFakeDefinitionData.find(&DD);
if (PFDI != Reader.PendingFakeDefinitionData.end() &&
PFDI->second == ASTReader::PendingFakeDefinitionKind::Fake) {
[modules] Sometimes we can deserialize a class member but not have yet encountered any definition for the class; this happens when the definition is added by an update record that is not yet loaded. In such a case, eagerly pick the original parent of the member as the canonical definition of the class rather than muddling through with the canonical declaration (the latter can lead to us failing to merge properly later if the canonical definition turns out to be some other declaration). llvm-svn: 226977
2015-01-24 09:07:20 +08:00
// We faked up this definition data because we found a class for which we'd
// not yet loaded the definition. Replace it with the real thing now.
assert(!DD.IsLambda && !MergeDD.IsLambda && "faked up lambda definition?");
[modules] Be sure to load the lexical definition of a class template specialization from an update record exactly once, even if we needed to fake up the definition. llvm-svn: 227939
2015-02-03 11:32:14 +08:00
PFDI->second = ASTReader::PendingFakeDefinitionKind::FakeLoaded;
[modules] Sometimes we can deserialize a class member but not have yet encountered any definition for the class; this happens when the definition is added by an update record that is not yet loaded. In such a case, eagerly pick the original parent of the member as the canonical definition of the class rather than muddling through with the canonical declaration (the latter can lead to us failing to merge properly later if the canonical definition turns out to be some other declaration). llvm-svn: 226977
2015-01-24 09:07:20 +08:00
// Don't change which declaration is the definition; that is required
// to be invariant once we select it.
auto *Def = DD.Definition;
DD = std::move(MergeDD);
DD.Definition = Def;
return;
}
When a module completes the definition of a class template specialization imported from another module, emit an update record, rather than using the broken decl rewriting mechanism. If multiple modules do this, merge the definitions together, much as we would if they were separate declarations. llvm-svn: 206680
2014-04-19 11:48:30 +08:00
// FIXME: Move this out into a .def file?
bool DetectedOdrViolation = false;
#define OR_FIELD(Field) DD.Field |= MergeDD.Field;
#define MATCH_FIELD(Field) \
DetectedOdrViolation |= DD.Field != MergeDD.Field; \
OR_FIELD(Field)
MATCH_FIELD(UserDeclaredConstructor)
MATCH_FIELD(UserDeclaredSpecialMembers)
MATCH_FIELD(Aggregate)
MATCH_FIELD(PlainOldData)
MATCH_FIELD(Empty)
MATCH_FIELD(Polymorphic)
MATCH_FIELD(Abstract)
MATCH_FIELD(IsStandardLayout)
MATCH_FIELD(HasNoNonEmptyBases)
MATCH_FIELD(HasPrivateFields)
MATCH_FIELD(HasProtectedFields)
MATCH_FIELD(HasPublicFields)
MATCH_FIELD(HasMutableFields)
MATCH_FIELD(HasVariantMembers)
MATCH_FIELD(HasOnlyCMembers)
MATCH_FIELD(HasInClassInitializer)
MATCH_FIELD(HasUninitializedReferenceMember)
Implement the likely resolution of core issue 253. C++11 requires const objects to have a user-provided constructor, even for classes without any fields. DR 253 relaxes this to say "If the implicit default constructor initializes all subobjects, no initializer should be required." clang is currently the only compiler that implements this C++11 rule, and e.g. libstdc++ relies on something like DR 253 to compile in newer versions. This change makes it possible to build code that says `const vector<int> v;' again when using libstdc++5.2 and _GLIBCXX_DEBUG (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=60284). Fixes PR23381. http://reviews.llvm.org/D16552 llvm-svn: 261297
2016-02-19 09:52:46 +08:00
MATCH_FIELD(HasUninitializedFields)
When a module completes the definition of a class template specialization imported from another module, emit an update record, rather than using the broken decl rewriting mechanism. If multiple modules do this, merge the definitions together, much as we would if they were separate declarations. llvm-svn: 206680
2014-04-19 11:48:30 +08:00
MATCH_FIELD(NeedOverloadResolutionForMoveConstructor)
MATCH_FIELD(NeedOverloadResolutionForMoveAssignment)
MATCH_FIELD(NeedOverloadResolutionForDestructor)
MATCH_FIELD(DefaultedMoveConstructorIsDeleted)
MATCH_FIELD(DefaultedMoveAssignmentIsDeleted)
MATCH_FIELD(DefaultedDestructorIsDeleted)
OR_FIELD(HasTrivialSpecialMembers)
OR_FIELD(DeclaredNonTrivialSpecialMembers)
MATCH_FIELD(HasIrrelevantDestructor)
OR_FIELD(HasConstexprNonCopyMoveConstructor)
Fix rejects-valid caused by r261297. r261297 called hasUserProvidedDefaultConstructor() to check if defining a const object is ok. This is incorrect for this example: struct X { template<typename ...T> X(T...); int n; }; const X x; // formerly OK, now bogus error Instead, track if a class has a defaulted default constructor, and disallow a const object for classes that either have defaulted default constructors or if they need an implicit constructor. Bug report and fix approach by Richard Smith, thanks! llvm-svn: 261770
2016-02-25 04:58:14 +08:00
OR_FIELD(HasDefaultedDefaultConstructor)
When a module completes the definition of a class template specialization imported from another module, emit an update record, rather than using the broken decl rewriting mechanism. If multiple modules do this, merge the definitions together, much as we would if they were separate declarations. llvm-svn: 206680
2014-04-19 11:48:30 +08:00
MATCH_FIELD(DefaultedDefaultConstructorIsConstexpr)
OR_FIELD(HasConstexprDefaultConstructor)
MATCH_FIELD(HasNonLiteralTypeFieldsOrBases)
// ComputedVisibleConversions is handled below.
MATCH_FIELD(UserProvidedDefaultConstructor)
OR_FIELD(DeclaredSpecialMembers)
MATCH_FIELD(ImplicitCopyConstructorHasConstParam)
MATCH_FIELD(ImplicitCopyAssignmentHasConstParam)
OR_FIELD(HasDeclaredCopyConstructorWithConstParam)
OR_FIELD(HasDeclaredCopyAssignmentWithConstParam)
MATCH_FIELD(IsLambda)
#undef OR_FIELD
#undef MATCH_FIELD
if (DD.NumBases != MergeDD.NumBases || DD.NumVBases != MergeDD.NumVBases)
DetectedOdrViolation = true;
// FIXME: Issue a diagnostic if the base classes don't match when we come
// to lazily load them.
// FIXME: Issue a diagnostic if the list of conversion functions doesn't
// match when we come to lazily load them.
if (MergeDD.ComputedVisibleConversions && !DD.ComputedVisibleConversions) {
DD.VisibleConversions = std::move(MergeDD.VisibleConversions);
DD.ComputedVisibleConversions = true;
}
// FIXME: Issue a diagnostic if FirstFriend doesn't match when we come to
// lazily load it.
if (DD.IsLambda) {
// FIXME: ODR-checking for merging lambdas (this happens, for instance,
// when they occur within the body of a function template specialization).
}
if (DetectedOdrViolation)
Reader.PendingOdrMergeFailures[DD.Definition].push_back(MergeDD.Definition);
}
[modules] Be sure to load the lexical definition of a class template specialization from an update record exactly once, even if we needed to fake up the definition. llvm-svn: 227939
2015-02-03 11:32:14 +08:00
void ASTDeclReader::ReadCXXRecordDefinition(CXXRecordDecl *D, bool Update) {
When a module completes the definition of a class template specialization imported from another module, emit an update record, rather than using the broken decl rewriting mechanism. If multiple modules do this, merge the definitions together, much as we would if they were separate declarations. llvm-svn: 206680
2014-04-19 11:48:30 +08:00
struct CXXRecordDecl::DefinitionData *DD;
ASTContext &C = Reader.getContext();
// Determine whether this is a lambda closure type, so that we can
// allocate the appropriate DefinitionData structure.
bool IsLambda = Record[Idx++];
if (IsLambda)
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
DD = new (C) CXXRecordDecl::LambdaDefinitionData(D, nullptr, false, false,
When a module completes the definition of a class template specialization imported from another module, emit an update record, rather than using the broken decl rewriting mechanism. If multiple modules do this, merge the definitions together, much as we would if they were separate declarations. llvm-svn: 206680
2014-04-19 11:48:30 +08:00
LCD_None);
else
DD = new (C) struct CXXRecordDecl::DefinitionData(D);
ReadCXXDefinitionData(*DD, Record, Idx);
[modules] It's possible to merge into the pattern of a class template before we load the definition data from the declaration itself. In that case, merge properly; don't assume the prior definition is the same as our own. llvm-svn: 226761
2015-01-22 09:41:56 +08:00
// We might already have a definition for this record. This can happen either
// because we're reading an update record, or because we've already done some
// merging. Either way, just merge into it.
[modules] Sometimes we can deserialize a class member but not have yet encountered any definition for the class; this happens when the definition is added by an update record that is not yet loaded. In such a case, eagerly pick the original parent of the member as the canonical definition of the class rather than muddling through with the canonical declaration (the latter can lead to us failing to merge properly later if the canonical definition turns out to be some other declaration). llvm-svn: 226977
2015-01-24 09:07:20 +08:00
CXXRecordDecl *Canon = D->getCanonicalDecl();
[modules] Refactor and slightly simplify class definition merging. llvm-svn: 240200
2015-06-20 08:22:34 +08:00
if (Canon->DefinitionData.getNotUpdated()) {
[modules] Sometimes we can deserialize a class member but not have yet encountered any definition for the class; this happens when the definition is added by an update record that is not yet loaded. In such a case, eagerly pick the original parent of the member as the canonical definition of the class rather than muddling through with the canonical declaration (the latter can lead to us failing to merge properly later if the canonical definition turns out to be some other declaration). llvm-svn: 226977
2015-01-24 09:07:20 +08:00
MergeDefinitionData(Canon, std::move(*DD));
D->DefinitionData = Canon->DefinitionData;
When a module completes the definition of a class template specialization imported from another module, emit an update record, rather than using the broken decl rewriting mechanism. If multiple modules do this, merge the definitions together, much as we would if they were separate declarations. llvm-svn: 206680
2014-04-19 11:48:30 +08:00
return;
}
[modules] Refactor and slightly simplify class definition merging. llvm-svn: 240200
2015-06-20 08:22:34 +08:00
// Mark this declaration as being a definition.
D->IsCompleteDefinition = true;
D->DefinitionData = DD;
If a declaration is loaded, and then a module import adds a redeclaration, then ensure that querying the first declaration for its most recent declaration checks for redeclarations from the imported module. This works as follows: * The 'most recent' pointer on a canonical declaration grows a pointer to the external AST source and a generation number (space- and time-optimized for the case where there is no external source). * Each time the 'most recent' pointer is queried, if it has an external source, we check whether it's up to date, and update it if not. * The ancillary data stored on the canonical declaration is allocated lazily to avoid filling it in for declarations that end up being non-canonical. We'll still perform a redundant (ASTContext) allocation if someone asks for the most recent declaration from a decl before setPreviousDecl is called, but such cases are probably all bugs, and are now easy to find. Some finessing is still in order here -- in particular, we use a very general mechanism for handling the DefinitionData pointer on CXXRecordData, and a more targeted approach would be more compact. Also, the MayHaveOutOfDateDef mechanism should now be expunged, since it was addressing only a corner of the full problem space here. That's not covered by this patch. Early performance benchmarks show that this makes no measurable difference to Clang performance without modules enabled (and fixes a major correctness issue with modules enabled). I'll revert if a full performance comparison shows any problems. llvm-svn: 209046
2014-05-17 07:01:30 +08:00
[modules] Refactor and slightly simplify class definition merging. llvm-svn: 240200
2015-06-20 08:22:34 +08:00
// If this is not the first declaration or is an update record, we can have
// other redeclarations already. Make a note that we need to propagate the
// DefinitionData pointer onto them.
if (Update || Canon != D) {
Canon->DefinitionData = D->DefinitionData;
If a declaration is loaded, and then a module import adds a redeclaration, then ensure that querying the first declaration for its most recent declaration checks for redeclarations from the imported module. This works as follows: * The 'most recent' pointer on a canonical declaration grows a pointer to the external AST source and a generation number (space- and time-optimized for the case where there is no external source). * Each time the 'most recent' pointer is queried, if it has an external source, we check whether it's up to date, and update it if not. * The ancillary data stored on the canonical declaration is allocated lazily to avoid filling it in for declarations that end up being non-canonical. We'll still perform a redundant (ASTContext) allocation if someone asks for the most recent declaration from a decl before setPreviousDecl is called, but such cases are probably all bugs, and are now easy to find. Some finessing is still in order here -- in particular, we use a very general mechanism for handling the DefinitionData pointer on CXXRecordData, and a more targeted approach would be more compact. Also, the MayHaveOutOfDateDef mechanism should now be expunged, since it was addressing only a corner of the full problem space here. That's not covered by this patch. Early performance benchmarks show that this makes no measurable difference to Clang performance without modules enabled (and fixes a major correctness issue with modules enabled). I'll revert if a full performance comparison shows any problems. llvm-svn: 209046
2014-05-17 07:01:30 +08:00
Reader.PendingDefinitions.insert(D);
When a module completes the definition of a class template specialization imported from another module, emit an update record, rather than using the broken decl rewriting mechanism. If multiple modules do this, merge the definitions together, much as we would if they were separate declarations. llvm-svn: 206680
2014-04-19 11:48:30 +08:00
}
}
Fix bitcode desynchronization when loading a PCH containing a class template specialization with modules enabled. Just don't merge them at all for now; we'll revisit this when support for template merging is added. In passing, make Decl::dump() a little safer to use with PCH/modules, by making it not deserialize any additional declarations. From a debugger you can call decls_begin() or similar first if you want to dump all child decls. llvm-svn: 182544
2013-05-23 09:49:11 +08:00
ASTDeclReader::RedeclarableResult
ASTDeclReader::VisitCXXRecordDeclImpl(CXXRecordDecl *D) {
RedeclarableResult Redecl = VisitRecordDeclImpl(D);
Fix issue with chained PCH where forward references did not pick up later definition in the chained PCH. llvm-svn: 116887
2010-10-20 08:11:15 +08:00
Now that deserializing a definition of a C++ class/Objective-C class/Objective-C protocol suffices get all of the redeclarations of that declaration wired to the definition, we no longer need to record the identity of the definition in every declaration. Instead, just record a bit to indicate whether a particular declaration is the definition. llvm-svn: 148224
2012-01-16 02:17:48 +08:00
ASTContext &C = Reader.getContext();
Fully read/write CXXRecordDecl for PCH. llvm-svn: 107475
2010-07-02 19:55:32 +08:00
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +08:00
enum CXXRecKind {
CXXRecNotTemplate = 0, CXXRecTemplate, CXXRecMemberSpecialization
};
switch ((CXXRecKind)Record[Idx++]) {
case CXXRecNotTemplate:
[modules] Don't try to merge template specializations by performing name lookup into their container; we won't find them there. These things are already being merged when they're added to their primary template's folding set, so this merging is redundant (and causes us to reject-valid because we think we've found an odr violation). llvm-svn: 212788
2014-07-11 08:20:06 +08:00
// Merged when we merge the folding set entry in the primary template.
if (!isa<ClassTemplateSpecializationDecl>(D))
mergeRedeclarable(D, Redecl);
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +08:00
break;
When two templates get merged together, also merge their pattern declarations together. This is extremely hairy, because in general we need to have loaded both the template and the pattern before we can determine whether either should be merged, so we temporarily violate the rule that all merging happens before reading a decl ends, but *only* in the case where a template's pattern is being loaded while loading the template itself. In order to accomodate this for class templates, delay loading the injected class name type for the pattern of the template until after we've loaded the template itself, if we happen to load the template first. llvm-svn: 207063
2014-04-24 10:25:27 +08:00
case CXXRecTemplate: {
// Merged when we merge the template.
ClassTemplateDecl *Template = ReadDeclAs<ClassTemplateDecl>(Record, Idx);
D->TemplateOrInstantiation = Template;
if (!Template->getTemplatedDecl()) {
// We've not actually loaded the ClassTemplateDecl yet, because we're
// currently being loaded as its pattern. Rely on it to set up our
// TypeForDecl (see VisitClassTemplateDecl).
//
// Beware: we do not yet know our canonical declaration, and may still
// get merged once the surrounding class template has got off the ground.
TypeIDForTypeDecl = 0;
}
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +08:00
break;
When two templates get merged together, also merge their pattern declarations together. This is extremely hairy, because in general we need to have loaded both the template and the pattern before we can determine whether either should be merged, so we temporarily violate the rule that all merging happens before reading a decl ends, but *only* in the case where a template's pattern is being loaded while loading the template itself. In order to accomodate this for class templates, delay loading the injected class name type for the pattern of the template until after we've loaded the template itself, if we happen to load the template first. llvm-svn: 207063
2014-04-24 10:25:27 +08:00
}
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +08:00
case CXXRecMemberSpecialization: {
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
CXXRecordDecl *RD = ReadDeclAs<CXXRecordDecl>(Record, Idx);
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +08:00
TemplateSpecializationKind TSK = (TemplateSpecializationKind)Record[Idx++];
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
SourceLocation POI = ReadSourceLocation(Record, Idx);
Avoid setters in ASTDeclReader::VisitCXXRecordDecl. llvm-svn: 113741
2010-09-13 19:45:25 +08:00
MemberSpecializationInfo *MSI = new (C) MemberSpecializationInfo(RD, TSK);
MSI->setPointOfInstantiation(POI);
D->TemplateOrInstantiation = MSI;
When a module completes the definition of a class template specialization imported from another module, emit an update record, rather than using the broken decl rewriting mechanism. If multiple modules do this, merge the definitions together, much as we would if they were separate declarations. llvm-svn: 206680
2014-04-19 11:48:30 +08:00
mergeRedeclarable(D, Redecl);
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +08:00
break;
}
}
Store in PCH the key function of C++ class to avoid deserializing the complete declaration context in order to compute it. Progress for rdar://7260160. llvm-svn: 116508
2010-10-15 04:14:38 +08:00
When a module completes the definition of a class template specialization imported from another module, emit an update record, rather than using the broken decl rewriting mechanism. If multiple modules do this, merge the definitions together, much as we would if they were separate declarations. llvm-svn: 206680
2014-04-19 11:48:30 +08:00
bool WasDefinition = Record[Idx++];
if (WasDefinition)
[modules] Be sure to load the lexical definition of a class template specialization from an update record exactly once, even if we needed to fake up the definition. llvm-svn: 227939
2015-02-03 11:32:14 +08:00
ReadCXXRecordDefinition(D, /*Update*/false);
When a module completes the definition of a class template specialization imported from another module, emit an update record, rather than using the broken decl rewriting mechanism. If multiple modules do this, merge the definitions together, much as we would if they were separate declarations. llvm-svn: 206680
2014-04-19 11:48:30 +08:00
else
// Propagate DefinitionData pointer from the canonical declaration.
D->DefinitionData = D->getCanonicalDecl()->DefinitionData;
Be lazier when loading KeyFunctions from PCH/modules. We don't need to load these in eagerly if we're not actually processing a translation unit. The added laziness here also avoids us loading in parts of a CXXRecordDecl earlier than an upcoming class template specialization merging patch would like. Ideally, we should mark the vtable as used when we see a definition for the key function, rather than having a separate pass over dynamic classes at the end of the TU. The existing approach is pretty bad for PCH/modules, since it forcibly loads the declarations of all key functions in all imported modules, whether or not those key functions are defined. llvm-svn: 189627
2013-08-30 07:59:27 +08:00
// Lazily load the key function to avoid deserializing every method so we can
Store in PCH the key function of C++ class to avoid deserializing the complete declaration context in order to compute it. Progress for rdar://7260160. llvm-svn: 116508
2010-10-15 04:14:38 +08:00
// compute it.
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
if (WasDefinition) {
DeclID KeyFn = ReadDeclID(Record, Idx);
if (KeyFn && D->IsCompleteDefinition)
Fix an iterator invalidation issue: deserializing a key function can write to the key functions table. Don't hold references to anything within that table across such an access. llvm-svn: 212437
2014-07-07 14:38:20 +08:00
// FIXME: This is wrong for the ARM ABI, where some other module may have
// made this function no longer be a key function. We need an update
// record or similar for that case.
Be lazier when loading KeyFunctions from PCH/modules. We don't need to load these in eagerly if we're not actually processing a translation unit. The added laziness here also avoids us loading in parts of a CXXRecordDecl earlier than an upcoming class template specialization merging patch would like. Ideally, we should mark the vtable as used when we see a definition for the key function, rather than having a separate pass over dynamic classes at the end of the TU. The existing approach is pretty bad for PCH/modules, since it forcibly loads the declarations of all key functions in all imported modules, whether or not those key functions are defined. llvm-svn: 189627
2013-08-30 07:59:27 +08:00
C.KeyFunctions[D] = KeyFn;
Store in PCH the key function of C++ class to avoid deserializing the complete declaration context in order to compute it. Progress for rdar://7260160. llvm-svn: 116508
2010-10-15 04:14:38 +08:00
}
Fix bitcode desynchronization when loading a PCH containing a class template specialization with modules enabled. Just don't merge them at all for now; we'll revisit this when support for template merging is added. In passing, make Decl::dump() a little safer to use with PCH/modules, by making it not deserialize any additional declarations. From a debugger you can call decls_begin() or similar first if you want to dump all child decls. llvm-svn: 182544
2013-05-23 09:49:11 +08:00
return Redecl;
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitCXXMethodDecl(CXXMethodDecl *D) {
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
VisitFunctionDecl(D);
[modules] Don't assert when merging virtual functions that override other functions. Also don't needlessly pull in non-canonical declarations of the overridden virtual functions. llvm-svn: 216503
2014-08-27 07:29:11 +08:00
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++];
[modules] Don't assert when merging virtual functions that override other functions. Also don't needlessly pull in non-canonical declarations of the overridden virtual functions. llvm-svn: 216503
2014-08-27 07:29:11 +08:00
if (D->isCanonicalDecl()) {
while (NumOverridenMethods--) {
// Avoid invariant checking of CXXMethodDecl::addOverriddenMethod,
// MD may be initializing.
if (CXXMethodDecl *MD = ReadDeclAs<CXXMethodDecl>(Record, Idx))
Reader.getContext().addOverriddenMethod(D, MD->getCanonicalDecl());
}
} else {
// We don't care about which declarations this used to override; we get
// the relevant information from the canonical declaration.
Idx += NumOverridenMethods;
Read/write more information of ASTContext for PCH. Overriden methods and instantiated-from information. llvm-svn: 107597
2010-07-05 05:44:35 +08:00
}
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitCXXConstructorDecl(CXXConstructorDecl *D) {
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
VisitCXXMethodDecl(D);
Fix PR18307: Properly (de)serialize inherited constructors and their using declarations Reviewed in http://llvm-reviews.chandlerc.com/D3102 llvm-svn: 204951
2014-03-28 03:22:19 +08:00
if (auto *CD = ReadDeclAs<CXXConstructorDecl>(Record, Idx))
[modules] For an inheriting constructor, the inherited constructor is stored in a map keyed off the canonical declaration. Don't try to set it if we're loading some non-canonical merged declaration. llvm-svn: 230716
2015-02-27 09:57:00 +08:00
if (D->isCanonicalDecl())
[Modules] Fix tiny bug where we failed to get the canonical decl when deserializing an inherited constructor. This is the exact same logic we use when deserializing method overrides for the same reason: the canonical decl may end up pinned to a different decl when we are improting modules, we need to re-pin to the canonical one during reading. My test case for this will come in a subsequent commit. I was trying to test a more tricky bug fix and the test case happened to tickle this bug as well. llvm-svn: 233325
2015-03-27 06:22:22 +08:00
D->setInheritedConstructor(CD->getCanonicalDecl());
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
}
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
[modules] Don't clobber a destructor's operator delete when adding another one; move the operator delete updating into a separate update record so we can cope with updating another module's destructor's operator delete. llvm-svn: 231735
2015-03-10 09:41:22 +08:00
if (auto *OperatorDelete = ReadDeclAs<FunctionDecl>(Record, Idx)) {
auto *Canon = cast<CXXDestructorDecl>(D->getCanonicalDecl());
// FIXME: Check consistency if we have an old and new operator delete.
if (!Canon->OperatorDelete)
Canon->OperatorDelete = OperatorDelete;
}
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++]);
[TrailingObjects] Convert Decl* classes. Also remove now-redundant explicit alignment specification on some of the classes converted prior to TrailingObjects automatically ensuring proper alignment. llvm-svn: 256585
2015-12-30 06:13:13 +08:00
SourceLocation *StoredLocs = D->getTrailingObjects<SourceLocation>();
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
for (unsigned I = 0, N = Record.back(); I != N; ++I)
StoredLocs[I] = ReadSourceLocation(Record, Idx);
[PCH] Fix serialization of an ImportDecl. ImportDecl's module ID was not written out and the reader accepted as module ID the serialized: Record.push_back(!IdentifierLocs.empty()); llvm-svn: 165087
2012-10-03 09:58:45 +08:00
++Idx; // The number of stored source locations.
Introduce a module import declaration, so that we properly represent, e.g., __import_module__ std.vector; in the AST. llvm-svn: 145725
2011-12-03 07:23:56 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitAccessSpecDecl(AccessSpecDecl *D) {
Added AccessSpecDecl node. llvm-svn: 105525
2010-06-05 13:09:32 +08:00
VisitDecl(D);
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
D->setColonLoc(ReadSourceLocation(Record, Idx));
Added AccessSpecDecl node. llvm-svn: 105525
2010-06-05 13:09:32 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitFriendDecl(FriendDecl *D) {
Read/write the identifier namespace in PCH for decls that may modify it. We can now use a PCH'ed <map>. llvm-svn: 107617
2010-07-05 18:38:01 +08:00
VisitDecl(D);
Added outer template parameter lists to friend type AST nodes. llvm-svn: 174050
2013-01-31 17:54:08 +08:00
if (Record[Idx++]) // hasFriendDecl
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
D->Friend = ReadDeclAs<NamedDecl>(Record, Idx);
Added outer template parameter lists to friend type AST nodes. llvm-svn: 174050
2013-01-31 17:54:08 +08:00
else
D->Friend = GetTypeSourceInfo(Record, Idx);
for (unsigned i = 0; i != D->NumTPLists; ++i)
[TrailingObjects] Convert Decl* classes. Also remove now-redundant explicit alignment specification on some of the classes converted prior to TrailingObjects automatically ensuring proper alignment. llvm-svn: 256585
2015-12-30 06:13:13 +08:00
D->getTrailingObjects<TemplateParameterList *>()[i] =
Reader.ReadTemplateParameterList(F, Record, Idx);
Map from local decl IDs to global decl IDs when lazily deserializing friend decl chains. llvm-svn: 189629
2013-08-30 08:23:29 +08:00
D->NextFriend = ReadDeclID(Record, Idx);
White-listing templated-scope friend decls is a good idea, but doing it by marking the decl invalid isn't. Make some steps towards supporting these and then hastily shut them down at the last second by marking them as unsupported. llvm-svn: 116661
2010-10-16 14:59:13 +08:00
D->UnsupportedFriend = (Record[Idx++] != 0);
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
D->FriendLoc = ReadSourceLocation(Record, Idx);
Support C++ friend declarations for PCH. This commit 'introduces' a slightly different way to restore the state of the AST object. It makes PCHDeclReader/PCHDeclWriter friends and gives them access to the private members of the object. The rationale is to avoid using/modifying the AST interfaces for PCH read/write so that to: -Avoid complications with objects that have side-effects during creation or when using some setters. -Not 'pollute' the AST interface with methods only used by the PCH reader/writer -Allow AST objects to be read-only. llvm-svn: 107219
2010-06-30 06:47:00 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitFriendTemplateDecl(FriendTemplateDecl *D) {
Read/write FriendTemplateDecl for PCH. llvm-svn: 109113
2010-07-23 00:04:10 +08:00
VisitDecl(D);
unsigned NumParams = Record[Idx++];
D->NumParams = NumParams;
D->Params = new TemplateParameterList*[NumParams];
for (unsigned i = 0; i != NumParams; ++i)
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
D->Params[i] = Reader.ReadTemplateParameterList(F, Record, Idx);
Read/write FriendTemplateDecl for PCH. llvm-svn: 109113
2010-07-23 00:04:10 +08:00
if (Record[Idx++]) // HasFriendDecl
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
D->Friend = ReadDeclAs<NamedDecl>(Record, Idx);
Read/write FriendTemplateDecl for PCH. llvm-svn: 109113
2010-07-23 00:04:10 +08:00
else
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
D->Friend = GetTypeSourceInfo(Record, Idx);
D->FriendLoc = ReadSourceLocation(Record, Idx);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
}
When two templates get merged together, also merge their pattern declarations together. This is extremely hairy, because in general we need to have loaded both the template and the pattern before we can determine whether either should be merged, so we temporarily violate the rule that all merging happens before reading a decl ends, but *only* in the case where a template's pattern is being loaded while loading the template itself. In order to accomodate this for class templates, delay loading the injected class name type for the pattern of the template until after we've loaded the template itself, if we happen to load the template first. llvm-svn: 207063
2014-04-24 10:25:27 +08:00
DeclID ASTDeclReader::VisitTemplateDecl(TemplateDecl *D) {
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +08:00
VisitNamedDecl(D);
When two templates get merged together, also merge their pattern declarations together. This is extremely hairy, because in general we need to have loaded both the template and the pattern before we can determine whether either should be merged, so we temporarily violate the rule that all merging happens before reading a decl ends, but *only* in the case where a template's pattern is being loaded while loading the template itself. In order to accomodate this for class templates, delay loading the injected class name type for the pattern of the template until after we've loaded the template itself, if we happen to load the template first. llvm-svn: 207063
2014-04-24 10:25:27 +08:00
DeclID PatternID = ReadDeclID(Record, Idx);
NamedDecl *TemplatedDecl = cast_or_null<NamedDecl>(Reader.GetDecl(PatternID));
Support C++ class template specializations and partial specializations for PCH. llvm-svn: 106625
2010-06-23 21:48:30 +08:00
TemplateParameterList* TemplateParams
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
= Reader.ReadTemplateParameterList(F, Record, Idx);
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +08:00
D->init(TemplatedDecl, TemplateParams);
Check for matching template-parameter-lists when merging template declarations. llvm-svn: 184791
2013-06-25 06:51:00 +08:00
When two templates get merged together, also merge their pattern declarations together. This is extremely hairy, because in general we need to have loaded both the template and the pattern before we can determine whether either should be merged, so we temporarily violate the rule that all merging happens before reading a decl ends, but *only* in the case where a template's pattern is being loaded while loading the template itself. In order to accomodate this for class templates, delay loading the injected class name type for the pattern of the template until after we've loaded the template itself, if we happen to load the template first. llvm-svn: 207063
2014-04-24 10:25:27 +08:00
return PatternID;
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
}
During name lookup, use redecl_iterator to walk over the redeclaration chain to determine whether any declaration of the given entity is visible, eliminating the redundant (and less efficient) getPreviousDeclaration() implementation. This tweak uncovered an omission in the handling of RedeclarableTemplateDecl, where we weren't making sure to search for additional redeclarations of a template in other module files. Things would be cleaner if RedeclarableTemplateDecl actually used Redeclarable. llvm-svn: 147687
2012-01-07 06:05:37 +08:00
ASTDeclReader::RedeclarableResult
ASTDeclReader::VisitRedeclarableTemplateDecl(RedeclarableTemplateDecl *D) {
Reimplement RedeclarableTemplateDecl in terms of Redeclarable<RedeclarableTemplateDecl>, eliminating a bunch of redeclaration-chain logic both in RedeclarableTemplateDecl and especially in its (de-)serialization. As part of this, eliminate the RedeclarableTemplate<> class template, which was an abstraction that didn't actually save anything. llvm-svn: 148181
2012-01-14 23:13:49 +08:00
RedeclarableResult Redecl = VisitRedeclarable(D);
Re-implement (de-)serialization of redeclaration chains for redeclaration templates (RedeclarableTemplateDecl), similarly to the way (de-)serialization is implemented for Redeclarable<T>. In the process, found a simpler formulation for handling redeclaration chains and implemented that in both places. The new test establishes that we're building the redeclaration chains properly. However, the FIXME indicates where we're tickling a different bug that has to do with us not setting the DefinitionData pointer properly in redeclarations that we detected after the definition itself was deserialized. The (separable) fix for that bug is forthcoming. llvm-svn: 146883
2011-12-20 02:19:24 +08:00
Reimplement RedeclarableTemplateDecl in terms of Redeclarable<RedeclarableTemplateDecl>, eliminating a bunch of redeclaration-chain logic both in RedeclarableTemplateDecl and especially in its (de-)serialization. As part of this, eliminate the RedeclarableTemplate<> class template, which was an abstraction that didn't actually save anything. llvm-svn: 148181
2012-01-14 23:13:49 +08:00
// Make sure we've allocated the Common pointer first. We do this before
// VisitTemplateDecl so that getCommonPtr() can be used during initialization.
RedeclarableTemplateDecl *CanonD = D->getCanonicalDecl();
if (!CanonD->Common) {
CanonD->Common = CanonD->newCommon(Reader.getContext());
Reader.PendingDefinitions.insert(CanonD);
}
D->Common = CanonD->Common;
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
Reimplement RedeclarableTemplateDecl in terms of Redeclarable<RedeclarableTemplateDecl>, eliminating a bunch of redeclaration-chain logic both in RedeclarableTemplateDecl and especially in its (de-)serialization. As part of this, eliminate the RedeclarableTemplate<> class template, which was an abstraction that didn't actually save anything. llvm-svn: 148181
2012-01-14 23:13:49 +08:00
// If this is the first declaration of the template, fill in the information
// for the 'common' pointer.
if (ThisDeclID == Redecl.getFirstID()) {
Refactor redeclarable template declarations This patch refactors much of the common code in ClassTemplateDecl and FunctionTemplateDecl into a common base class RedeclarableTemplateDecl together with support functions in a template class RedeclarableTemplate. The patch also includes similar refactoring for these classes' PCH reader and writer implementations. llvm-svn: 109754
2010-07-30 00:11:51 +08:00
if (RedeclarableTemplateDecl *RTD
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
= ReadDeclAs<RedeclarableTemplateDecl>(Record, Idx)) {
Refactor redeclarable template declarations This patch refactors much of the common code in ClassTemplateDecl and FunctionTemplateDecl into a common base class RedeclarableTemplateDecl together with support functions in a template class RedeclarableTemplate. The patch also includes similar refactoring for these classes' PCH reader and writer implementations. llvm-svn: 109754
2010-07-30 00:11:51 +08:00
assert(RTD->getKind() == D->getKind() &&
"InstantiatedFromMemberTemplate kind mismatch");
Reimplement RedeclarableTemplateDecl in terms of Redeclarable<RedeclarableTemplateDecl>, eliminating a bunch of redeclaration-chain logic both in RedeclarableTemplateDecl and especially in its (de-)serialization. As part of this, eliminate the RedeclarableTemplate<> class template, which was an abstraction that didn't actually save anything. llvm-svn: 148181
2012-01-14 23:13:49 +08:00
D->setInstantiatedFromMemberTemplate(RTD);
Refactor redeclarable template declarations This patch refactors much of the common code in ClassTemplateDecl and FunctionTemplateDecl into a common base class RedeclarableTemplateDecl together with support functions in a template class RedeclarableTemplate. The patch also includes similar refactoring for these classes' PCH reader and writer implementations. llvm-svn: 109754
2010-07-30 00:11:51 +08:00
if (Record[Idx++])
D->setMemberSpecialization();
}
}
Also merge template redeclarations. Don't require specializations (of existing and read template) to be unique. llvm-svn: 164931
2012-10-01 17:18:00 +08:00
When two templates get merged together, also merge their pattern declarations together. This is extremely hairy, because in general we need to have loaded both the template and the pattern before we can determine whether either should be merged, so we temporarily violate the rule that all merging happens before reading a decl ends, but *only* in the case where a template's pattern is being loaded while loading the template itself. In order to accomodate this for class templates, delay loading the injected class name type for the pattern of the template until after we've loaded the template itself, if we happen to load the template first. llvm-svn: 207063
2014-04-24 10:25:27 +08:00
DeclID PatternID = VisitTemplateDecl(D);
Fix C++ PCH issues. PCH got a severe beating by the boost-using test case reported here: http://llvm.org/PR8099 Fix issues like: -When PCH reading, make sure Decl's getASTContext() doesn't get called since a Decl in the parent hierarchy may be initializing. -In ASTDeclReader::VisitFunctionDecl VisitRedeclarable should be called before using FunctionDecl's isCanonicalDecl() -In ASTDeclReader::VisitRedeclarableTemplateDecl CommonOrPrev must be initialized before anything else. llvm-svn: 113391
2010-09-09 03:31:22 +08:00
D->IdentifierNamespace = Record[Idx++];
Also merge template redeclarations. Don't require specializations (of existing and read template) to be unique. llvm-svn: 164931
2012-10-01 17:18:00 +08:00
When two templates get merged together, also merge their pattern declarations together. This is extremely hairy, because in general we need to have loaded both the template and the pattern before we can determine whether either should be merged, so we temporarily violate the rule that all merging happens before reading a decl ends, but *only* in the case where a template's pattern is being loaded while loading the template itself. In order to accomodate this for class templates, delay loading the injected class name type for the pattern of the template until after we've loaded the template itself, if we happen to load the template first. llvm-svn: 207063
2014-04-24 10:25:27 +08:00
mergeRedeclarable(D, Redecl, PatternID);
Also merge template redeclarations. Don't require specializations (of existing and read template) to be unique. llvm-svn: 164931
2012-10-01 17:18:00 +08:00
Merge common pointers for redeclarations of the same template across modules. llvm-svn: 192560
2013-10-14 07:50:45 +08:00
// If we merged the template with a prior declaration chain, merge the common
// pointer.
// FIXME: Actually merge here, don't just overwrite.
D->Common = D->getCanonicalDecl()->Common;
Reimplement RedeclarableTemplateDecl in terms of Redeclarable<RedeclarableTemplateDecl>, eliminating a bunch of redeclaration-chain logic both in RedeclarableTemplateDecl and especially in its (de-)serialization. As part of this, eliminate the RedeclarableTemplate<> class template, which was an abstraction that didn't actually save anything. llvm-svn: 148181
2012-01-14 23:13:49 +08:00
return Redecl;
Refactor redeclarable template declarations This patch refactors much of the common code in ClassTemplateDecl and FunctionTemplateDecl into a common base class RedeclarableTemplateDecl together with support functions in a template class RedeclarableTemplate. The patch also includes similar refactoring for these classes' PCH reader and writer implementations. llvm-svn: 109754
2010-07-30 00:11:51 +08:00
}
[modules] When loading in multiple canonical definitions of a template, accumulate the set of specializations rather than overwriting one list with another. llvm-svn: 230712
2015-02-27 08:25:58 +08:00
static DeclID *newDeclIDList(ASTContext &Context, DeclID *Old,
SmallVectorImpl<DeclID> &IDs) {
assert(!IDs.empty() && "no IDs to add to list");
[modules] Deduplicate when merging lists of template specializations from imported modules. llvm-svn: 230834
2015-02-28 09:45:19 +08:00
if (Old) {
IDs.insert(IDs.end(), Old + 1, Old + 1 + Old[0]);
std::sort(IDs.begin(), IDs.end());
IDs.erase(std::unique(IDs.begin(), IDs.end()), IDs.end());
}
[modules] When loading in multiple canonical definitions of a template, accumulate the set of specializations rather than overwriting one list with another. llvm-svn: 230712
2015-02-27 08:25:58 +08:00
[modules] Deduplicate when merging lists of template specializations from imported modules. llvm-svn: 230834
2015-02-28 09:45:19 +08:00
auto *Result = new (Context) DeclID[1 + IDs.size()];
*Result = IDs.size();
std::copy(IDs.begin(), IDs.end(), Result + 1);
[modules] When loading in multiple canonical definitions of a template, accumulate the set of specializations rather than overwriting one list with another. llvm-svn: 230712
2015-02-27 08:25:58 +08:00
return Result;
}
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.
[modules] When loading in multiple canonical definitions of a template, accumulate the set of specializations rather than overwriting one list with another. llvm-svn: 230712
2015-02-27 08:25:58 +08:00
SmallVector<serialization::DeclID, 32> SpecIDs;
ReadDeclIDList(SpecIDs);
if (!SpecIDs.empty()) {
auto *CommonPtr = D->getCommonPtr();
CommonPtr->LazySpecializations = newDeclIDList(
Reader.getContext(), CommonPtr->LazySpecializations, 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
}
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +08:00
}
When two templates get merged together, also merge their pattern declarations together. This is extremely hairy, because in general we need to have loaded both the template and the pattern before we can determine whether either should be merged, so we temporarily violate the rule that all merging happens before reading a decl ends, but *only* in the case where a template's pattern is being loaded while loading the template itself. In order to accomodate this for class templates, delay loading the injected class name type for the pattern of the template until after we've loaded the template itself, if we happen to load the template first. llvm-svn: 207063
2014-04-24 10:25:27 +08:00
if (D->getTemplatedDecl()->TemplateOrInstantiation) {
// We were loaded before our templated declaration was. We've not set up
// its corresponding type yet (see VisitCXXRecordDeclImpl), so reconstruct
// it now.
Reader.Context.getInjectedClassNameType(
Recompute the injected class name type for a class template specialization rather than saving and restoring it. llvm-svn: 209557
2014-05-24 05:31:59 +08:00
D->getTemplatedDecl(), D->getInjectedClassNameSpecialization());
When two templates get merged together, also merge their pattern declarations together. This is extremely hairy, because in general we need to have loaded both the template and the pattern before we can determine whether either should be merged, so we temporarily violate the rule that all merging happens before reading a decl ends, but *only* in the case where a template's pattern is being loaded while loading the template itself. In order to accomodate this for class templates, delay loading the injected class name type for the pattern of the template until after we've loaded the template itself, if we happen to load the template first. llvm-svn: 207063
2014-04-24 10:25:27 +08:00
}
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
}
[Sema] Implement __make_integer_seq This new builtin template allows for incredibly fast instantiations of templates like std::integer_sequence. Performance numbers follow: My work station has 64 GB of ram + 20 Xeon Cores at 2.8 GHz. __make_integer_seq<std::integer_sequence, int, 90000> takes 0.25 seconds. std::make_integer_sequence<int, 90000> takes unbound time, it is still running. Clang is consuming gigabytes of memory. Differential Revision: http://reviews.llvm.org/D13786 llvm-svn: 252036
2015-11-04 11:40:30 +08:00
void ASTDeclReader::VisitBuiltinTemplateDecl(BuiltinTemplateDecl *D) {
llvm_unreachable("BuiltinTemplates are not serialized");
}
A clean-up pass, exploring the unification of traversals of class, variable and function templates. llvm-svn: 189152
2013-08-24 06:21:36 +08:00
/// TODO: Unify with ClassTemplateDecl version?
/// May require unifying ClassTemplateDecl and
/// VarTemplateDecl beyond TemplateDecl...
Started implementing variable templates. Top level declarations should be fully supported, up to some limitations documented as FIXMEs or TODO. Static data member templates work very partially. Static data member templates of class templates need particular attention... llvm-svn: 187762
2013-08-06 09:03:05 +08:00
void ASTDeclReader::VisitVarTemplateDecl(VarTemplateDecl *D) {
RedeclarableResult Redecl = VisitRedeclarableTemplateDecl(D);
if (ThisDeclID == Redecl.getFirstID()) {
Bug fix: disallow a variable template to be redeclared as a non-templated variable llvm-svn: 188350
2013-08-14 11:09:19 +08:00
// This VarTemplateDecl owns a CommonPtr; read it to keep track of all of
Started implementing variable templates. Top level declarations should be fully supported, up to some limitations documented as FIXMEs or TODO. Static data member templates work very partially. Static data member templates of class templates need particular attention... llvm-svn: 187762
2013-08-06 09:03:05 +08:00
// the specializations.
[modules] When loading in multiple canonical definitions of a template, accumulate the set of specializations rather than overwriting one list with another. llvm-svn: 230712
2015-02-27 08:25:58 +08:00
SmallVector<serialization::DeclID, 32> SpecIDs;
ReadDeclIDList(SpecIDs);
if (!SpecIDs.empty()) {
auto *CommonPtr = D->getCommonPtr();
CommonPtr->LazySpecializations = newDeclIDList(
Reader.getContext(), CommonPtr->LazySpecializations, SpecIDs);
Started implementing variable templates. Top level declarations should be fully supported, up to some limitations documented as FIXMEs or TODO. Static data member templates work very partially. Static data member templates of class templates need particular attention... llvm-svn: 187762
2013-08-06 09:03:05 +08:00
}
}
}
Fix bitcode desynchronization when loading a PCH containing a class template specialization with modules enabled. Just don't merge them at all for now; we'll revisit this when support for template merging is added. In passing, make Decl::dump() a little safer to use with PCH/modules, by making it not deserialize any additional declarations. From a debugger you can call decls_begin() or similar first if you want to dump all child decls. llvm-svn: 182544
2013-05-23 09:49:11 +08:00
ASTDeclReader::RedeclarableResult
ASTDeclReader::VisitClassTemplateSpecializationDeclImpl(
ClassTemplateSpecializationDecl *D) {
RedeclarableResult Redecl = VisitCXXRecordDeclImpl(D);
Avoid setters in ASTDeclReader::VisitClassTemplateSpecializationDecl. llvm-svn: 113742
2010-09-13 19:45:32 +08:00
In ASTReader, replace the never-NULL ASTContext pointer with an ASTContext reference. Remove all of the extra checking and logic that was used to cope with a NULL ASTContext. No effective functionality change. llvm-svn: 139413
2011-09-10 05:34:22 +08:00
ASTContext &C = Reader.getContext();
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
if (Decl *InstD = ReadDecl(Record, Idx)) {
Support C++ class template specializations and partial specializations for PCH. llvm-svn: 106625
2010-06-23 21:48:30 +08:00
if (ClassTemplateDecl *CTD = dyn_cast<ClassTemplateDecl>(InstD)) {
Avoid setters in ASTDeclReader::VisitClassTemplateSpecializationDecl. llvm-svn: 113742
2010-09-13 19:45:32 +08:00
D->SpecializedTemplate = CTD;
Support C++ class template specializations and partial specializations for PCH. llvm-svn: 106625
2010-06-23 21:48:30 +08:00
} else {
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<TemplateArgument, 8> TemplArgs;
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
Avoid setters in ASTDeclReader::VisitClassTemplateSpecializationDecl. llvm-svn: 113742
2010-09-13 19:45:32 +08:00
TemplateArgumentList *ArgList
Remove broken support for variadic templates, along with the various abstractions (e.g., TemplateArgumentListBuilder) that were designed to support variadic templates. Only a few remnants of variadic templates remain, in the parser (parsing template type parameter packs), AST (template type parameter pack bits and TemplateArgument::Pack), and Sema; these are expected to be used in a future implementation of variadic templates. But don't get too excited about that happening now. llvm-svn: 118385
2010-11-08 07:05:16 +08:00
= TemplateArgumentList::CreateCopy(C, TemplArgs.data(),
TemplArgs.size());
Avoid setters in ASTDeclReader::VisitClassTemplateSpecializationDecl. llvm-svn: 113742
2010-09-13 19:45:32 +08:00
ClassTemplateSpecializationDecl::SpecializedPartialSpecialization *PS
= new (C) ClassTemplateSpecializationDecl::
SpecializedPartialSpecialization();
PS->PartialSpecialization
= cast<ClassTemplatePartialSpecializationDecl>(InstD);
PS->TemplateArgs = ArgList;
D->SpecializedTemplate = PS;
Support C++ class template specializations and partial specializations for PCH. llvm-svn: 106625
2010-06-23 21:48:30 +08:00
}
}
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<TemplateArgument, 8> TemplArgs;
[modules] When loading a template specialization, re-canonicalize its template arguments because the reloaded form might have become non-canonical across the serialization/deserialization step (this particularly happens when the canonical form of the type involves an expression). llvm-svn: 244409
2015-08-09 09:05:31 +08:00
Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx,
/*Canonicalize*/ true);
Remove broken support for variadic templates, along with the various abstractions (e.g., TemplateArgumentListBuilder) that were designed to support variadic templates. Only a few remnants of variadic templates remain, in the parser (parsing template type parameter packs), AST (template type parameter pack bits and TemplateArgument::Pack), and Sema; these are expected to be used in a future implementation of variadic templates. But don't get too excited about that happening now. llvm-svn: 118385
2010-11-08 07:05:16 +08:00
D->TemplateArgs = TemplateArgumentList::CreateCopy(C, TemplArgs.data(),
TemplArgs.size());
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
D->PointOfInstantiation = ReadSourceLocation(Record, Idx);
Avoid setters in ASTDeclReader::VisitClassTemplateSpecializationDecl. llvm-svn: 113742
2010-09-13 19:45:32 +08:00
D->SpecializationKind = (TemplateSpecializationKind)Record[Idx++];
Bring ASTReader and Writer into sync for the case where a canonical template specialization was written, which is non-canonical at the time of reading: force the reading of the ClassTemplateDecl if it was written. The easiest way out is to store whether the decl was canonical at the time of writing. Add test. llvm-svn: 164927
2012-10-01 15:34:47 +08:00
bool writtenAsCanonicalDecl = Record[Idx++];
if (writtenAsCanonicalDecl) {
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
ClassTemplateDecl *CanonPattern = ReadDeclAs<ClassTemplateDecl>(Record,Idx);
Bring ASTReader and Writer into sync for the case where a canonical template specialization was written, which is non-canonical at the time of reading: force the reading of the ClassTemplateDecl if it was written. The easiest way out is to store whether the decl was canonical at the time of writing. Add test. llvm-svn: 164927
2012-10-01 15:34:47 +08:00
if (D->isCanonicalDecl()) { // It's kept in the folding set.
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
// Set this as, or find, the canonical declaration for this specialization
ClassTemplateSpecializationDecl *CanonSpec;
Fix deserializing of class template partial specializations. Assign sequence numbers as we deserialize class template partial specializations. We can't assume that the old sequence numbers will work. The sequence numbers are still deterministic, but are now a lot less predictable for class template partial specializations in modules/PCH. llvm-svn: 184811
2013-06-25 09:25:15 +08:00
if (ClassTemplatePartialSpecializationDecl *Partial =
dyn_cast<ClassTemplatePartialSpecializationDecl>(D)) {
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
CanonSpec = CanonPattern->getCommonPtr()->PartialSpecializations
Fix deserializing of class template partial specializations. Assign sequence numbers as we deserialize class template partial specializations. We can't assume that the old sequence numbers will work. The sequence numbers are still deterministic, but are now a lot less predictable for class template partial specializations in modules/PCH. llvm-svn: 184811
2013-06-25 09:25:15 +08:00
.GetOrInsertNode(Partial);
Bring ASTReader and Writer into sync for the case where a canonical template specialization was written, which is non-canonical at the time of reading: force the reading of the ClassTemplateDecl if it was written. The easiest way out is to store whether the decl was canonical at the time of writing. Add test. llvm-svn: 164927
2012-10-01 15:34:47 +08:00
} else {
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
CanonSpec =
CanonPattern->getCommonPtr()->Specializations.GetOrInsertNode(D);
}
// If there was already a canonical specialization, merge into it.
if (CanonSpec != D) {
mergeRedeclarable<TagDecl>(D, CanonSpec, Redecl);
// This declaration might be a definition. Merge with any existing
// definition.
If a declaration is loaded, and then a module import adds a redeclaration, then ensure that querying the first declaration for its most recent declaration checks for redeclarations from the imported module. This works as follows: * The 'most recent' pointer on a canonical declaration grows a pointer to the external AST source and a generation number (space- and time-optimized for the case where there is no external source). * Each time the 'most recent' pointer is queried, if it has an external source, we check whether it's up to date, and update it if not. * The ancillary data stored on the canonical declaration is allocated lazily to avoid filling it in for declarations that end up being non-canonical. We'll still perform a redundant (ASTContext) allocation if someone asks for the most recent declaration from a decl before setPreviousDecl is called, but such cases are probably all bugs, and are now easy to find. Some finessing is still in order here -- in particular, we use a very general mechanism for handling the DefinitionData pointer on CXXRecordData, and a more targeted approach would be more compact. Also, the MayHaveOutOfDateDef mechanism should now be expunged, since it was addressing only a corner of the full problem space here. That's not covered by this patch. Early performance benchmarks show that this makes no measurable difference to Clang performance without modules enabled (and fixes a major correctness issue with modules enabled). I'll revert if a full performance comparison shows any problems. llvm-svn: 209046
2014-05-17 07:01:30 +08:00
if (auto *DDD = D->DefinitionData.getNotUpdated()) {
[modules] Refactor and slightly simplify class definition merging. llvm-svn: 240200
2015-06-20 08:22:34 +08:00
if (CanonSpec->DefinitionData.getNotUpdated())
[modules] Sometimes we can deserialize a class member but not have yet encountered any definition for the class; this happens when the definition is added by an update record that is not yet loaded. In such a case, eagerly pick the original parent of the member as the canonical definition of the class rather than muddling through with the canonical declaration (the latter can lead to us failing to merge properly later if the canonical definition turns out to be some other declaration). llvm-svn: 226977
2015-01-24 09:07:20 +08:00
MergeDefinitionData(CanonSpec, std::move(*DDD));
[modules] Refactor and slightly simplify class definition merging. llvm-svn: 240200
2015-06-20 08:22:34 +08:00
else
If a declaration is loaded, and then a module import adds a redeclaration, then ensure that querying the first declaration for its most recent declaration checks for redeclarations from the imported module. This works as follows: * The 'most recent' pointer on a canonical declaration grows a pointer to the external AST source and a generation number (space- and time-optimized for the case where there is no external source). * Each time the 'most recent' pointer is queried, if it has an external source, we check whether it's up to date, and update it if not. * The ancillary data stored on the canonical declaration is allocated lazily to avoid filling it in for declarations that end up being non-canonical. We'll still perform a redundant (ASTContext) allocation if someone asks for the most recent declaration from a decl before setPreviousDecl is called, but such cases are probably all bugs, and are now easy to find. Some finessing is still in order here -- in particular, we use a very general mechanism for handling the DefinitionData pointer on CXXRecordData, and a more targeted approach would be more compact. Also, the MayHaveOutOfDateDef mechanism should now be expunged, since it was addressing only a corner of the full problem space here. That's not covered by this patch. Early performance benchmarks show that this makes no measurable difference to Clang performance without modules enabled (and fixes a major correctness issue with modules enabled). I'll revert if a full performance comparison shows any problems. llvm-svn: 209046
2014-05-17 07:01:30 +08:00
CanonSpec->DefinitionData = D->DefinitionData;
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
}
[modules] When merging a class template, also merge the definition of its pattern. llvm-svn: 212836
2014-07-12 02:22:58 +08:00
D->DefinitionData = CanonSpec->DefinitionData;
Bring ASTReader and Writer into sync for the case where a canonical template specialization was written, which is non-canonical at the time of reading: force the reading of the ClassTemplateDecl if it was written. The easiest way out is to store whether the decl was canonical at the time of writing. Add test. llvm-svn: 164927
2012-10-01 15:34:47 +08:00
}
Reorganize how ClassTemplate[Partial]SpecializationDecls are read/written to avoid the possibility of adding an unitialized one into the folding set. llvm-svn: 108016
2010-07-10 05:11:43 +08:00
}
}
Fix bitcode desynchronization when loading a PCH containing a class template specialization with modules enabled. Just don't merge them at all for now; we'll revisit this when support for template merging is added. In passing, make Decl::dump() a little safer to use with PCH/modules, by making it not deserialize any additional declarations. From a debugger you can call decls_begin() or similar first if you want to dump all child decls. llvm-svn: 182544
2013-05-23 09:49:11 +08:00
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
// Explicit info.
if (TypeSourceInfo *TyInfo = GetTypeSourceInfo(Record, Idx)) {
ClassTemplateSpecializationDecl::ExplicitSpecializationInfo *ExplicitInfo
= new (C) ClassTemplateSpecializationDecl::ExplicitSpecializationInfo;
ExplicitInfo->TypeAsWritten = TyInfo;
ExplicitInfo->ExternLoc = ReadSourceLocation(Record, Idx);
ExplicitInfo->TemplateKeywordLoc = ReadSourceLocation(Record, Idx);
D->ExplicitInfo = ExplicitInfo;
}
Fix bitcode desynchronization when loading a PCH containing a class template specialization with modules enabled. Just don't merge them at all for now; we'll revisit this when support for template merging is added. In passing, make Decl::dump() a little safer to use with PCH/modules, by making it not deserialize any additional declarations. From a debugger you can call decls_begin() or similar first if you want to dump all child decls. llvm-svn: 182544
2013-05-23 09:49:11 +08:00
return Redecl;
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitClassTemplatePartialSpecializationDecl(
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
ClassTemplatePartialSpecializationDecl *D) {
Fix bitcode desynchronization when loading a PCH containing a class template specialization with modules enabled. Just don't merge them at all for now; we'll revisit this when support for template merging is added. In passing, make Decl::dump() a little safer to use with PCH/modules, by making it not deserialize any additional declarations. From a debugger you can call decls_begin() or similar first if you want to dump all child decls. llvm-svn: 182544
2013-05-23 09:49:11 +08:00
RedeclarableResult Redecl = VisitClassTemplateSpecializationDeclImpl(D);
Support C++ class template specializations and partial specializations for PCH. llvm-svn: 106625
2010-06-23 21:48:30 +08:00
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
D->TemplateParams = Reader.ReadTemplateParameterList(F, Record, Idx);
Added source locs for angled parentheses in class/var template partial specs. llvm-svn: 188134
2013-08-10 15:24:53 +08:00
D->ArgsAsWritten = Reader.ReadASTTemplateArgumentListInfo(F, Record, Idx);
Avoid setters in ASTDeclReader::VisitClassTemplatePartialSpecializationDecl. llvm-svn: 113743
2010-09-13 19:45:41 +08:00
Support C++ class template specializations and partial specializations for PCH. llvm-svn: 106625
2010-06-23 21:48:30 +08:00
// These are read/set from/to the first declaration.
Fix bitcode desynchronization when loading a PCH containing a class template specialization with modules enabled. Just don't merge them at all for now; we'll revisit this when support for template merging is added. In passing, make Decl::dump() a little safer to use with PCH/modules, by making it not deserialize any additional declarations. From a debugger you can call decls_begin() or similar first if you want to dump all child decls. llvm-svn: 182544
2013-05-23 09:49:11 +08:00
if (ThisDeclID == Redecl.getFirstID()) {
Avoid setters in ASTDeclReader::VisitClassTemplatePartialSpecializationDecl. llvm-svn: 113743
2010-09-13 19:45:41 +08:00
D->InstantiatedFromMember.setPointer(
In the ASTReader, factor out the loading of (local) declaration IDs, such that every declaration ID loaded from an AST file will go through a central local -> global mapping function. At present, this change does nothing, since the local -> global mapping function is the identity function. This is the mechanical part of the refactoring; a follow-up patch will address a few remaining areas where it's not obvious whether we're dealing with local or global IDs. llvm-svn: 135711
2011-07-22 06:35:25 +08:00
ReadDeclAs<ClassTemplatePartialSpecializationDecl>(Record, Idx));
Avoid setters in ASTDeclReader::VisitClassTemplatePartialSpecializationDecl. llvm-svn: 113743
2010-09-13 19:45:41 +08:00
D->InstantiatedFromMember.setInt(Record[Idx++]);
Support C++ class template specializations and partial specializations for PCH. llvm-svn: 106625
2010-06-23 21:48:30 +08:00
}
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
}
Serialize the new bits in CXXRecordDecl::DefinitionData. llvm-svn: 138855
2011-08-31 21:59:56 +08:00
void ASTDeclReader::VisitClassScopeFunctionSpecializationDecl(
ClassScopeFunctionSpecializationDecl *D) {
Add serialization support for ClassScopeFunctionSpecializationDecl. llvm-svn: 137799
2011-08-17 09:06:54 +08:00
VisitDecl(D);
D->Specialization = ReadDeclAs<CXXMethodDecl>(Record, Idx);
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) {
Reimplement RedeclarableTemplateDecl in terms of Redeclarable<RedeclarableTemplateDecl>, eliminating a bunch of redeclaration-chain logic both in RedeclarableTemplateDecl and especially in its (de-)serialization. As part of this, eliminate the RedeclarableTemplate<> class template, which was an abstraction that didn't actually save anything. llvm-svn: 148181
2012-01-14 23:13:49 +08:00
RedeclarableResult Redecl = VisitRedeclarableTemplateDecl(D);
Support emitting/reading function templates to/from PCH. llvm-svn: 106534
2010-06-22 17:55:07 +08:00
Reimplement RedeclarableTemplateDecl in terms of Redeclarable<RedeclarableTemplateDecl>, eliminating a bunch of redeclaration-chain logic both in RedeclarableTemplateDecl and especially in its (de-)serialization. As part of this, eliminate the RedeclarableTemplate<> class template, which was an abstraction that didn't actually save anything. llvm-svn: 148181
2012-01-14 23:13:49 +08:00
if (ThisDeclID == Redecl.getFirstID()) {
Support emitting/reading function templates to/from PCH. llvm-svn: 106534
2010-06-22 17:55:07 +08:00
// This FunctionTemplateDecl owns a CommonPtr; read it.
[modules] When loading in multiple canonical definitions of a template, accumulate the set of specializations rather than overwriting one list with another. llvm-svn: 230712
2015-02-27 08:25:58 +08:00
SmallVector<serialization::DeclID, 32> SpecIDs;
ReadDeclIDList(SpecIDs);
Support emitting/reading function templates to/from PCH. llvm-svn: 106534
2010-06-22 17:55:07 +08:00
[modules] When loading in multiple canonical definitions of a template, accumulate the set of specializations rather than overwriting one list with another. llvm-svn: 230712
2015-02-27 08:25:58 +08:00
if (!SpecIDs.empty()) {
auto *CommonPtr = D->getCommonPtr();
CommonPtr->LazySpecializations = newDeclIDList(
Reader.getContext(), CommonPtr->LazySpecializations, SpecIDs);
Lazily deserialize function template specializations. This fixes a cycle in module deserialization / merging, and more laziness here is general goodness. llvm-svn: 185132
2013-06-28 12:37:53 +08:00
}
Support emitting/reading function templates to/from PCH. llvm-svn: 106534
2010-06-22 17:55:07 +08:00
}
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
}
A clean-up pass, exploring the unification of traversals of class, variable and function templates. llvm-svn: 189152
2013-08-24 06:21:36 +08:00
/// TODO: Unify with ClassTemplateSpecializationDecl version?
/// May require unifying ClassTemplate(Partial)SpecializationDecl and
/// VarTemplate(Partial)SpecializationDecl with a new data
/// structure Template(Partial)SpecializationDecl, and
/// using Template(Partial)SpecializationDecl as input type.
Started implementing variable templates. Top level declarations should be fully supported, up to some limitations documented as FIXMEs or TODO. Static data member templates work very partially. Static data member templates of class templates need particular attention... llvm-svn: 187762
2013-08-06 09:03:05 +08:00
ASTDeclReader::RedeclarableResult
ASTDeclReader::VisitVarTemplateSpecializationDeclImpl(
VarTemplateSpecializationDecl *D) {
RedeclarableResult Redecl = VisitVarDeclImpl(D);
ASTContext &C = Reader.getContext();
if (Decl *InstD = ReadDecl(Record, Idx)) {
if (VarTemplateDecl *VTD = dyn_cast<VarTemplateDecl>(InstD)) {
D->SpecializedTemplate = VTD;
} else {
SmallVector<TemplateArgument, 8> TemplArgs;
Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
TemplateArgumentList *ArgList = TemplateArgumentList::CreateCopy(
C, TemplArgs.data(), TemplArgs.size());
VarTemplateSpecializationDecl::SpecializedPartialSpecialization *PS =
new (C)
VarTemplateSpecializationDecl::SpecializedPartialSpecialization();
PS->PartialSpecialization =
cast<VarTemplatePartialSpecializationDecl>(InstD);
PS->TemplateArgs = ArgList;
D->SpecializedTemplate = PS;
}
}
// Explicit info.
if (TypeSourceInfo *TyInfo = GetTypeSourceInfo(Record, Idx)) {
VarTemplateSpecializationDecl::ExplicitSpecializationInfo *ExplicitInfo =
new (C) VarTemplateSpecializationDecl::ExplicitSpecializationInfo;
ExplicitInfo->TypeAsWritten = TyInfo;
ExplicitInfo->ExternLoc = ReadSourceLocation(Record, Idx);
ExplicitInfo->TemplateKeywordLoc = ReadSourceLocation(Record, Idx);
D->ExplicitInfo = ExplicitInfo;
}
SmallVector<TemplateArgument, 8> TemplArgs;
[modules] When loading a template specialization, re-canonicalize its template arguments because the reloaded form might have become non-canonical across the serialization/deserialization step (this particularly happens when the canonical form of the type involves an expression). llvm-svn: 244409
2015-08-09 09:05:31 +08:00
Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx,
/*Canonicalize*/ true);
Started implementing variable templates. Top level declarations should be fully supported, up to some limitations documented as FIXMEs or TODO. Static data member templates work very partially. Static data member templates of class templates need particular attention... llvm-svn: 187762
2013-08-06 09:03:05 +08:00
D->TemplateArgs =
TemplateArgumentList::CreateCopy(C, TemplArgs.data(), TemplArgs.size());
D->PointOfInstantiation = ReadSourceLocation(Record, Idx);
D->SpecializationKind = (TemplateSpecializationKind)Record[Idx++];
bool writtenAsCanonicalDecl = Record[Idx++];
if (writtenAsCanonicalDecl) {
VarTemplateDecl *CanonPattern = ReadDeclAs<VarTemplateDecl>(Record, Idx);
if (D->isCanonicalDecl()) { // It's kept in the folding set.
[modules] Add an assert for redeclarations that we never added to their redecl chain and fix the cases where it fires. * Handle the __va_list_tag as a predefined decl. Previously we failed to merge sometimes it because it's not visible to name lookup. (In passing, remove redundant __va_list_tag typedefs that we were creating for some ABIs. These didn't affect the mangling or representation of the type.) * For Decls derived from Redeclarable that are not in fact redeclarable (implicit params, function params, ObjC type parameters), remove them from the list of expected redeclarable decls. llvm-svn: 243259
2015-07-27 13:40:23 +08:00
// FIXME: If it's already present, merge it.
Started implementing variable templates. Top level declarations should be fully supported, up to some limitations documented as FIXMEs or TODO. Static data member templates work very partially. Static data member templates of class templates need particular attention... llvm-svn: 187762
2013-08-06 09:03:05 +08:00
if (VarTemplatePartialSpecializationDecl *Partial =
dyn_cast<VarTemplatePartialSpecializationDecl>(D)) {
CanonPattern->getCommonPtr()->PartialSpecializations
.GetOrInsertNode(Partial);
} else {
CanonPattern->getCommonPtr()->Specializations.GetOrInsertNode(D);
}
}
}
return Redecl;
}
A clean-up pass, exploring the unification of traversals of class, variable and function templates. llvm-svn: 189152
2013-08-24 06:21:36 +08:00
/// TODO: Unify with ClassTemplatePartialSpecializationDecl version?
/// May require unifying ClassTemplate(Partial)SpecializationDecl and
/// VarTemplate(Partial)SpecializationDecl with a new data
/// structure Template(Partial)SpecializationDecl, and
/// using Template(Partial)SpecializationDecl as input type.
Started implementing variable templates. Top level declarations should be fully supported, up to some limitations documented as FIXMEs or TODO. Static data member templates work very partially. Static data member templates of class templates need particular attention... llvm-svn: 187762
2013-08-06 09:03:05 +08:00
void ASTDeclReader::VisitVarTemplatePartialSpecializationDecl(
VarTemplatePartialSpecializationDecl *D) {
RedeclarableResult Redecl = VisitVarTemplateSpecializationDeclImpl(D);
D->TemplateParams = Reader.ReadTemplateParameterList(F, Record, Idx);
Added source locs for angled parentheses in class/var template partial specs. llvm-svn: 188134
2013-08-10 15:24:53 +08:00
D->ArgsAsWritten = Reader.ReadASTTemplateArgumentListInfo(F, Record, Idx);
Started implementing variable templates. Top level declarations should be fully supported, up to some limitations documented as FIXMEs or TODO. Static data member templates work very partially. Static data member templates of class templates need particular attention... llvm-svn: 187762
2013-08-06 09:03:05 +08:00
// These are read/set from/to the first declaration.
if (ThisDeclID == Redecl.getFirstID()) {
D->InstantiatedFromMember.setPointer(
ReadDeclAs<VarTemplatePartialSpecializationDecl>(Record, Idx));
D->InstantiatedFromMember.setInt(Record[Idx++]);
}
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitTemplateTypeParmDecl(TemplateTypeParmDecl *D) {
Initial support for reading templates from PCH. llvm-svn: 106392
2010-06-20 03:29:09 +08:00
VisitTypeDecl(D);
D->setDeclaredWithTypename(Record[Idx++]);
Refactor storage of default template arguments. This is just a preparatory step towards fixing visibility for default template arguments in modules builds. llvm-svn: 239447
2015-06-10 08:29:03 +08:00
if (Record[Idx++])
D->setDefaultArgument(GetTypeSourceInfo(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::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()) {
[TrailingObjects] Convert Decl* classes. Also remove now-redundant explicit alignment specification on some of the classes converted prior to TrailingObjects automatically ensuring proper alignment. llvm-svn: 256585
2015-12-30 06:13:13 +08:00
auto TypesAndInfos =
D->getTrailingObjects<std::pair<QualType, TypeSourceInfo *>>();
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
for (unsigned I = 0, N = D->getNumExpansionTypes(); I != N; ++I) {
[TrailingObjects] Convert Decl* classes. Also remove now-redundant explicit alignment specification on some of the classes converted prior to TrailingObjects automatically ensuring proper alignment. llvm-svn: 256585
2015-12-30 06:13:13 +08:00
new (&TypesAndInfos[I].first) QualType(Reader.readType(F, Record, Idx));
TypesAndInfos[I].second = GetTypeSourceInfo(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
}
} else {
// Rest of NonTypeTemplateParmDecl.
D->ParameterPack = Record[Idx++];
Refactor storage of default template arguments. This is just a preparatory step towards fixing visibility for default template arguments in modules builds. llvm-svn: 239447
2015-06-10 08:29:03 +08:00
if (Record[Idx++])
D->setDefaultArgument(Reader.ReadExpr(F));
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
}
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitTemplateTemplateParmDecl(TemplateTemplateParmDecl *D) {
Support TemplateTemplateParmDecl for PCH. llvm-svn: 107884
2010-07-09 01:12:57 +08:00
VisitTemplateDecl(D);
// TemplateParmPosition.
D->setDepth(Record[Idx++]);
D->setPosition(Record[Idx++]);
PR9023: A template template parameter whose template parameter list contains an unexpanded parameter pack is a pack expansion. Thus, as with a non-type template parameter which is a pack expansion, it needs to be expanded early into a fixed list of template parameters. Since the expanded list of template parameters is not itself a parameter pack, it is permitted to appear before the end of the template parameter list, so also remove that restriction (for both template template parameter pack expansions and non-type template parameter pack expansions). llvm-svn: 163369
2012-09-07 10:06:42 +08:00
if (D->isExpandedParameterPack()) {
[TrailingObjects] Convert Decl* classes. Also remove now-redundant explicit alignment specification on some of the classes converted prior to TrailingObjects automatically ensuring proper alignment. llvm-svn: 256585
2015-12-30 06:13:13 +08:00
TemplateParameterList **Data =
D->getTrailingObjects<TemplateParameterList *>();
PR9023: A template template parameter whose template parameter list contains an unexpanded parameter pack is a pack expansion. Thus, as with a non-type template parameter which is a pack expansion, it needs to be expanded early into a fixed list of template parameters. Since the expanded list of template parameters is not itself a parameter pack, it is permitted to appear before the end of the template parameter list, so also remove that restriction (for both template template parameter pack expansions and non-type template parameter pack expansions). llvm-svn: 163369
2012-09-07 10:06:42 +08:00
for (unsigned I = 0, N = D->getNumExpansionTemplateParameters();
I != N; ++I)
Data[I] = Reader.ReadTemplateParameterList(F, Record, Idx);
} else {
// Rest of TemplateTemplateParmDecl.
D->ParameterPack = Record[Idx++];
Refactor storage of default template arguments. This is just a preparatory step towards fixing visibility for default template arguments in modules builds. llvm-svn: 239447
2015-06-10 08:29:03 +08:00
if (Record[Idx++])
D->setDefaultArgument(Reader.getContext(),
Reader.ReadTemplateArgumentLoc(F, Record, Idx));
PR9023: A template template parameter whose template parameter list contains an unexpanded parameter pack is a pack expansion. Thus, as with a non-type template parameter which is a pack expansion, it needs to be expanded early into a fixed list of template parameters. Since the expanded list of template parameters is not itself a parameter pack, it is permitted to appear before the end of the template parameter list, so also remove that restriction (for both template template parameter pack expansions and non-type template parameter pack expansions). llvm-svn: 163369
2012-09-07 10:06:42 +08:00
}
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
}
Implement support for C++0x alias templates. llvm-svn: 130953
2011-05-06 05:57:07 +08:00
void ASTDeclReader::VisitTypeAliasTemplateDecl(TypeAliasTemplateDecl *D) {
VisitRedeclarableTemplateDecl(D);
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
void ASTDeclReader::VisitStaticAssertDecl(StaticAssertDecl *D) {
Read/write C++0x static_assert for PCH. llvm-svn: 109123
2010-07-23 01:28:12 +08:00
VisitDecl(D);
Stop instantiating a class if we hit a static_assert failure. Also, if the static_assert fails when parsing the template, don't diagnose it again on every instantiation. llvm-svn: 160088
2012-07-12 06:37:56 +08:00
D->AssertExprAndFailed.setPointer(Reader.ReadExpr(F));
D->AssertExprAndFailed.setInt(Record[Idx++]);
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
D->Message = cast<StringLiteral>(Reader.ReadExpr(F));
Fixed source range for StaticAssertDecl and LinkageSpecDecl. Fixed source range for declarations using postfix types. llvm-svn: 127251
2011-03-09 00:41:52 +08:00
D->RParenLoc = ReadSourceLocation(Record, Idx);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
}
[Sema] Semantic analysis for empty-declaration and attribute-declaration. Introduce a new AST Decl node "EmptyDecl" to model empty-declaration. Have attributes from attribute-declaration appertain to the EmptyDecl node by creating the AST representations of these attributes and attach them to the EmptyDecl node so these attributes can be sema checked just as attributes attached to "normal" declarations. llvm-svn: 175900
2013-02-23 01:15:32 +08:00
void ASTDeclReader::VisitEmptyDecl(EmptyDecl *D) {
VisitDecl(D);
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
std::pair<uint64_t, uint64_t>
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
ASTDeclReader::VisitDeclContext(DeclContext *DC) {
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
uint64_t LexicalOffset = Record[Idx++];
uint64_t VisibleOffset = Record[Idx++];
return std::make_pair(LexicalOffset, VisibleOffset);
}
Apart from storing/retrieving the previous redeclaration from PCH, also store/retrieve the most recent redeclaration. That way we are sure that the full redeclarations chain is loaded. When using chained PCHs, first declarations point to the most recent redeclarations in the same PCH. To address this use a REDECLS_UPDATE_LATEST record block to keep track of which first declarations need to point to a most recent redeclaration in another PCH. llvm-svn: 110125
2010-08-04 01:30:10 +08:00
template <typename T>
[modules] If a module declares an entity and then imports another declaration of that entity, ensure that the redeclaration chain is reordered properly on reload. Otherwise, the result of name lookup for that entity may point to an entity that is too old; if that's an injected friend name or the like, that can result in the name not being found at all. llvm-svn: 228371
2015-02-06 10:42:59 +08:00
ASTDeclReader::RedeclarableResult
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::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);
[modules] If a module declares an entity and then imports another declaration of that entity, ensure that the redeclaration chain is reordered properly on reload. Otherwise, the result of name lookup for that entity may point to an entity that is too old; if that's an injected friend name or the like, that can result in the name not being found at all. llvm-svn: 228371
2015-02-06 10:42:59 +08:00
Decl *MergeWith = nullptr;
[modules] Rearrange how redeclaration chains are loaded, to remove a walk over all modules and reduce the number of declarations we load when loading a redeclaration chain. The new approach is: * when loading the first declaration of an entity within a module file, we first load all declarations of the entity that were imported into that module file, and then load all the other declarations of that entity from that module file and build a suitable decl chain from them * when loading any other declaration of an entity, we first load the first declaration from the same module file As before, we complete redecl chains through name lookup where necessary. To make this work, I also had to change the way that template specializations are stored -- it no longer suffices to track only canonical specializations; we now emit all "first local" declarations when emitting a list of specializations for a template. On one testcase with several thousand imported module files, this reduces the total runtime by 72%. llvm-svn: 245779
2015-08-22 09:47:18 +08:00
[modules] Improve performance when there is a local declaration of an entity before the first imported declaration. We don't need to track all formerly-canonical declarations of an entity; it's sufficient to track those ones for which no other formerly-canonical declaration was imported into the same module. We call those ones "key declarations", and use them as our starting points for collecting redeclarations and performing namespace lookups. llvm-svn: 241999
2015-07-13 07:43:21 +08:00
bool IsKeyDecl = ThisDeclID == FirstDeclID;
[modules] Rearrange how redeclaration chains are loaded, to remove a walk over all modules and reduce the number of declarations we load when loading a redeclaration chain. The new approach is: * when loading the first declaration of an entity within a module file, we first load all declarations of the entity that were imported into that module file, and then load all the other declarations of that entity from that module file and build a suitable decl chain from them * when loading any other declaration of an entity, we first load the first declaration from the same module file As before, we complete redecl chains through name lookup where necessary. To make this work, I also had to change the way that template specializations are stored -- it no longer suffices to track only canonical specializations; we now emit all "first local" declarations when emitting a list of specializations for a template. On one testcase with several thousand imported module files, this reduces the total runtime by 72%. llvm-svn: 245779
2015-08-22 09:47:18 +08:00
bool IsFirstLocalDecl = false;
[modules] If a module declares an entity and then imports another declaration of that entity, ensure that the redeclaration chain is reordered properly on reload. Otherwise, the result of name lookup for that entity may point to an entity that is too old; if that's an injected friend name or the like, that can result in the name not being found at all. llvm-svn: 228371
2015-02-06 10:42:59 +08:00
[modules] Further simplification and speedup of redeclaration chain loading. Instead of eagerly deserializing a list of DeclIDs when we load a module file and doing a binary search to find the redeclarations of a decl, store a list of redeclarations of each chain before the first declaration and load it directly. llvm-svn: 245789
2015-08-23 04:13:39 +08:00
uint64_t RedeclOffset = 0;
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.
[modules] Improve performance when there is a local declaration of an entity before the first imported declaration. We don't need to track all formerly-canonical declarations of an entity; it's sufficient to track those ones for which no other formerly-canonical declaration was imported into the same module. We call those ones "key declarations", and use them as our starting points for collecting redeclarations and performing namespace lookups. llvm-svn: 241999
2015-07-13 07:43:21 +08:00
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;
[modules] Improve performance when there is a local declaration of an entity before the first imported declaration. We don't need to track all formerly-canonical declarations of an entity; it's sufficient to track those ones for which no other formerly-canonical declaration was imported into the same module. We call those ones "key declarations", and use them as our starting points for collecting redeclarations and performing namespace lookups. llvm-svn: 241999
2015-07-13 07:43:21 +08:00
IsKeyDecl = true;
[modules] Rearrange how redeclaration chains are loaded, to remove a walk over all modules and reduce the number of declarations we load when loading a redeclaration chain. The new approach is: * when loading the first declaration of an entity within a module file, we first load all declarations of the entity that were imported into that module file, and then load all the other declarations of that entity from that module file and build a suitable decl chain from them * when loading any other declaration of an entity, we first load the first declaration from the same module file As before, we complete redecl chains through name lookup where necessary. To make this work, I also had to change the way that template specializations are stored -- it no longer suffices to track only canonical specializations; we now emit all "first local" declarations when emitting a list of specializations for a template. On one testcase with several thousand imported module files, this reduces the total runtime by 72%. llvm-svn: 245779
2015-08-22 09:47:18 +08:00
IsFirstLocalDecl = true;
[modules] Improve performance when there is a local declaration of an entity before the first imported declaration. We don't need to track all formerly-canonical declarations of an entity; it's sufficient to track those ones for which no other formerly-canonical declaration was imported into the same module. We call those ones "key declarations", and use them as our starting points for collecting redeclarations and performing namespace lookups. llvm-svn: 241999
2015-07-13 07:43:21 +08:00
} else if (unsigned N = Record[Idx++]) {
[modules] Rearrange how redeclaration chains are loaded, to remove a walk over all modules and reduce the number of declarations we load when loading a redeclaration chain. The new approach is: * when loading the first declaration of an entity within a module file, we first load all declarations of the entity that were imported into that module file, and then load all the other declarations of that entity from that module file and build a suitable decl chain from them * when loading any other declaration of an entity, we first load the first declaration from the same module file As before, we complete redecl chains through name lookup where necessary. To make this work, I also had to change the way that template specializations are stored -- it no longer suffices to track only canonical specializations; we now emit all "first local" declarations when emitting a list of specializations for a template. On one testcase with several thousand imported module files, this reduces the total runtime by 72%. llvm-svn: 245779
2015-08-22 09:47:18 +08:00
// This declaration was the first local declaration, but may have imported
// other declarations.
IsKeyDecl = N == 1;
IsFirstLocalDecl = true;
[modules] Improve performance when there is a local declaration of an entity before the first imported declaration. We don't need to track all formerly-canonical declarations of an entity; it's sufficient to track those ones for which no other formerly-canonical declaration was imported into the same module. We call those ones "key declarations", and use them as our starting points for collecting redeclarations and performing namespace lookups. llvm-svn: 241999
2015-07-13 07:43:21 +08:00
[modules] Rework merging of redeclaration chains on module import. We used to save out and eagerly load a (potentially huge) table of merged formerly-canonical declarations when we loaded each module. This was extremely inefficient in the presence of large amounts of merging, and didn't actually save any merging lookup work, because we still needed to perform name lookup to check that our merged declaration lists were complete. This also resulted in a loss of laziness -- even if we only needed an early declaration of an entity, we would eagerly pull in all declarations that had been merged into it regardless. We now store the relevant fragments of the table within the declarations themselves. In detail: * The first declaration of each entity within a module stores a list of first declarations from imported modules that are merged into it. * Loading that declaration pre-loads those other entities, so that they appear earlier within the redeclaration chain. * The name lookup tables list the most recent local lookup result, if there is one, or all directly-imported lookup results if not. llvm-svn: 231424
2015-03-06 07:24:12 +08:00
// We have some declarations that must be before us in our redeclaration
// chain. Read them now, and remember that we ought to merge with one of
// them.
// FIXME: Provide a known merge target to the second and subsequent such
// declaration.
[modules] Rearrange how redeclaration chains are loaded, to remove a walk over all modules and reduce the number of declarations we load when loading a redeclaration chain. The new approach is: * when loading the first declaration of an entity within a module file, we first load all declarations of the entity that were imported into that module file, and then load all the other declarations of that entity from that module file and build a suitable decl chain from them * when loading any other declaration of an entity, we first load the first declaration from the same module file As before, we complete redecl chains through name lookup where necessary. To make this work, I also had to change the way that template specializations are stored -- it no longer suffices to track only canonical specializations; we now emit all "first local" declarations when emitting a list of specializations for a template. On one testcase with several thousand imported module files, this reduces the total runtime by 72%. llvm-svn: 245779
2015-08-22 09:47:18 +08:00
for (unsigned I = 0; I != N - 1; ++I)
[modules] Rework merging of redeclaration chains on module import. We used to save out and eagerly load a (potentially huge) table of merged formerly-canonical declarations when we loaded each module. This was extremely inefficient in the presence of large amounts of merging, and didn't actually save any merging lookup work, because we still needed to perform name lookup to check that our merged declaration lists were complete. This also resulted in a loss of laziness -- even if we only needed an early declaration of an entity, we would eagerly pull in all declarations that had been merged into it regardless. We now store the relevant fragments of the table within the declarations themselves. In detail: * The first declaration of each entity within a module stores a list of first declarations from imported modules that are merged into it. * Loading that declaration pre-loads those other entities, so that they appear earlier within the redeclaration chain. * The name lookup tables list the most recent local lookup result, if there is one, or all directly-imported lookup results if not. llvm-svn: 231424
2015-03-06 07:24:12 +08:00
MergeWith = ReadDecl(Record, Idx/*, MergeWith*/);
[modules] Further simplification and speedup of redeclaration chain loading. Instead of eagerly deserializing a list of DeclIDs when we load a module file and doing a binary search to find the redeclarations of a decl, store a list of redeclarations of each chain before the first declaration and load it directly. llvm-svn: 245789
2015-08-23 04:13:39 +08:00
RedeclOffset = Record[Idx++];
[modules] Rearrange how redeclaration chains are loaded, to remove a walk over all modules and reduce the number of declarations we load when loading a redeclaration chain. The new approach is: * when loading the first declaration of an entity within a module file, we first load all declarations of the entity that were imported into that module file, and then load all the other declarations of that entity from that module file and build a suitable decl chain from them * when loading any other declaration of an entity, we first load the first declaration from the same module file As before, we complete redecl chains through name lookup where necessary. To make this work, I also had to change the way that template specializations are stored -- it no longer suffices to track only canonical specializations; we now emit all "first local" declarations when emitting a list of specializations for a template. On one testcase with several thousand imported module files, this reduces the total runtime by 72%. llvm-svn: 245779
2015-08-22 09:47:18 +08:00
} else {
// This declaration was not the first local declaration. Read the first
// local declaration now, to trigger the import of other redeclarations.
(void)ReadDecl(Record, Idx);
[modules] If a module declares an entity and then imports another declaration of that entity, ensure that the redeclaration chain is reordered properly on reload. Otherwise, the result of name lookup for that entity may point to an entity that is too old; if that's an injected friend name or the like, that can result in the name not being found at all. llvm-svn: 228371
2015-02-06 10:42:59 +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
T *FirstDecl = cast_or_null<T>(Reader.GetDecl(FirstDeclID));
if (FirstDecl != D) {
When reading the AST, delay loading of the redeclaration chain to avoid deeply nested calls. Temporarily set the first (canonical) declaration as the previous one, which is the one that matters, and mark the real previous DeclID to be loaded & attached later on. Fixes rdar://8956193. llvm-svn: 125434
2011-02-12 15:50:47 +08:00
// We delay loading of the redeclaration chain to avoid deeply nested calls.
// We temporarily set the first (canonical) declaration as the previous one
// which is the one that matters and mark the real previous DeclID to be
// loaded & attached later on.
Address minor FIXME in RedeclLink to contain a PointerIntPair instead of derive from it. Use actual factory functions rather than derived classes acting as named constructors/factories. llvm-svn: 157588
2012-05-29 03:38:42 +08:00
D->RedeclLink = Redeclarable<T>::PreviousDeclLink(FirstDecl);
Keep track of canonical decls in Redeclarable. More than 2x speedup on modules builds with large redecl chains. Roughly 15-20% speedup on non-modules builds for very large TUs. Between 2-3% cost in memory on large TUs. llvm-svn: 233228
2015-03-26 07:18:30 +08:00
D->First = FirstDecl->getCanonicalDecl();
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
}
[modules] Rearrange how redeclaration chains are loaded, to remove a walk over all modules and reduce the number of declarations we load when loading a redeclaration chain. The new approach is: * when loading the first declaration of an entity within a module file, we first load all declarations of the entity that were imported into that module file, and then load all the other declarations of that entity from that module file and build a suitable decl chain from them * when loading any other declaration of an entity, we first load the first declaration from the same module file As before, we complete redecl chains through name lookup where necessary. To make this work, I also had to change the way that template specializations are stored -- it no longer suffices to track only canonical specializations; we now emit all "first local" declarations when emitting a list of specializations for a template. On one testcase with several thousand imported module files, this reduces the total runtime by 72%. llvm-svn: 245779
2015-08-22 09:47:18 +08:00
T *DAsT = static_cast<T*>(D);
// Note that we need to load local redeclarations of this decl and build a
// decl chain for them. This must happen *after* we perform the preloading
// above; this ensures that the redeclaration chain is built in the correct
// order.
if (IsFirstLocalDecl)
[modules] Further simplification and speedup of redeclaration chain loading. Instead of eagerly deserializing a list of DeclIDs when we load a module file and doing a binary search to find the redeclarations of a decl, store a list of redeclarations of each chain before the first declaration and load it directly. llvm-svn: 245789
2015-08-23 04:13:39 +08:00
Reader.PendingDeclChains.push_back(std::make_pair(DAsT, RedeclOffset));
[modules] Rearrange how redeclaration chains are loaded, to remove a walk over all modules and reduce the number of declarations we load when loading a redeclaration chain. The new approach is: * when loading the first declaration of an entity within a module file, we first load all declarations of the entity that were imported into that module file, and then load all the other declarations of that entity from that module file and build a suitable decl chain from them * when loading any other declaration of an entity, we first load the first declaration from the same module file As before, we complete redecl chains through name lookup where necessary. To make this work, I also had to change the way that template specializations are stored -- it no longer suffices to track only canonical specializations; we now emit all "first local" declarations when emitting a list of specializations for a template. On one testcase with several thousand imported module files, this reduces the total runtime by 72%. llvm-svn: 245779
2015-08-22 09:47:18 +08:00
[modules] Remove some dead code after r245779. llvm-svn: 245780
2015-08-22 10:09:38 +08:00
return RedeclarableResult(FirstDeclID, MergeWith, IsKeyDecl);
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>
[modules] Rearrange and unify the way we determine if we need to pull in redeclaration chains when pulling in a declaration. We need the redecl chain unless we know some other declaration will trigger it to be pulled in; that happens if our originally-canonical declaration had all the knowledge that we have (and isn't us). llvm-svn: 213043
2014-07-15 11:37:06 +08:00
void ASTDeclReader::mergeRedeclarable(Redeclarable<T> *DBase,
When two templates get merged together, also merge their pattern declarations together. This is extremely hairy, because in general we need to have loaded both the template and the pattern before we can determine whether either should be merged, so we temporarily violate the rule that all merging happens before reading a decl ends, but *only* in the case where a template's pattern is being loaded while loading the template itself. In order to accomodate this for class templates, delay loading the injected class name type for the pattern of the template until after we've loaded the template itself, if we happen to load the template first. llvm-svn: 207063
2014-04-24 10:25:27 +08:00
RedeclarableResult &Redecl,
DeclID TemplatePatternID) {
[modules] Rearrange and unify the way we determine if we need to pull in redeclaration chains when pulling in a declaration. We need the redecl chain unless we know some other declaration will trigger it to be pulled in; that happens if our originally-canonical declaration had all the knowledge that we have (and isn't us). llvm-svn: 213043
2014-07-15 11:37:06 +08:00
T *D = static_cast<T*>(DBase);
Don't attempt to merge a deserialized declaration with existing declarations in the AST unless modules are enabled. This case doesn't come up with precompiled headers, and it isn't cheap. llvm-svn: 147451
2012-01-04 01:31:38 +08:00
// If modules are not available, there is no reason to perform this merge.
Unify naming of LangOptions variable/get function across the Clang stack (Lex to AST). The member variable is always "LangOpts" and the member function is always "getLangOpts". Reviewed by Chris Lattner llvm-svn: 152536
2012-03-11 15:00:24 +08:00
if (!Reader.getContext().getLangOpts().Modules)
Don't attempt to merge a deserialized declaration with existing declarations in the AST unless modules are enabled. This case doesn't come up with precompiled headers, and it isn't cheap. llvm-svn: 147451
2012-01-04 01:31:38 +08:00
return;
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
[modules] Don't bother looking up a declaration to merge into if we're not actually loading a formerly-canonical declaration. llvm-svn: 231742
2015-03-10 10:57:50 +08:00
// If we're not the canonical declaration, we don't need to merge.
if (!DBase->isFirstDecl())
return;
[modules] If a module declares an entity and then imports another declaration of that entity, ensure that the redeclaration chain is reordered properly on reload. Otherwise, the result of name lookup for that entity may point to an entity that is too old; if that's an injected friend name or the like, that can result in the name not being found at all. llvm-svn: 228371
2015-02-06 10:42:59 +08:00
if (auto *Existing = Redecl.getKnownMergeTarget())
// We already know of an existing declaration we should merge with.
mergeRedeclarable(D, cast<T>(Existing), Redecl, TemplatePatternID);
else if (FindExistingResult ExistingRes = findExisting(D))
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
if (T *Existing = ExistingRes)
When two templates get merged together, also merge their pattern declarations together. This is extremely hairy, because in general we need to have loaded both the template and the pattern before we can determine whether either should be merged, so we temporarily violate the rule that all merging happens before reading a decl ends, but *only* in the case where a template's pattern is being loaded while loading the template itself. In order to accomodate this for class templates, delay loading the injected class name type for the pattern of the template until after we've loaded the template itself, if we happen to load the template first. llvm-svn: 207063
2014-04-24 10:25:27 +08:00
mergeRedeclarable(D, Existing, Redecl, TemplatePatternID);
}
/// \brief "Cast" to type T, asserting if we don't have an implicit conversion.
/// We use this to put code in a template that will only be valid for certain
/// instantiations.
template<typename T> static T assert_cast(T t) { return t; }
template<typename T> static T assert_cast(...) {
llvm_unreachable("bad assert_cast");
}
/// \brief Merge together the pattern declarations from two template
/// declarations.
void ASTDeclReader::mergeTemplatePattern(RedeclarableTemplateDecl *D,
RedeclarableTemplateDecl *Existing,
[modules] Improve performance when there is a local declaration of an entity before the first imported declaration. We don't need to track all formerly-canonical declarations of an entity; it's sufficient to track those ones for which no other formerly-canonical declaration was imported into the same module. We call those ones "key declarations", and use them as our starting points for collecting redeclarations and performing namespace lookups. llvm-svn: 241999
2015-07-13 07:43:21 +08:00
DeclID DsID, bool IsKeyDecl) {
When two templates get merged together, also merge their pattern declarations together. This is extremely hairy, because in general we need to have loaded both the template and the pattern before we can determine whether either should be merged, so we temporarily violate the rule that all merging happens before reading a decl ends, but *only* in the case where a template's pattern is being loaded while loading the template itself. In order to accomodate this for class templates, delay loading the injected class name type for the pattern of the template until after we've loaded the template itself, if we happen to load the template first. llvm-svn: 207063
2014-04-24 10:25:27 +08:00
auto *DPattern = D->getTemplatedDecl();
auto *ExistingPattern = Existing->getTemplatedDecl();
[modules] Remove some dead code after r245779. llvm-svn: 245780
2015-08-22 10:09:38 +08:00
RedeclarableResult Result(DPattern->getCanonicalDecl()->getGlobalID(),
/*MergeWith*/ ExistingPattern, IsKeyDecl);
[modules] Sometimes we can deserialize a class member but not have yet encountered any definition for the class; this happens when the definition is added by an update record that is not yet loaded. In such a case, eagerly pick the original parent of the member as the canonical definition of the class rather than muddling through with the canonical declaration (the latter can lead to us failing to merge properly later if the canonical definition turns out to be some other declaration). llvm-svn: 226977
2015-01-24 09:07:20 +08:00
[modules] When merging a class template, also merge the definition of its pattern. llvm-svn: 212836
2014-07-12 02:22:58 +08:00
if (auto *DClass = dyn_cast<CXXRecordDecl>(DPattern)) {
// Merge with any existing definition.
// FIXME: This is duplicated in several places. Refactor.
auto *ExistingClass =
cast<CXXRecordDecl>(ExistingPattern)->getCanonicalDecl();
if (auto *DDD = DClass->DefinitionData.getNotUpdated()) {
[modules] Refactor and slightly simplify class definition merging. llvm-svn: 240200
2015-06-20 08:22:34 +08:00
if (ExistingClass->DefinitionData.getNotUpdated()) {
[modules] Sometimes we can deserialize a class member but not have yet encountered any definition for the class; this happens when the definition is added by an update record that is not yet loaded. In such a case, eagerly pick the original parent of the member as the canonical definition of the class rather than muddling through with the canonical declaration (the latter can lead to us failing to merge properly later if the canonical definition turns out to be some other declaration). llvm-svn: 226977
2015-01-24 09:07:20 +08:00
MergeDefinitionData(ExistingClass, std::move(*DDD));
[modules] When merging a class template, also merge the definition of its pattern. llvm-svn: 212836
2014-07-12 02:22:58 +08:00
} else {
ExistingClass->DefinitionData = DClass->DefinitionData;
[modules] Refactor and slightly simplify class definition merging. llvm-svn: 240200
2015-06-20 08:22:34 +08:00
// We may have skipped this before because we thought that DClass
// was the canonical declaration.
[modules] When merging the pattern of a class template definition into a prior definition, be sure to update the definition data on all declarations, not just the canonical one, since the pattern might not be in the list of pending definitions (if it used to be canonical itself). One-line fix by me; reduced testcase by Daniel Jasper! llvm-svn: 231950
2015-03-12 02:21:02 +08:00
Reader.PendingDefinitions.insert(DClass);
[modules] When merging a class template, also merge the definition of its pattern. llvm-svn: 212836
2014-07-12 02:22:58 +08:00
}
}
DClass->DefinitionData = ExistingClass->DefinitionData;
When two templates get merged together, also merge their pattern declarations together. This is extremely hairy, because in general we need to have loaded both the template and the pattern before we can determine whether either should be merged, so we temporarily violate the rule that all merging happens before reading a decl ends, but *only* in the case where a template's pattern is being loaded while loading the template itself. In order to accomodate this for class templates, delay loading the injected class name type for the pattern of the template until after we've loaded the template itself, if we happen to load the template first. llvm-svn: 207063
2014-04-24 10:25:27 +08:00
return mergeRedeclarable(DClass, cast<TagDecl>(ExistingPattern),
Result);
[modules] When merging a class template, also merge the definition of its pattern. llvm-svn: 212836
2014-07-12 02:22:58 +08:00
}
When two templates get merged together, also merge their pattern declarations together. This is extremely hairy, because in general we need to have loaded both the template and the pattern before we can determine whether either should be merged, so we temporarily violate the rule that all merging happens before reading a decl ends, but *only* in the case where a template's pattern is being loaded while loading the template itself. In order to accomodate this for class templates, delay loading the injected class name type for the pattern of the template until after we've loaded the template itself, if we happen to load the template first. llvm-svn: 207063
2014-04-24 10:25:27 +08:00
if (auto *DFunction = dyn_cast<FunctionDecl>(DPattern))
return mergeRedeclarable(DFunction, cast<FunctionDecl>(ExistingPattern),
Result);
if (auto *DVar = dyn_cast<VarDecl>(DPattern))
return mergeRedeclarable(DVar, cast<VarDecl>(ExistingPattern), Result);
[modules] PR20475: merging support for alias template declarations. llvm-svn: 214124
2014-07-29 05:16:37 +08:00
if (auto *DAlias = dyn_cast<TypeAliasDecl>(DPattern))
return mergeRedeclarable(DAlias, cast<TypedefNameDecl>(ExistingPattern),
Result);
When two templates get merged together, also merge their pattern declarations together. This is extremely hairy, because in general we need to have loaded both the template and the pattern before we can determine whether either should be merged, so we temporarily violate the rule that all merging happens before reading a decl ends, but *only* in the case where a template's pattern is being loaded while loading the template itself. In order to accomodate this for class templates, delay loading the injected class name type for the pattern of the template until after we've loaded the template itself, if we happen to load the template first. llvm-svn: 207063
2014-04-24 10:25:27 +08:00
llvm_unreachable("merged an unknown kind of redeclarable template");
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
}
/// \brief Attempts to merge the given declaration (D) with another declaration
/// of the same entity.
template<typename T>
When two templates get merged together, also merge their pattern declarations together. This is extremely hairy, because in general we need to have loaded both the template and the pattern before we can determine whether either should be merged, so we temporarily violate the rule that all merging happens before reading a decl ends, but *only* in the case where a template's pattern is being loaded while loading the template itself. In order to accomodate this for class templates, delay loading the injected class name type for the pattern of the template until after we've loaded the template itself, if we happen to load the template first. llvm-svn: 207063
2014-04-24 10:25:27 +08:00
void ASTDeclReader::mergeRedeclarable(Redeclarable<T> *DBase, T *Existing,
RedeclarableResult &Redecl,
DeclID TemplatePatternID) {
T *D = static_cast<T*>(DBase);
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
T *ExistingCanon = Existing->getCanonicalDecl();
When two templates get merged together, also merge their pattern declarations together. This is extremely hairy, because in general we need to have loaded both the template and the pattern before we can determine whether either should be merged, so we temporarily violate the rule that all merging happens before reading a decl ends, but *only* in the case where a template's pattern is being loaded while loading the template itself. In order to accomodate this for class templates, delay loading the injected class name type for the pattern of the template until after we've loaded the template itself, if we happen to load the template first. llvm-svn: 207063
2014-04-24 10:25:27 +08:00
T *DCanon = D->getCanonicalDecl();
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
if (ExistingCanon != DCanon) {
[modules] Don't bother looking up a declaration to merge into if we're not actually loading a formerly-canonical declaration. llvm-svn: 231742
2015-03-10 10:57:50 +08:00
assert(DCanon->getGlobalID() == Redecl.getFirstID() &&
"already merged this declaration");
[modules] Rearrange and unify the way we determine if we need to pull in redeclaration chains when pulling in a declaration. We need the redecl chain unless we know some other declaration will trigger it to be pulled in; that happens if our originally-canonical declaration had all the knowledge that we have (and isn't us). llvm-svn: 213043
2014-07-15 11:37:06 +08:00
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
// Have our redeclaration link point back at the canonical declaration
[modules] Rearrange and unify the way we determine if we need to pull in redeclaration chains when pulling in a declaration. We need the redecl chain unless we know some other declaration will trigger it to be pulled in; that happens if our originally-canonical declaration had all the knowledge that we have (and isn't us). llvm-svn: 213043
2014-07-15 11:37:06 +08:00
// of the existing declaration, so that this declaration has the
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
// appropriate canonical declaration.
D->RedeclLink = Redeclarable<T>::PreviousDeclLink(ExistingCanon);
Keep track of canonical decls in Redeclarable. More than 2x speedup on modules builds with large redecl chains. Roughly 15-20% speedup on non-modules builds for very large TUs. Between 2-3% cost in memory on large TUs. llvm-svn: 233228
2015-03-26 07:18:30 +08:00
D->First = ExistingCanon;
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
// When we merge a namespace, update its pointer to the first namespace.
[modules] Fix bug where an anonymous namespace could cause the containing namespace to not merge properly. We have an invariant here: after a declaration reads its canonical declaration, it can assume the canonical declaration is fully merged. This invariant can be violated if deserializing some declaration triggers the deserialization of a later declaration, because that later declaration can in turn deserialize a redeclaration of that first declaration before it is fully merged. The anonymous namespace for a namespace gets stored with the first declaration of that namespace, which may be before its parent namespace, so defer loading it until after we've finished merging the surrounding namespace. llvm-svn: 232455
2015-03-17 10:23:11 +08:00
// We cannot have loaded any redeclarations of this declaration yet, so
// there's nothing else that needs to be updated.
When two templates get merged together, also merge their pattern declarations together. This is extremely hairy, because in general we need to have loaded both the template and the pattern before we can determine whether either should be merged, so we temporarily violate the rule that all merging happens before reading a decl ends, but *only* in the case where a template's pattern is being loaded while loading the template itself. In order to accomodate this for class templates, delay loading the injected class name type for the pattern of the template until after we've loaded the template itself, if we happen to load the template first. llvm-svn: 207063
2014-04-24 10:25:27 +08:00
if (auto *Namespace = dyn_cast<NamespaceDecl>(D))
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
Namespace->AnonOrFirstNamespaceAndInline.setPointer(
When two templates get merged together, also merge their pattern declarations together. This is extremely hairy, because in general we need to have loaded both the template and the pattern before we can determine whether either should be merged, so we temporarily violate the rule that all merging happens before reading a decl ends, but *only* in the case where a template's pattern is being loaded while loading the template itself. In order to accomodate this for class templates, delay loading the injected class name type for the pattern of the template until after we've loaded the template itself, if we happen to load the template first. llvm-svn: 207063
2014-04-24 10:25:27 +08:00
assert_cast<NamespaceDecl*>(ExistingCanon));
// When we merge a template, merge its pattern.
if (auto *DTemplate = dyn_cast<RedeclarableTemplateDecl>(D))
mergeTemplatePattern(
DTemplate, assert_cast<RedeclarableTemplateDecl*>(ExistingCanon),
[modules] Improve performance when there is a local declaration of an entity before the first imported declaration. We don't need to track all formerly-canonical declarations of an entity; it's sufficient to track those ones for which no other formerly-canonical declaration was imported into the same module. We call those ones "key declarations", and use them as our starting points for collecting redeclarations and performing namespace lookups. llvm-svn: 241999
2015-07-13 07:43:21 +08:00
TemplatePatternID, Redecl.isKeyDecl());
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
[modules] Improve performance when there is a local declaration of an entity before the first imported declaration. We don't need to track all formerly-canonical declarations of an entity; it's sufficient to track those ones for which no other formerly-canonical declaration was imported into the same module. We call those ones "key declarations", and use them as our starting points for collecting redeclarations and performing namespace lookups. llvm-svn: 241999
2015-07-13 07:43:21 +08:00
// If this declaration is a key declaration, make a note of that.
[modules] Rearrange how redeclaration chains are loaded, to remove a walk over all modules and reduce the number of declarations we load when loading a redeclaration chain. The new approach is: * when loading the first declaration of an entity within a module file, we first load all declarations of the entity that were imported into that module file, and then load all the other declarations of that entity from that module file and build a suitable decl chain from them * when loading any other declaration of an entity, we first load the first declaration from the same module file As before, we complete redecl chains through name lookup where necessary. To make this work, I also had to change the way that template specializations are stored -- it no longer suffices to track only canonical specializations; we now emit all "first local" declarations when emitting a list of specializations for a template. On one testcase with several thousand imported module files, this reduces the total runtime by 72%. llvm-svn: 245779
2015-08-22 09:47:18 +08:00
if (Redecl.isKeyDecl())
[modules] Improve performance when there is a local declaration of an entity before the first imported declaration. We don't need to track all formerly-canonical declarations of an entity; it's sufficient to track those ones for which no other formerly-canonical declaration was imported into the same module. We call those ones "key declarations", and use them as our starting points for collecting redeclarations and performing namespace lookups. llvm-svn: 241999
2015-07-13 07:43:21 +08:00
Reader.KeyDecls[ExistingCanon].push_back(Redecl.getFirstID());
Factor the merging of declarations in the AST reader out to a separate member function template, since the behavior is identical for ObjCInterfaceDecl and ObjCProtocolDecl. It's expected that all redeclarable entities will have the same behavior. llvm-svn: 147450
2012-01-04 01:27:13 +08:00
}
}
When merging class definitions across modules in C++, merge together fields. This change doesn't go all the way to making fields redeclarable; instead, it makes them 'mergeable', which means we can find the canonical declaration, but not much else (and for a declaration that's not from a module, the canonical declaration is always that declaration). llvm-svn: 192092
2013-10-07 16:02:11 +08:00
/// \brief Attempts to merge the given declaration (D) with another declaration
/// of the same entity, for the case where the entity is not actually
/// redeclarable. This happens, for instance, when merging the fields of
/// identical class definitions from two different modules.
template<typename T>
void ASTDeclReader::mergeMergeable(Mergeable<T> *D) {
// If modules are not available, there is no reason to perform this merge.
if (!Reader.getContext().getLangOpts().Modules)
return;
C++ modules: merging for enumerations and enumerators with multiple definitions (eg through template instantiations in multiple modules). llvm-svn: 192740
2013-10-16 06:02:41 +08:00
// ODR-based merging is only performed in C++. In C, identically-named things
// in different translation units are not redeclarations (but may still have
// compatible types).
if (!Reader.getContext().getLangOpts().CPlusPlus)
return;
When merging class definitions across modules in C++, merge together fields. This change doesn't go all the way to making fields redeclarable; instead, it makes them 'mergeable', which means we can find the canonical declaration, but not much else (and for a declaration that's not from a module, the canonical declaration is always that declaration). llvm-svn: 192092
2013-10-07 16:02:11 +08:00
if (FindExistingResult ExistingRes = findExisting(static_cast<T*>(D)))
if (T *Existing = ExistingRes)
Reader.Context.setPrimaryMergedDecl(static_cast<T*>(D),
Existing->getCanonicalDecl());
}
OpenMP threadprivate directive parsing and semantic analysis llvm-svn: 177705
2013-03-22 14:34:35 +08:00
void ASTDeclReader::VisitOMPThreadPrivateDecl(OMPThreadPrivateDecl *D) {
VisitDecl(D);
unsigned NumVars = D->varlist_size();
OpenMP threadprivate with qualified names. llvm-svn: 181683
2013-05-13 12:18:18 +08:00
SmallVector<Expr *, 16> Vars;
OpenMP threadprivate directive parsing and semantic analysis llvm-svn: 177705
2013-03-22 14:34:35 +08:00
Vars.reserve(NumVars);
for (unsigned i = 0; i != NumVars; ++i) {
OpenMP threadprivate with qualified names. llvm-svn: 181683
2013-05-13 12:18:18 +08:00
Vars.push_back(Reader.ReadExpr(F));
OpenMP threadprivate directive parsing and semantic analysis llvm-svn: 177705
2013-03-22 14:34:35 +08:00
}
D->setVars(Vars);
}
[OPENMP 4.0] Initial support for 'omp declare reduction' construct. Add parsing, sema analysis and serialization/deserialization for 'declare reduction' construct. User-defined reductions are defined as #pragma omp declare reduction( reduction-identifier : typename-list : combiner ) [initializer ( initializer-expr )] These custom reductions may be used in 'reduction' clauses of OpenMP constructs. The combiner specifies how partial results can be combined into a single value. The combiner can use the special variable identifiers omp_in and omp_out that are of the type of the variables being reduced with this reduction-identifier. Each of them will denote one of the values to be combined before executing the combiner. It is assumed that the special omp_out identifier will refer to the storage that holds the resulting combined value after executing the combiner. As the initializer-expr value of a user-defined reduction is not known a priori the initializer-clause can be used to specify one. Then the contents of the initializer-clause will be used as the initializer for private copies of reduction list items where the omp_priv identifier will refer to the storage to be initialized. The special identifier omp_orig can also appear in the initializer-clause and it will refer to the storage of the original variable to be reduced. Differential Revision: http://reviews.llvm.org/D11182 llvm-svn: 262582
2016-03-03 13:21:39 +08:00
void ASTDeclReader::VisitOMPDeclareReductionDecl(OMPDeclareReductionDecl *D) {
[OPENMP 4.0] Codegen for 'declare reduction' construct. Emit function for 'combiner' part of 'declare reduction' construct and 'initialilzer' part, if any. llvm-svn: 262699
2016-03-04 17:22:22 +08:00
VisitValueDecl(D);
[OPENMP 4.0] Initial support for 'omp declare reduction' construct. Add parsing, sema analysis and serialization/deserialization for 'declare reduction' construct. User-defined reductions are defined as #pragma omp declare reduction( reduction-identifier : typename-list : combiner ) [initializer ( initializer-expr )] These custom reductions may be used in 'reduction' clauses of OpenMP constructs. The combiner specifies how partial results can be combined into a single value. The combiner can use the special variable identifiers omp_in and omp_out that are of the type of the variables being reduced with this reduction-identifier. Each of them will denote one of the values to be combined before executing the combiner. It is assumed that the special omp_out identifier will refer to the storage that holds the resulting combined value after executing the combiner. As the initializer-expr value of a user-defined reduction is not known a priori the initializer-clause can be used to specify one. Then the contents of the initializer-clause will be used as the initializer for private copies of reduction list items where the omp_priv identifier will refer to the storage to be initialized. The special identifier omp_orig can also appear in the initializer-clause and it will refer to the storage of the original variable to be reduced. Differential Revision: http://reviews.llvm.org/D11182 llvm-svn: 262582
2016-03-03 13:21:39 +08:00
D->setLocation(Reader.ReadSourceLocation(F, Record, Idx));
D->setCombiner(Reader.ReadExpr(F));
D->setInitializer(Reader.ReadExpr(F));
D->PrevDeclInScope = Reader.ReadDeclID(F, Record, Idx);
}
[OPENMP] Rename OMPCapturedFieldDecl to OMPCapturedExprDecl, NFC. OMPCapturedExprDecl allows caopturing not only of fielddecls, but also other expressions. It also allows to simplify codegen for several clauses. llvm-svn: 260492
2016-02-11 13:35:55 +08:00
void ASTDeclReader::VisitOMPCapturedExprDecl(OMPCapturedExprDecl *D) {
[OPENMP 4.5] Ccapture/codegen of private non-static data members. OpenMP 4.5 introduces privatization of non-static data members of current class in non-static member functions. To correctly handle such kind of privatization a new (pseudo)declaration VarDecl-based node is added. It allows to reuse an existing code for capturing variables in Lambdas/Block/Captured blocks of code for correct privatization and codegen. llvm-svn: 260077
2016-02-08 17:29:13 +08:00
VisitVarDecl(D);
}
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) {
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
Attr *New = nullptr;
Implement first TD-based usage of attributes. Currently, there are two effective changes: - Attr::Kind has been changed to attr::Kind, in a separate namespace rather than the Attr class. This is because the enumerator needs to be visible to parse. - The class definitions for the C++0x attributes other than aligned are generated by TableGen. The specific classes generated by TableGen are controlled by an array in TableGen (see the accompanying commit to the LLVM repository). I will be expanding the amount of code generated as I develop the new attributes system while initially keeping it confined to these attributes. llvm-svn: 106172
2010-06-17 07:43:53 +08:00
attr::Kind Kind = (attr::Kind)Record[Idx++];
Keep the source range of attributes. Depends on a llvm tablegen commit. llvm-svn: 139600
2011-09-14 00:05:58 +08:00
SourceRange Range = ReadSourceRange(F, Record, Idx);
move attribute reading to PCHReaderDecl.cpp, remove some extraneous braces. llvm-svn: 70191
2009-04-27 14:01:06 +08:00
Generate Attr subclasses with TableGen. Now all classes derived from Attr are generated from TableGen. Additionally, Attr* is no longer its own linked list; SmallVectors or Attr* are used. The accompanying LLVM commit contains the updates to TableGen necessary for this. Some other notes about newly-generated attribute classes: - The constructor arguments are a SourceLocation and a Context&, followed by the attributes arguments in the order that they were defined in Attr.td - Every argument in Attr.td has an appropriate accessor named getFoo, and there are sometimes a few extra ones (such as to get the length of a variadic argument). Additionally, specific_attr_iterator has been introduced, which will iterate over an AttrVec, but only over attributes of a certain type. It can be accessed through either Decl::specific_attr_begin/end or the global functions of the same name. llvm-svn: 111455
2010-08-19 07:23:40 +08:00
#include "clang/Serialization/AttrPCHRead.inc"
move attribute reading to PCHReaderDecl.cpp, remove some extraneous braces. llvm-svn: 70191
2009-04-27 14:01:06 +08:00
assert(New && "Unable to decode attribute?");
Generate Attr subclasses with TableGen. Now all classes derived from Attr are generated from TableGen. Additionally, Attr* is no longer its own linked list; SmallVectors or Attr* are used. The accompanying LLVM commit contains the updates to TableGen necessary for this. Some other notes about newly-generated attribute classes: - The constructor arguments are a SourceLocation and a Context&, followed by the attributes arguments in the order that they were defined in Attr.td - Every argument in Attr.td has an appropriate accessor named getFoo, and there are sometimes a few extra ones (such as to get the length of a variadic argument). Additionally, specific_attr_iterator has been introduced, which will iterate over an AttrVec, but only over attributes of a certain type. It can be accessed through either Decl::specific_attr_begin/end or the global functions of the same name. llvm-svn: 111455
2010-08-19 07:23:40 +08:00
Attrs.push_back(New);
move attribute reading to PCHReaderDecl.cpp, remove some extraneous braces. llvm-svn: 70191
2009-04-27 14:01:06 +08:00
}
}
//===----------------------------------------------------------------------===//
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
// ASTReader Implementation
move attribute reading to PCHReaderDecl.cpp, remove some extraneous braces. llvm-svn: 70191
2009-04-27 14:01:06 +08:00
//===----------------------------------------------------------------------===//
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
/// \brief Note that we have loaded the declaration with the given
/// Index.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
///
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
/// This routine notes that this declaration has already been loaded,
/// so that future GetDecl calls will return this declaration rather
/// than trying to load a new declaration.
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
inline void ASTReader::LoadedDecl(unsigned Index, Decl *D) {
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
assert(!DeclsLoaded[Index] && "Decl loaded twice?");
DeclsLoaded[Index] = D;
}
/// \brief Determine whether the consumer will be interested in seeing
/// this declaration (via HandleTopLevelDecl).
///
/// This routine should return true for anything that might affect
/// code generation, e.g., inline function definitions, Objective-C
/// declarations with metadata, etc.
When we load a function or method body from an AST file, we check whether that function/method already has a body (loaded from some other AST file), as introduced in r165137. Delay this check until after the redeclaration chains have been wired up. While I'm here, make the loading of method bodies lazy. llvm-svn: 165513
2012-10-10 01:21:28 +08:00
static bool isConsumerInterestedIn(Decl *D, bool HasBody) {
[PCH] Fix a regression that r139441 introduced (decls were getting passed to the consumer without being fully deserialized). The regression was on compiling boost.python and it was too difficult to get a reduced test case unfortunately. Also modify the logic of how objc methods are getting passed to the consumer; codegen depended on receiving objc methods before the implementation decl. Since the interesting objc methods are ones with a body and such methods only exist inside an ObjCImplDecl, deserialize and pass to consumer all the methods of ObCImplDecl when we see one. Fixes http://llvm.org/PR10922 & rdar://10117105. llvm-svn: 139644
2011-09-14 05:35:00 +08:00
// An ObjCMethodDecl is never considered as "interesting" because its
// implementation container always is.
Clean up our handling of Objective-C definitions in AST files. Rather than having CodeGen check whether a declaration comes from an AST file (which it shouldn't know or care about), make sure that the AST writer and reader pass along "interesting" declarations that CodeGen needs to know about. llvm-svn: 139441
2011-09-10 08:22:34 +08:00
if (isa<FileScopeAsmDecl>(D) ||
isa<ObjCProtocolDecl>(D) ||
Fix autolinking when modules are imported in pch files Add the ImportDecl to the set of interesting delcarations that are deserialized eagerly when an AST file is loaded (rather than lazily like most decls). This is required to get auto linking to work when there is no explicit import in the main file. Also resolve a FIXME to rename 'ExternalDefinitions', since that is only one of the things that need eager deserialization. The new name is 'EagerlyDeserializedDecls'. The corresponding AST bitcode is also renamed. llvm-svn: 200505
2014-01-31 09:06:56 +08:00
isa<ObjCImplDecl>(D) ||
[OPENMP] Codegen for threadprivate variables For all threadprivate variables which have constructor/destructor emit call to void __kmpc_threadprivate_register(ident_t * <Current Location>, void *<Original Global Addr>, kmpc_ctor <Constructor>, kmpc_cctor NULL, kmpc_dtor <Destructor>); In expressions all references to such variables are replaced by calls to void *__kmpc_threadprivate_cached(ident_t *<Current Location>, kmp_int32 <Current Thread Id>, void *<Original Global Addr>, size_t <Size of Data>, void ***<Pointer to autogenerated cache – array of private copies of threadprivate variable>); Test test/OpenMP/threadprivate_codegen.cpp checks that codegen is correct. Also it checks that codegen is correct after serialization/deserialization and one of passes verifies debug info. Differential Revision: http://reviews.llvm.org/D4002 llvm-svn: 221663
2014-11-11 12:05:39 +08:00
isa<ImportDecl>(D) ||
Serialize `#pragma comment`. `#pragma comment` was handled by Sema calling a function on ASTConsumer, and CodeGen then implementing this function and writing things to its output. Instead, introduce a PragmaCommentDecl AST node and hang one off the TranslationUnitDecl for every `#pragma comment` line, and then use the regular serialization machinery. (Since PragmaCommentDecl has codegen relevance, it's eagerly deserialized.) http://reviews.llvm.org/D17799 llvm-svn: 262493
2016-03-03 01:28:48 +08:00
isa<PragmaCommentDecl>(D) ||
[OPENMP 4.0] Codegen for 'declare reduction' construct. Emit function for 'combiner' part of 'declare reduction' construct and 'initialilzer' part, if any. llvm-svn: 262699
2016-03-04 17:22:22 +08:00
isa<PragmaDetectMismatchDecl>(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;
[OPENMP 4.0] Codegen for 'declare reduction' construct. Emit function for 'combiner' part of 'declare reduction' construct and 'initialilzer' part, if any. llvm-svn: 262699
2016-03-04 17:22:22 +08:00
if (isa<OMPThreadPrivateDecl>(D) || isa<OMPDeclareReductionDecl>(D))
return !D->getDeclContext()->isFunctionOrMethod();
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
if (VarDecl *Var = dyn_cast<VarDecl>(D))
Make sure C++ variable definitions are actually passed to the consumer when loaded from PCH. llvm-svn: 110322
2010-08-05 17:47:59 +08:00
return Var->isFileVarDecl() &&
Var->isThisDeclarationADefinition() == VarDecl::Definition;
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
if (FunctionDecl *Func = dyn_cast<FunctionDecl>(D))
When we load a function or method body from an AST file, we check whether that function/method already has a body (loaded from some other AST file), as introduced in r165137. Delay this check until after the redeclaration chains have been wired up. While I'm here, make the loading of method bodies lazy. llvm-svn: 165513
2012-10-10 01:21:28 +08:00
return Func->doesThisDeclarationHaveABody() || HasBody;
Clean up our handling of Objective-C definitions in AST files. Rather than having CodeGen check whether a declaration comes from an AST file (which it shouldn't know or care about), make sure that the AST writer and reader pass along "interesting" declarations that CodeGen needs to know about. llvm-svn: 139441
2011-09-10 08:22:34 +08:00
return false;
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Use a ContinuousRangeMap to map from the global declaration ID in the AST reader down to the AST file + local ID within that file, rather than lamely walking the PCH chain. There's no actual functionality change now, but this is cleaner and more general. llvm-svn: 135548
2011-07-20 08:27:43 +08:00
/// \brief Get the correct cursor and offset for loading a declaration.
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
ASTReader::RecordLocation
[PCH] Pull the location out of the serialized declarations and put it in the array of decl bit offsets. This allows us to easily get at the location of a decl without deserializing it. It increases size of Cocoa PCH by only 0.2%. llvm-svn: 143123
2011-10-28 02:47:35 +08:00
ASTReader::DeclCursorForID(DeclID ID, unsigned &RawLocation) {
Instead of modifying the ObjC AST to not modify existing declarations, teach chained PCH to overwrite declarations from earlier PCH files in dependent ones. Tell Sema to note when it changes AST nodes so that they have to be reserialized. Finally, the ObjCProtocolDecls created in forward decls, like the ObjCInterfaceDecls in @class forward decls, are not lexically part of the decl context; only the definition is. llvm-svn: 110989
2010-08-13 08:28:03 +08:00
// See if there's an override.
DeclReplacementMap::iterator It = ReplacedDecls.find(ID);
[PCH] Now that we store the location of a decl outside its record make sure that we keep track of locations of replaced decls as well. llvm-svn: 143341
2011-10-31 15:20:15 +08:00
if (It != ReplacedDecls.end()) {
RawLocation = It->second.RawLoc;
return RecordLocation(It->second.Mod, It->second.Offset);
}
Instead of modifying the ObjC AST to not modify existing declarations, teach chained PCH to overwrite declarations from earlier PCH files in dependent ones. Tell Sema to note when it changes AST nodes so that they have to be reserialized. Finally, the ObjCProtocolDecls created in forward decls, like the ObjCInterfaceDecls in @class forward decls, are not lexically part of the decl context; only the definition is. llvm-svn: 110989
2010-08-13 08:28:03 +08:00
Use a ContinuousRangeMap to map from the global declaration ID in the AST reader down to the AST file + local ID within that file, rather than lamely walking the PCH chain. There's no actual functionality change now, but this is cleaner and more general. llvm-svn: 135548
2011-07-20 08:27:43 +08:00
GlobalDeclMapType::iterator I = GlobalDeclMap.find(ID);
assert(I != GlobalDeclMap.end() && "Corrupted global declaration map");
Promote ModuleMap::Module to a namespace-scope class in the Basic library, since modules cut across all of the libraries. Rename serialization::Module to serialization::ModuleFile to side-step the annoying naming conflict. Prune a bunch of ModuleMap.h includes that are no longer needed (most files only needed the Module type). llvm-svn: 145538
2011-12-01 07:21:26 +08:00
ModuleFile *M = I->second;
[PCH] Pull the location out of the serialized declarations and put it in the array of decl bit offsets. This allows us to easily get at the location of a decl without deserializing it. It increases size of Cocoa PCH by only 0.2%. llvm-svn: 143123
2011-10-28 02:47:35 +08:00
const DeclOffset &
DOffs = M->DeclOffsets[ID - M->BaseDeclID - NUM_PREDEF_DECL_IDS];
RawLocation = DOffs.Loc;
return RecordLocation(M, DOffs.BitOffset);
Allow loading declarations from any file in the chain. WIP llvm-svn: 108956
2010-07-21 06:46:15 +08:00
}
Introduce a global bit-offset continuous range map into the ASTReader, so that we have one, simple way to map from global bit offsets to local bit offsets. Eliminates a number of loops over the chain, and generalizes for more interesting bit remappings. Also, as an amusing oddity, we were computing global bit offsets *backwards* for preprocessed entities (e.g., the directly included PCH file in the chain would start at offset zero, rather than the original PCH that occurs first in translation unit). Even more amusingly, it made precompiled preambles work, because we were forgetting to adjust the local bit offset to a global bit offset when storing preprocessed entity offsets in the ASTUnit. Two wrongs made a right, and now they're both right. llvm-svn: 135750
2011-07-22 14:10:01 +08:00
ASTReader::RecordLocation ASTReader::getLocalBitOffset(uint64_t GlobalOffset) {
Promote ModuleMap::Module to a namespace-scope class in the Basic library, since modules cut across all of the libraries. Rename serialization::Module to serialization::ModuleFile to side-step the annoying naming conflict. Prune a bunch of ModuleMap.h includes that are no longer needed (most files only needed the Module type). llvm-svn: 145538
2011-12-01 07:21:26 +08:00
ContinuousRangeMap<uint64_t, ModuleFile*, 4>::iterator I
Introduce a global bit-offset continuous range map into the ASTReader, so that we have one, simple way to map from global bit offsets to local bit offsets. Eliminates a number of loops over the chain, and generalizes for more interesting bit remappings. Also, as an amusing oddity, we were computing global bit offsets *backwards* for preprocessed entities (e.g., the directly included PCH file in the chain would start at offset zero, rather than the original PCH that occurs first in translation unit). Even more amusingly, it made precompiled preambles work, because we were forgetting to adjust the local bit offset to a global bit offset when storing preprocessed entity offsets in the ASTUnit. Two wrongs made a right, and now they're both right. llvm-svn: 135750
2011-07-22 14:10:01 +08:00
= GlobalBitOffsetsMap.find(GlobalOffset);
assert(I != GlobalBitOffsetsMap.end() && "Corrupted global bit offsets map");
return RecordLocation(I->second, GlobalOffset - I->second->GlobalBitOffset);
}
Promote ModuleMap::Module to a namespace-scope class in the Basic library, since modules cut across all of the libraries. Rename serialization::Module to serialization::ModuleFile to side-step the annoying naming conflict. Prune a bunch of ModuleMap.h includes that are no longer needed (most files only needed the Module type). llvm-svn: 145538
2011-12-01 07:21:26 +08:00
uint64_t ASTReader::getGlobalBitOffset(ModuleFile &M, uint32_t LocalOffset) {
Don't introduce a local -> global mapping for CXXBaseSpecifiers. The IDs will never cross module boundaries, since they're tied to the CXXDefinitionData, so just use a local mapping throughout. Eliminate the global -> local tables and supporting data. llvm-svn: 136847
2011-08-04 08:01:48 +08:00
return LocalOffset + M.GlobalBitOffset;
}
Check for matching template-parameter-lists when merging template declarations. llvm-svn: 184791
2013-06-25 06:51:00 +08:00
static bool isSameTemplateParameterList(const TemplateParameterList *X,
const TemplateParameterList *Y);
/// \brief Determine whether two template parameters are similar enough
/// that they may be used in declarations of the same template.
static bool isSameTemplateParameter(const NamedDecl *X,
const NamedDecl *Y) {
if (X->getKind() != Y->getKind())
return false;
if (const TemplateTypeParmDecl *TX = dyn_cast<TemplateTypeParmDecl>(X)) {
const TemplateTypeParmDecl *TY = cast<TemplateTypeParmDecl>(Y);
return TX->isParameterPack() == TY->isParameterPack();
}
if (const NonTypeTemplateParmDecl *TX = dyn_cast<NonTypeTemplateParmDecl>(X)) {
const NonTypeTemplateParmDecl *TY = cast<NonTypeTemplateParmDecl>(Y);
return TX->isParameterPack() == TY->isParameterPack() &&
TX->getASTContext().hasSameType(TX->getType(), TY->getType());
}
const TemplateTemplateParmDecl *TX = cast<TemplateTemplateParmDecl>(X);
const TemplateTemplateParmDecl *TY = cast<TemplateTemplateParmDecl>(Y);
return TX->isParameterPack() == TY->isParameterPack() &&
isSameTemplateParameterList(TX->getTemplateParameters(),
TY->getTemplateParameters());
}
[modules] Merging for class-scope using-declarations. llvm-svn: 219657
2014-10-14 10:00:47 +08:00
static NamespaceDecl *getNamespace(const NestedNameSpecifier *X) {
if (auto *NS = X->getAsNamespace())
return NS;
if (auto *NAS = X->getAsNamespaceAlias())
return NAS->getNamespace();
return nullptr;
}
static bool isSameQualifier(const NestedNameSpecifier *X,
const NestedNameSpecifier *Y) {
if (auto *NSX = getNamespace(X)) {
auto *NSY = getNamespace(Y);
if (!NSY || NSX->getCanonicalDecl() != NSY->getCanonicalDecl())
return false;
} else if (X->getKind() != Y->getKind())
return false;
// FIXME: For namespaces and types, we're permitted to check that the entity
// is named via the same tokens. We should probably do so.
switch (X->getKind()) {
case NestedNameSpecifier::Identifier:
if (X->getAsIdentifier() != Y->getAsIdentifier())
return false;
break;
case NestedNameSpecifier::Namespace:
case NestedNameSpecifier::NamespaceAlias:
// We've already checked that we named the same namespace.
break;
case NestedNameSpecifier::TypeSpec:
case NestedNameSpecifier::TypeSpecWithTemplate:
if (X->getAsType()->getCanonicalTypeInternal() !=
Y->getAsType()->getCanonicalTypeInternal())
return false;
break;
case NestedNameSpecifier::Global:
case NestedNameSpecifier::Super:
return true;
}
// Recurse into earlier portion of NNS, if any.
auto *PX = X->getPrefix();
auto *PY = Y->getPrefix();
if (PX && PY)
return isSameQualifier(PX, PY);
return !PX && !PY;
}
Check for matching template-parameter-lists when merging template declarations. llvm-svn: 184791
2013-06-25 06:51:00 +08:00
/// \brief Determine whether two template parameter lists are similar enough
/// that they may be used in declarations of the same template.
static bool isSameTemplateParameterList(const TemplateParameterList *X,
const TemplateParameterList *Y) {
if (X->size() != Y->size())
return false;
for (unsigned I = 0, N = X->size(); I != N; ++I)
if (!isSameTemplateParameter(X->getParam(I), Y->getParam(I)))
return false;
return true;
}
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
/// \brief Determine whether the two declarations refer to the same entity.
static bool isSameEntity(NamedDecl *X, NamedDecl *Y) {
assert(X->getDeclName() == Y->getDeclName() && "Declaration name mismatch!");
[modules] Make NamespaceAliasDecl redeclarable, as it should be. This fixes merging of namespace aliases across modules and improves source fidelity. Incidentally also fixes PR20816. llvm-svn: 217103
2014-09-04 07:11:22 +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
if (X == Y)
return true;
[modules] Make NamespaceAliasDecl redeclarable, as it should be. This fixes merging of namespace aliases across modules and improves source fidelity. Incidentally also fixes PR20816. llvm-svn: 217103
2014-09-04 07:11:22 +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
// 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());
[modules] Make NamespaceAliasDecl redeclarable, as it should be. This fixes merging of namespace aliases across modules and improves source fidelity. Incidentally also fixes PR20816. llvm-svn: 217103
2014-09-04 07:11:22 +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;
[modules] Make NamespaceAliasDecl redeclarable, as it should be. This fixes merging of namespace aliases across modules and improves source fidelity. Incidentally also fixes PR20816. llvm-svn: 217103
2014-09-04 07:11:22 +08:00
Implement declaration merging for Objective-C protocols across multiple, disjoint modules. There is far too much duplicating with the ObjCInterfaceDecl case here, which I'll eliminate shortly. llvm-svn: 147417
2012-01-02 05:47:52 +08:00
// Objective-C classes and protocols with the same name always match.
if (isa<ObjCInterfaceDecl>(X) || isa<ObjCProtocolDecl>(X))
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
return true;
Fix bitcode desynchronization when loading a PCH containing a class template specialization with modules enabled. Just don't merge them at all for now; we'll revisit this when support for template merging is added. In passing, make Decl::dump() a little safer to use with PCH/modules, by making it not deserialize any additional declarations. From a debugger you can call decls_begin() or similar first if you want to dump all child decls. llvm-svn: 182544
2013-05-23 09:49:11 +08:00
if (isa<ClassTemplateSpecializationDecl>(X)) {
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
// No need to handle these here: we merge them when adding them to the
// template.
Fix bitcode desynchronization when loading a PCH containing a class template specialization with modules enabled. Just don't merge them at all for now; we'll revisit this when support for template merging is added. In passing, make Decl::dump() a little safer to use with PCH/modules, by making it not deserialize any additional declarations. From a debugger you can call decls_begin() or similar first if you want to dump all child decls. llvm-svn: 182544
2013-05-23 09:49:11 +08:00
return false;
}
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
Implement cross-module declaration merging for tag declarations, so that if two modules A and B both contain a declaration of a tag such as struct X; and those two modules are unrelated, the two declarations of X will be merged into a single redeclaration chain. llvm-svn: 147488
2012-01-04 06:46:00 +08:00
// Compatible tags match.
Normalize line endings of r163013 (part 2). llvm-svn: 163032
2012-09-01 06:18:20 +08:00
if (TagDecl *TagX = dyn_cast<TagDecl>(X)) {
TagDecl *TagY = cast<TagDecl>(Y);
return (TagX->getTagKind() == TagY->getTagKind()) ||
((TagX->getTagKind() == TTK_Struct || TagX->getTagKind() == TTK_Class ||
TagX->getTagKind() == TTK_Interface) &&
(TagY->getTagKind() == TTK_Struct || TagY->getTagKind() == TTK_Class ||
TagY->getTagKind() == TTK_Interface));
}
Slightly improve cross-module merging for function templates. llvm-svn: 184689
2013-06-24 12:45:28 +08:00
Normalize line endings of r163013 (part 2). llvm-svn: 163032
2012-09-01 06:18:20 +08:00
// Functions with the same type and linkage match.
[modules] Make NamespaceAliasDecl redeclarable, as it should be. This fixes merging of namespace aliases across modules and improves source fidelity. Incidentally also fixes PR20816. llvm-svn: 217103
2014-09-04 07:11:22 +08:00
// FIXME: This needs to cope with merging of prototyped/non-prototyped
// functions, etc.
Implement declaration merging for non-template functions from different modules. This implementation is a first approximation of what we want, using only the function type to determine equivalence. Later, we'll want to deal with some of the more subtle issues, including: - C allows a prototyped declaration and a non-prototyped declaration to be merged, which we should support - We may want to ignore the return type when merging, then complain if the return types differ. Or, we may want to leave it as it us, so that we only complain if overload resolution eventually fails. - C++ non-static member functions need to consider cv-qualifiers and ref-qualifiers. - Function templates need to consider the template parameters and return type. - Function template specializations will have special rules. - We can now (accidentally!) end up overloading in C, even without the "overloadable" attribute, and will need to detect this at some point. The actual detection of "is this an overload?" is implemented by Sema::IsOverload(), which will need to be moved into the AST library for re-use here. That will be a future refactor. llvm-svn: 147534
2012-01-05 01:13:46 +08:00
if (FunctionDecl *FuncX = dyn_cast<FunctionDecl>(X)) {
FunctionDecl *FuncY = cast<FunctionDecl>(Y);
Cleanup handling of UniqueExternalLinkage. This patch renames getLinkage to getLinkageInternal. Only code that needs to handle UniqueExternalLinkage specially should call this. Linkage, as defined in the c++ standard, is provided by getFormalLinkage. It maps UniqueExternalLinkage to ExternalLinkage. Most places in the compiler actually want isExternallyVisible, which handles UniqueExternalLinkage as internal. llvm-svn: 181677
2013-05-13 08:12:11 +08:00
return (FuncX->getLinkageInternal() == FuncY->getLinkageInternal()) &&
Implement declaration merging for non-template functions from different modules. This implementation is a first approximation of what we want, using only the function type to determine equivalence. Later, we'll want to deal with some of the more subtle issues, including: - C allows a prototyped declaration and a non-prototyped declaration to be merged, which we should support - We may want to ignore the return type when merging, then complain if the return types differ. Or, we may want to leave it as it us, so that we only complain if overload resolution eventually fails. - C++ non-static member functions need to consider cv-qualifiers and ref-qualifiers. - Function templates need to consider the template parameters and return type. - Function template specializations will have special rules. - We can now (accidentally!) end up overloading in C, even without the "overloadable" attribute, and will need to detect this at some point. The actual detection of "is this an overload?" is implemented by Sema::IsOverload(), which will need to be moved into the AST library for re-use here. That will be a future refactor. llvm-svn: 147534
2012-01-05 01:13:46 +08:00
FuncX->getASTContext().hasSameType(FuncX->getType(), FuncY->getType());
}
Also merge template redeclarations. Don't require specializations (of existing and read template) to be unique. llvm-svn: 164931
2012-10-01 17:18:00 +08:00
Implement declaration merging for variables in disjoint modules. llvm-svn: 147535
2012-01-05 01:21:36 +08:00
// Variables with the same type and linkage match.
if (VarDecl *VarX = dyn_cast<VarDecl>(X)) {
VarDecl *VarY = cast<VarDecl>(Y);
Merge templated static member variables, fixes http://llvm.org/pr26179. Patch by Vassil Vassilev! Reviewed by Richard Smith. llvm-svn: 258524
2016-01-23 03:03:27 +08:00
if (VarX->getLinkageInternal() == VarY->getLinkageInternal()) {
ASTContext &C = VarX->getASTContext();
if (C.hasSameType(VarX->getType(), VarY->getType()))
return true;
// We can get decls with different types on the redecl chain. Eg.
// template <typename T> struct S { static T Var[]; }; // #1
// template <typename T> T S<T>::Var[sizeof(T)]; // #2
// Only? happens when completing an incomplete array type. In this case
[modules] Prefer more complete array types. If we import a module that has a complete array type and one that has an incomplete array type, the declaration found by name lookup might be the one with the incomplete type, possibly resulting in rejects-valid. Now, the name lookup prefers decls with a complete array types. Also, diagnose cases when the redecl chain has array bound, different from the merge candidate. Reviewed by Richard Smith. llvm-svn: 262189
2016-02-29 03:08:24 +08:00
// when comparing #1 and #2 we should go through their element type.
Merge templated static member variables, fixes http://llvm.org/pr26179. Patch by Vassil Vassilev! Reviewed by Richard Smith. llvm-svn: 258524
2016-01-23 03:03:27 +08:00
const ArrayType *VarXTy = C.getAsArrayType(VarX->getType());
const ArrayType *VarYTy = C.getAsArrayType(VarY->getType());
if (!VarXTy || !VarYTy)
return false;
if (VarXTy->isIncompleteArrayType() || VarYTy->isIncompleteArrayType())
return C.hasSameType(VarXTy->getElementType(), VarYTy->getElementType());
}
return false;
Implement declaration merging for variables in disjoint modules. llvm-svn: 147535
2012-01-05 01:21:36 +08:00
}
Slightly improve cross-module merging for function templates. llvm-svn: 184689
2013-06-24 12:45:28 +08:00
Implement redeclaration merging for namespaces defined in distinct modules. Teach name lookup into namespaces to search in each of the merged DeclContexts as well as the (now-primary) DeclContext. This supports the common case where two different modules put something into the same namespace. llvm-svn: 147778
2012-01-10 01:30:44 +08:00
// Namespaces with the same name and inlinedness match.
if (NamespaceDecl *NamespaceX = dyn_cast<NamespaceDecl>(X)) {
NamespaceDecl *NamespaceY = cast<NamespaceDecl>(Y);
return NamespaceX->isInline() == NamespaceY->isInline();
}
Also merge template redeclarations. Don't require specializations (of existing and read template) to be unique. llvm-svn: 164931
2012-10-01 17:18:00 +08:00
Slightly improve cross-module merging for function templates. llvm-svn: 184689
2013-06-24 12:45:28 +08:00
// Identical template names and kinds match if their template parameter lists
// and patterns match.
if (TemplateDecl *TemplateX = dyn_cast<TemplateDecl>(X)) {
Check for matching template-parameter-lists when merging template declarations. llvm-svn: 184791
2013-06-25 06:51:00 +08:00
TemplateDecl *TemplateY = cast<TemplateDecl>(Y);
Slightly improve cross-module merging for function templates. llvm-svn: 184689
2013-06-24 12:45:28 +08:00
return isSameEntity(TemplateX->getTemplatedDecl(),
Check for matching template-parameter-lists when merging template declarations. llvm-svn: 184791
2013-06-25 06:51:00 +08:00
TemplateY->getTemplatedDecl()) &&
isSameTemplateParameterList(TemplateX->getTemplateParameters(),
TemplateY->getTemplateParameters());
Slightly improve cross-module merging for function templates. llvm-svn: 184689
2013-06-24 12:45:28 +08:00
}
Also merge template redeclarations. Don't require specializations (of existing and read template) to be unique. llvm-svn: 164931
2012-10-01 17:18:00 +08:00
When merging class definitions across modules in C++, merge together fields. This change doesn't go all the way to making fields redeclarable; instead, it makes them 'mergeable', which means we can find the canonical declaration, but not much else (and for a declaration that's not from a module, the canonical declaration is always that declaration). llvm-svn: 192092
2013-10-07 16:02:11 +08:00
// Fields with the same name and the same type match.
if (FieldDecl *FDX = dyn_cast<FieldDecl>(X)) {
FieldDecl *FDY = cast<FieldDecl>(Y);
C++ modules: merging for enumerations and enumerators with multiple definitions (eg through template instantiations in multiple modules). llvm-svn: 192740
2013-10-16 06:02:41 +08:00
// FIXME: Also check the bitwidth is odr-equivalent, if any.
When merging class definitions across modules in C++, merge together fields. This change doesn't go all the way to making fields redeclarable; instead, it makes them 'mergeable', which means we can find the canonical declaration, but not much else (and for a declaration that's not from a module, the canonical declaration is always that declaration). llvm-svn: 192092
2013-10-07 16:02:11 +08:00
return X->getASTContext().hasSameType(FDX->getType(), FDY->getType());
}
[modules] Make IndirectFieldDecl mergeable to avoid lookup ambiguity when the same anonymous union is defined across multiple modules. llvm-svn: 243940
2015-08-04 10:05:09 +08:00
// Indirect fields with the same target field match.
if (auto *IFDX = dyn_cast<IndirectFieldDecl>(X)) {
auto *IFDY = cast<IndirectFieldDecl>(Y);
return IFDX->getAnonField()->getCanonicalDecl() ==
IFDY->getAnonField()->getCanonicalDecl();
}
C++ modules: merging for enumerations and enumerators with multiple definitions (eg through template instantiations in multiple modules). llvm-svn: 192740
2013-10-16 06:02:41 +08:00
// Enumerators with the same name match.
if (isa<EnumConstantDecl>(X))
// FIXME: Also check the value is odr-equivalent.
return true;
Make UsingShadowDecls redeclarable. This fixes some visibility problems with modules. With this fixed, I no longer see any test regressions in the libc++ test suite when enabling a single-module module.map for libc++ (other than issues with my system headers). llvm-svn: 193219
2013-10-23 10:17:46 +08:00
// Using shadow declarations with the same target match.
if (UsingShadowDecl *USX = dyn_cast<UsingShadowDecl>(X)) {
UsingShadowDecl *USY = cast<UsingShadowDecl>(Y);
return USX->getTargetDecl() == USY->getTargetDecl();
}
[modules] Merging for class-scope using-declarations. llvm-svn: 219657
2014-10-14 10:00:47 +08:00
// Using declarations with the same qualifier match. (We already know that
// the name matches.)
if (auto *UX = dyn_cast<UsingDecl>(X)) {
auto *UY = cast<UsingDecl>(Y);
return isSameQualifier(UX->getQualifier(), UY->getQualifier()) &&
UX->hasTypename() == UY->hasTypename() &&
UX->isAccessDeclaration() == UY->isAccessDeclaration();
}
if (auto *UX = dyn_cast<UnresolvedUsingValueDecl>(X)) {
auto *UY = cast<UnresolvedUsingValueDecl>(Y);
return isSameQualifier(UX->getQualifier(), UY->getQualifier()) &&
UX->isAccessDeclaration() == UY->isAccessDeclaration();
}
if (auto *UX = dyn_cast<UnresolvedUsingTypenameDecl>(X))
return isSameQualifier(
UX->getQualifier(),
cast<UnresolvedUsingTypenameDecl>(Y)->getQualifier());
[modules] Make NamespaceAliasDecl redeclarable, as it should be. This fixes merging of namespace aliases across modules and improves source fidelity. Incidentally also fixes PR20816. llvm-svn: 217103
2014-09-04 07:11:22 +08:00
// Namespace alias definitions with the same target match.
if (auto *NAX = dyn_cast<NamespaceAliasDecl>(X)) {
auto *NAY = cast<NamespaceAliasDecl>(Y);
return NAX->getNamespace()->Equals(NAY->getNamespace());
}
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 false;
}
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
/// Find the context in which we should search for previous declarations when
/// looking for declarations to merge.
[modules] Sometimes we can deserialize a class member but not have yet encountered any definition for the class; this happens when the definition is added by an update record that is not yet loaded. In such a case, eagerly pick the original parent of the member as the canonical definition of the class rather than muddling through with the canonical declaration (the latter can lead to us failing to merge properly later if the canonical definition turns out to be some other declaration). llvm-svn: 226977
2015-01-24 09:07:20 +08:00
DeclContext *ASTDeclReader::getPrimaryContextForMerging(ASTReader &Reader,
DeclContext *DC) {
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
if (NamespaceDecl *ND = dyn_cast<NamespaceDecl>(DC))
return ND->getOriginalNamespace();
[modules] Sometimes we can deserialize a class member but not have yet encountered any definition for the class; this happens when the definition is added by an update record that is not yet loaded. In such a case, eagerly pick the original parent of the member as the canonical definition of the class rather than muddling through with the canonical declaration (the latter can lead to us failing to merge properly later if the canonical definition turns out to be some other declaration). llvm-svn: 226977
2015-01-24 09:07:20 +08:00
if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(DC)) {
// Try to dig out the definition.
auto *DD = RD->DefinitionData.getNotUpdated();
if (!DD)
DD = RD->getCanonicalDecl()->DefinitionData.getNotUpdated();
// If there's no definition yet, then DC's definition is added by an update
// record, but we've not yet loaded that update record. In this case, we
// commit to DC being the canonical definition now, and will fix this when
// we load the update record.
if (!DD) {
DD = new (Reader.Context) struct CXXRecordDecl::DefinitionData(RD);
RD->IsCompleteDefinition = true;
RD->DefinitionData = DD;
RD->getCanonicalDecl()->DefinitionData = DD;
// Track that we did this horrible thing so that we can fix it later.
[modules] Be sure to load the lexical definition of a class template specialization from an update record exactly once, even if we needed to fake up the definition. llvm-svn: 227939
2015-02-03 11:32:14 +08:00
Reader.PendingFakeDefinitionData.insert(
std::make_pair(DD, ASTReader::PendingFakeDefinitionKind::Fake));
[modules] Sometimes we can deserialize a class member but not have yet encountered any definition for the class; this happens when the definition is added by an update record that is not yet loaded. In such a case, eagerly pick the original parent of the member as the canonical definition of the class rather than muddling through with the canonical declaration (the latter can lead to us failing to merge properly later if the canonical definition turns out to be some other declaration). llvm-svn: 226977
2015-01-24 09:07:20 +08:00
}
return DD->Definition;
}
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
C++ modules: merging for enumerations and enumerators with multiple definitions (eg through template instantiations in multiple modules). llvm-svn: 192740
2013-10-16 06:02:41 +08:00
if (EnumDecl *ED = dyn_cast<EnumDecl>(DC))
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
return ED->getASTContext().getLangOpts().CPlusPlus? ED->getDefinition()
: nullptr;
C++ modules: merging for enumerations and enumerators with multiple definitions (eg through template instantiations in multiple modules). llvm-svn: 192740
2013-10-16 06:02:41 +08:00
[modules] When using -E, we may try to merge decls despite having no Sema object. In such a case, use the TU's DC for merging global decls rather than giving up when we find there is no TU scope. Ultimately, we should probably avoid all loading of decls when preprocessing, but there are other reasonable use cases for loading an AST file with no Sema object for which this is the right thing. llvm-svn: 228234
2015-02-05 07:37:59 +08:00
// We can see the TU here only if we have no Sema object. In that case,
// there's no TU scope to look in, so using the DC alone is sufficient.
if (auto *TU = dyn_cast<TranslationUnitDecl>(DC))
return TU;
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
return nullptr;
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
}
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
ASTDeclReader::FindExistingResult::~FindExistingResult() {
[modules] If we load two declarations with typedef names for linkage purposes on top of a local declaration of the same entity, we still need to remember that we loaded the first one or we may fail to merge the second one properly. llvm-svn: 226765
2015-01-22 10:21:23 +08:00
// Record that we had a typedef name for linkage whether or not we merge
// with that declaration.
if (TypedefNameForLinkage) {
DeclContext *DC = New->getDeclContext()->getRedeclContext();
Reader.ImportedTypedefNamesForLinkage.insert(
std::make_pair(std::make_pair(DC, TypedefNameForLinkage), New));
return;
}
Implement merging of namespace-scope declarations across modules, so that we can merge, for example, two occurrences of namespace N { void f(); } in two disjoint modules. llvm-svn: 147780
2012-01-10 01:38:47 +08:00
if (!AddResult || Existing)
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
return;
C++ modules: Don't call DeclContext::lookup when half-way through deserializing decls. That can reenter deserialization and explode horribly by trying to merge a declaration that we've not got very far through deserializing yet. llvm-svn: 186236
2013-07-13 10:00:19 +08:00
[modules] Fix deserialization cycle when loading a tag declaration with a typedef name for linkage purposes. When loading the type, delay loading its typedef until we've finished loading and merging the type. In its place, save out the name of the typedef, which we need for merging purposes. llvm-svn: 216806
2014-08-30 08:04:23 +08:00
DeclarationName Name = New->getDeclName();
C++ modules: Don't call DeclContext::lookup when half-way through deserializing decls. That can reenter deserialization and explode horribly by trying to merge a declaration that we've not got very far through deserializing yet. llvm-svn: 186236
2013-07-13 10:00:19 +08:00
DeclContext *DC = New->getDeclContext()->getRedeclContext();
[modules] Treat friend declarations that are lexically within a dependent context as anonymous for merging purposes. They can't be found by their names, so we merge them based on their position within the surrounding context. llvm-svn: 228485
2015-02-07 11:11:11 +08:00
if (needsAnonymousDeclarationNumber(New)) {
[modules] Number anonymous declarations that are lexically within mergeable contexts, so that we can merge them when we merge the surrounding context. llvm-svn: 216639
2014-08-28 09:33:39 +08:00
setAnonymousDeclForMerging(Reader, New->getLexicalDeclContext(),
AnonymousDeclNumber, New);
[modules] Remove redundant import of lexical decls when building a lookup table for a DeclContext, and fix propagation of exception specifications along redeclaration chains. This reverts r232905, r232907, and r232907, which reverted r232793, r232853, and r232853. One additional change is present here to resolve issues with LLDB: distinguish between whether lexical decls missing from the lookup table are local or are provided by the external AST source, and still look in the external source if that's where they came from. llvm-svn: 232928
2015-03-23 11:25:59 +08:00
} else if (DC->isTranslationUnit() && Reader.SemaObj &&
!Reader.getContext().getLangOpts().CPlusPlus) {
if (Reader.SemaObj->IdResolver.tryAddTopLevelDecl(New, Name))
Reader.PendingFakeLookupResults[Name.getAsIdentifierInfo()]
.push_back(New);
[modules] Sometimes we can deserialize a class member but not have yet encountered any definition for the class; this happens when the definition is added by an update record that is not yet loaded. In such a case, eagerly pick the original parent of the member as the canonical definition of the class rather than muddling through with the canonical declaration (the latter can lead to us failing to merge properly later if the canonical definition turns out to be some other declaration). llvm-svn: 226977
2015-01-24 09:07:20 +08:00
} else if (DeclContext *MergeDC = getPrimaryContextForMerging(Reader, DC)) {
C++ modules: Don't call DeclContext::lookup when half-way through deserializing decls. That can reenter deserialization and explode horribly by trying to merge a declaration that we've not got very far through deserializing yet. llvm-svn: 186236
2013-07-13 10:00:19 +08:00
// Add the declaration to its redeclaration context so later merging
// lookups will find it.
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
MergeDC->makeDeclVisibleInContextImpl(New, /*Internal*/true);
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
}
}
[modules] When merging a tag declaration that has a typedef name for linkage purposes, look for other typedefs with that same name and merge into their named tag declaration if there is one. llvm-svn: 216312
2014-08-23 09:45:27 +08:00
/// Find the declaration that should be merged into, given the declaration found
/// by name lookup. If we're merging an anonymous declaration within a typedef,
/// we need a matching typedef, and we merge with the type inside it.
static NamedDecl *getDeclForMerging(NamedDecl *Found,
bool IsTypedefNameForLinkage) {
if (!IsTypedefNameForLinkage)
return Found;
// If we found a typedef declaration that gives a name to some other
// declaration, then we want that inner declaration. Declarations from
// AST files are handled via ImportedTypedefNamesForLinkage.
[modules] Handle defining a tag with a typedef name for linkage purposes on top of an existing imported-but-not-visible definition. llvm-svn: 233345
2015-03-27 09:37:43 +08:00
if (Found->isFromASTFile())
Fix Clang-tidy modernize-use-nullptr warnings in source directories; other minor cleanups Patch by Eugene Zelenko! Differential Revision: http://reviews.llvm.org/D13406 llvm-svn: 249484
2015-10-07 07:40:43 +08:00
return nullptr;
[modules] Handle defining a tag with a typedef name for linkage purposes on top of an existing imported-but-not-visible definition. llvm-svn: 233345
2015-03-27 09:37:43 +08:00
if (auto *TND = dyn_cast<TypedefNameDecl>(Found))
return TND->getAnonDeclWithTypedefName();
[modules] When merging a tag declaration that has a typedef name for linkage purposes, look for other typedefs with that same name and merge into their named tag declaration if there is one. llvm-svn: 216312
2014-08-23 09:45:27 +08:00
Fix Clang-tidy modernize-use-nullptr warnings in source directories; other minor cleanups Patch by Eugene Zelenko! Differential Revision: http://reviews.llvm.org/D13406 llvm-svn: 249484
2015-10-07 07:40:43 +08:00
return nullptr;
[modules] When merging a tag declaration that has a typedef name for linkage purposes, look for other typedefs with that same name and merge into their named tag declaration if there is one. llvm-svn: 216312
2014-08-23 09:45:27 +08:00
}
[modules] Number anonymous declarations that are lexically within mergeable contexts, so that we can merge them when we merge the surrounding context. llvm-svn: 216639
2014-08-28 09:33:39 +08:00
NamedDecl *ASTDeclReader::getAnonymousDeclForMerging(ASTReader &Reader,
DeclContext *DC,
unsigned Index) {
// If the lexical context has been merged, look into the now-canonical
// definition.
if (auto *Merged = Reader.MergedDeclContexts.lookup(DC))
DC = Merged;
// If we've seen this before, return the canonical declaration.
auto &Previous = Reader.AnonymousDeclarationsForMerging[DC];
if (Index < Previous.size() && Previous[Index])
return Previous[Index];
// If this is the first time, but we have parsed a declaration of the context,
// build the anonymous declaration list from the parsed declaration.
if (!cast<Decl>(DC)->isFromASTFile()) {
[modules] Treat friend declarations that are lexically within a dependent context as anonymous for merging purposes. They can't be found by their names, so we merge them based on their position within the surrounding context. llvm-svn: 228485
2015-02-07 11:11:11 +08:00
numberAnonymousDeclsWithin(DC, [&](NamedDecl *ND, unsigned Number) {
if (Previous.size() == Number)
[modules] Number anonymous declarations that are lexically within mergeable contexts, so that we can merge them when we merge the surrounding context. llvm-svn: 216639
2014-08-28 09:33:39 +08:00
Previous.push_back(cast<NamedDecl>(ND->getCanonicalDecl()));
else
[modules] Treat friend declarations that are lexically within a dependent context as anonymous for merging purposes. They can't be found by their names, so we merge them based on their position within the surrounding context. llvm-svn: 228485
2015-02-07 11:11:11 +08:00
Previous[Number] = cast<NamedDecl>(ND->getCanonicalDecl());
});
[modules] Number anonymous declarations that are lexically within mergeable contexts, so that we can merge them when we merge the surrounding context. llvm-svn: 216639
2014-08-28 09:33:39 +08:00
}
return Index < Previous.size() ? Previous[Index] : nullptr;
}
void ASTDeclReader::setAnonymousDeclForMerging(ASTReader &Reader,
DeclContext *DC, unsigned Index,
NamedDecl *D) {
if (auto *Merged = Reader.MergedDeclContexts.lookup(DC))
DC = Merged;
auto &Previous = Reader.AnonymousDeclarationsForMerging[DC];
if (Index >= Previous.size())
Previous.resize(Index + 1);
if (!Previous[Index])
Previous[Index] = 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
ASTDeclReader::FindExistingResult ASTDeclReader::findExisting(NamedDecl *D) {
[modules] Fix deserialization cycle when loading a tag declaration with a typedef name for linkage purposes. When loading the type, delay loading its typedef until we've finished loading and merging the type. In its place, save out the name of the typedef, which we need for merging purposes. llvm-svn: 216806
2014-08-30 08:04:23 +08:00
DeclarationName Name = TypedefNameForLinkage ? TypedefNameForLinkage
: D->getDeclName();
[modules] When merging a tag declaration that has a typedef name for linkage purposes, look for other typedefs with that same name and merge into their named tag declaration if there is one. llvm-svn: 216312
2014-08-23 09:45:27 +08:00
[modules] Number anonymous declarations that are lexically within mergeable contexts, so that we can merge them when we merge the surrounding context. llvm-svn: 216639
2014-08-28 09:33:39 +08:00
if (!Name && !needsAnonymousDeclarationNumber(D)) {
// Don't bother trying to find unnamed declarations that are in
// unmergeable contexts.
[modules] Fix deserialization cycle when loading a tag declaration with a typedef name for linkage purposes. When loading the type, delay loading its typedef until we've finished loading and merging the type. In its place, save out the name of the typedef, which we need for merging purposes. llvm-svn: 216806
2014-08-30 08:04:23 +08:00
FindExistingResult Result(Reader, D, /*Existing=*/nullptr,
AnonymousDeclNumber, TypedefNameForLinkage);
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
Result.suppress();
return Result;
}
C++ modules: Don't call DeclContext::lookup when half-way through deserializing decls. That can reenter deserialization and explode horribly by trying to merge a declaration that we've not got very far through deserializing yet. llvm-svn: 186236
2013-07-13 10:00:19 +08:00
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();
[modules] Fix deserialization cycle when loading a tag declaration with a typedef name for linkage purposes. When loading the type, delay loading its typedef until we've finished loading and merging the type. In its place, save out the name of the typedef, which we need for merging purposes. llvm-svn: 216806
2014-08-30 08:04:23 +08:00
if (TypedefNameForLinkage) {
[modules] When merging a tag declaration that has a typedef name for linkage purposes, look for other typedefs with that same name and merge into their named tag declaration if there is one. llvm-svn: 216312
2014-08-23 09:45:27 +08:00
auto It = Reader.ImportedTypedefNamesForLinkage.find(
[modules] Fix deserialization cycle when loading a tag declaration with a typedef name for linkage purposes. When loading the type, delay loading its typedef until we've finished loading and merging the type. In its place, save out the name of the typedef, which we need for merging purposes. llvm-svn: 216806
2014-08-30 08:04:23 +08:00
std::make_pair(DC, TypedefNameForLinkage));
[modules] When merging a tag declaration that has a typedef name for linkage purposes, look for other typedefs with that same name and merge into their named tag declaration if there is one. llvm-svn: 216312
2014-08-23 09:45:27 +08:00
if (It != Reader.ImportedTypedefNamesForLinkage.end())
if (isSameEntity(It->second, D))
[modules] Fix deserialization cycle when loading a tag declaration with a typedef name for linkage purposes. When loading the type, delay loading its typedef until we've finished loading and merging the type. In its place, save out the name of the typedef, which we need for merging purposes. llvm-svn: 216806
2014-08-30 08:04:23 +08:00
return FindExistingResult(Reader, D, It->second, AnonymousDeclNumber,
TypedefNameForLinkage);
[modules] When merging a tag declaration that has a typedef name for linkage purposes, look for other typedefs with that same name and merge into their named tag declaration if there is one. llvm-svn: 216312
2014-08-23 09:45:27 +08:00
// Go on to check in other places in case an existing typedef name
// was not imported.
}
[modules] Number anonymous declarations that are lexically within mergeable contexts, so that we can merge them when we merge the surrounding context. llvm-svn: 216639
2014-08-28 09:33:39 +08:00
[modules] Treat friend declarations that are lexically within a dependent context as anonymous for merging purposes. They can't be found by their names, so we merge them based on their position within the surrounding context. llvm-svn: 228485
2015-02-07 11:11:11 +08:00
if (needsAnonymousDeclarationNumber(D)) {
[modules] Number anonymous declarations that are lexically within mergeable contexts, so that we can merge them when we merge the surrounding context. llvm-svn: 216639
2014-08-28 09:33:39 +08:00
// This is an anonymous declaration that we may need to merge. Look it up
// in its context by number.
if (auto *Existing = getAnonymousDeclForMerging(
Reader, D->getLexicalDeclContext(), AnonymousDeclNumber))
if (isSameEntity(Existing, D))
[modules] Fix deserialization cycle when loading a tag declaration with a typedef name for linkage purposes. When loading the type, delay loading its typedef until we've finished loading and merging the type. In its place, save out the name of the typedef, which we need for merging purposes. llvm-svn: 216806
2014-08-30 08:04:23 +08:00
return FindExistingResult(Reader, D, Existing, AnonymousDeclNumber,
TypedefNameForLinkage);
[modules] Remove redundant import of lexical decls when building a lookup table for a DeclContext, and fix propagation of exception specifications along redeclaration chains. This reverts r232905, r232907, and r232907, which reverted r232793, r232853, and r232853. One additional change is present here to resolve issues with LLDB: distinguish between whether lexical decls missing from the lookup table are local or are provided by the external AST source, and still look in the external source if that's where they came from. llvm-svn: 232928
2015-03-23 11:25:59 +08:00
} else if (DC->isTranslationUnit() && Reader.SemaObj &&
!Reader.getContext().getLangOpts().CPlusPlus) {
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
IdentifierResolver &IdResolver = Reader.SemaObj->IdResolver;
Ensure that the identifier chains have the most recent declaration after module deserialization. This commit introduces a set of related changes to ensure that the declaration that shows up in the identifier chain after deserializing declarations with a given identifier is, in fact, the most recent declaration. The primary change involves waiting until after we deserialize and wire up redeclaration chains before updating the identifier chains. There is a minor optimization in here to avoid recursively deserializing names as part of looking to see whether top-level declarations for a given name exist. A related change that became suddenly more urgent is to property record a merged declaration when an entity first declared in the current translation unit is later deserialized from a module (that had not been loaded at the time of the original declaration). Since we key off the canonical declaration (which is parsed, not from an AST file) for emitted redeclarations, we simply record this as a merged declaration during AST writing and let the readers merge them. Re-fixes <rdar://problem/13189985>, presumably for good this time. llvm-svn: 175447
2013-02-18 23:53:43 +08:00
// Temporarily consider the identifier to be up-to-date. We don't want to
// cause additional lookups here.
class UpToDateIdentifierRAII {
IdentifierInfo *II;
bool WasOutToDate;
public:
explicit UpToDateIdentifierRAII(IdentifierInfo *II)
: II(II), WasOutToDate(false)
{
if (II) {
WasOutToDate = II->isOutOfDate();
if (WasOutToDate)
II->setOutOfDate(false);
}
}
~UpToDateIdentifierRAII() {
if (WasOutToDate)
II->setOutOfDate(true);
}
} UpToDate(Name.getAsIdentifierInfo());
Implement cross-module declaration merging for tag declarations, so that if two modules A and B both contain a declaration of a tag such as struct X; and those two modules are unrelated, the two declarations of X will be merged into a single redeclaration chain. llvm-svn: 147488
2012-01-04 06:46:00 +08:00
for (IdentifierResolver::iterator I = IdResolver.begin(Name),
When deserializing an Objective-C class, check whether we have another declaration of that same class that either came from some other module or occurred in the translation unit loading the module. In this case, we need to merge the two redeclaration chains immediately so that all such declarations have the same canonical declaration in the resulting AST (even though they don't in the module files we've imported). Focusing on Objective-C classes until I'm happy with the design, then I'll both (1) extend this notion to other kinds of declarations, and (2) optimize away this extra checking when we're not dealing with modules. For now, doing this checking for PCH files/preambles gives us better testing coverage. llvm-svn: 147123
2011-12-22 09:48:48 +08:00
IEnd = IdResolver.end();
I != IEnd; ++I) {
[modules] Fix deserialization cycle when loading a tag declaration with a typedef name for linkage purposes. When loading the type, delay loading its typedef until we've finished loading and merging the type. In its place, save out the name of the typedef, which we need for merging purposes. llvm-svn: 216806
2014-08-30 08:04:23 +08:00
if (NamedDecl *Existing = getDeclForMerging(*I, TypedefNameForLinkage))
Fix typo. llvm-svn: 216417
2014-08-26 07:33:46 +08:00
if (isSameEntity(Existing, D))
[modules] Fix deserialization cycle when loading a tag declaration with a typedef name for linkage purposes. When loading the type, delay loading its typedef until we've finished loading and merging the type. In its place, save out the name of the typedef, which we need for merging purposes. llvm-svn: 216806
2014-08-30 08:04:23 +08:00
return FindExistingResult(Reader, D, Existing, AnonymousDeclNumber,
TypedefNameForLinkage);
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
}
[modules] Sometimes we can deserialize a class member but not have yet encountered any definition for the class; this happens when the definition is added by an update record that is not yet loaded. In such a case, eagerly pick the original parent of the member as the canonical definition of the class rather than muddling through with the canonical declaration (the latter can lead to us failing to merge properly later if the canonical definition turns out to be some other declaration). llvm-svn: 226977
2015-01-24 09:07:20 +08:00
} else if (DeclContext *MergeDC = getPrimaryContextForMerging(Reader, DC)) {
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
DeclContext::lookup_result R = MergeDC->noload_lookup(Name);
C++ modules: Don't call DeclContext::lookup when half-way through deserializing decls. That can reenter deserialization and explode horribly by trying to merge a declaration that we've not got very far through deserializing yet. llvm-svn: 186236
2013-07-13 10:00:19 +08:00
for (DeclContext::lookup_iterator I = R.begin(), E = R.end(); I != E; ++I) {
[modules] Fix deserialization cycle when loading a tag declaration with a typedef name for linkage purposes. When loading the type, delay loading its typedef until we've finished loading and merging the type. In its place, save out the name of the typedef, which we need for merging purposes. llvm-svn: 216806
2014-08-30 08:04:23 +08:00
if (NamedDecl *Existing = getDeclForMerging(*I, TypedefNameForLinkage))
[modules] When merging a tag declaration that has a typedef name for linkage purposes, look for other typedefs with that same name and merge into their named tag declaration if there is one. llvm-svn: 216312
2014-08-23 09:45:27 +08:00
if (isSameEntity(Existing, D))
[modules] Fix deserialization cycle when loading a tag declaration with a typedef name for linkage purposes. When loading the type, delay loading its typedef until we've finished loading and merging the type. In its place, save out the name of the typedef, which we need for merging purposes. llvm-svn: 216806
2014-08-30 08:04:23 +08:00
return FindExistingResult(Reader, D, Existing, AnonymousDeclNumber,
TypedefNameForLinkage);
Implement merging of namespace-scope declarations across modules, so that we can merge, for example, two occurrences of namespace N { void f(); } in two disjoint modules. llvm-svn: 147780
2012-01-10 01:38:47 +08:00
}
Basic ODR checking for C++ modules: If we have multiple definitions of the same entity from different modules, we nominate the first definition which we see as being the canonical definition. If we load a declaration from a different definition and we can't find a corresponding declaration in the canonical definition, issue a diagnostic. This is insufficient to prevent things from going horribly wrong in all cases -- we might be in the middle of emitting IR for a function when we trigger some deserialization and discover that it refers to an incoherent piece of the AST, by which point it's probably too late to bail out -- but we'll at least produce a diagnostic. llvm-svn: 192950
2013-10-18 14:05:18 +08:00
} else {
// Not in a mergeable context.
return FindExistingResult(Reader);
Implement merging of namespace-scope declarations across modules, so that we can merge, for example, two occurrences of namespace N { void f(); } in two disjoint modules. llvm-svn: 147780
2012-01-10 01:38:47 +08:00
}
C++ modules: if a class is defined in multiple modules (for instance, because it is an implicit instantiation of a class template specialization), pick the first-loaded definition to be the canonical definition, and merge all other definitions into it. This is still rather incomplete -- we need to extend every form of declaration that can appear within a CXXRecordDecl to be redeclarable if it came from an AST file (this includes fields, enumerators, ...). llvm-svn: 190315
2013-09-10 00:55:27 +08:00
Basic ODR checking for C++ modules: If we have multiple definitions of the same entity from different modules, we nominate the first definition which we see as being the canonical definition. If we load a declaration from a different definition and we can't find a corresponding declaration in the canonical definition, issue a diagnostic. This is insufficient to prevent things from going horribly wrong in all cases -- we might be in the middle of emitting IR for a function when we trigger some deserialization and discover that it refers to an incoherent piece of the AST, by which point it's probably too late to bail out -- but we'll at least produce a diagnostic. llvm-svn: 192950
2013-10-18 14:05:18 +08:00
// If this declaration is from a merged context, make a note that we need to
// check that the canonical definition of that context contains the decl.
When a module completes the definition of a class template specialization imported from another module, emit an update record, rather than using the broken decl rewriting mechanism. If multiple modules do this, merge the definitions together, much as we would if they were separate declarations. llvm-svn: 206680
2014-04-19 11:48:30 +08:00
//
// FIXME: We should do something similar if we merge two definitions of the
// same template specialization into the same CXXRecordDecl.
[modules] Fix false report of an ODR violation when merging friend declarations. We can't expect to find them in the canonical definition of the class, because that's not where they live. This means we no longer reject real ODR violations with friend declarations, but we weren't consistently doing so anyway. llvm-svn: 216369
2014-08-25 10:10:01 +08:00
auto MergedDCIt = Reader.MergedDeclContexts.find(D->getLexicalDeclContext());
if (MergedDCIt != Reader.MergedDeclContexts.end() &&
MergedDCIt->second == D->getDeclContext())
Basic ODR checking for C++ modules: If we have multiple definitions of the same entity from different modules, we nominate the first definition which we see as being the canonical definition. If we load a declaration from a different definition and we can't find a corresponding declaration in the canonical definition, issue a diagnostic. This is insufficient to prevent things from going horribly wrong in all cases -- we might be in the middle of emitting IR for a function when we trigger some deserialization and discover that it refers to an incoherent piece of the AST, by which point it's probably too late to bail out -- but we'll at least produce a diagnostic. llvm-svn: 192950
2013-10-18 14:05:18 +08:00
Reader.PendingOdrMergeChecks.push_back(D);
[modules] Number anonymous declarations that are lexically within mergeable contexts, so that we can merge them when we merge the surrounding context. llvm-svn: 216639
2014-08-28 09:33:39 +08:00
return FindExistingResult(Reader, D, /*Existing=*/nullptr,
[modules] Fix deserialization cycle when loading a tag declaration with a typedef name for linkage purposes. When loading the type, delay loading its typedef until we've finished loading and merging the type. In its place, save out the name of the typedef, which we need for merging purposes. llvm-svn: 216806
2014-08-30 08:04:23 +08:00
AnonymousDeclNumber, TypedefNameForLinkage);
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
}
[modules] Avoid adding a redecl chain to the 'pending out of date' list as the very first step in updating it. llvm-svn: 230840
2015-02-28 13:57:02 +08:00
template<typename DeclT>
Decl *ASTDeclReader::getMostRecentDeclImpl(Redeclarable<DeclT> *D) {
return D->RedeclLink.getLatestNotUpdated();
}
Decl *ASTDeclReader::getMostRecentDeclImpl(...) {
llvm_unreachable("getMostRecentDecl on non-redeclarable declaration");
}
Decl *ASTDeclReader::getMostRecentDecl(Decl *D) {
assert(D);
switch (D->getKind()) {
#define ABSTRACT_DECL(TYPE)
#define DECL(TYPE, BASE) \
case Decl::TYPE: \
return getMostRecentDeclImpl(cast<TYPE##Decl>(D));
#include "clang/AST/DeclNodes.inc"
}
llvm_unreachable("unknown decl kind");
}
[modules] Avoid accidentally completing the redeclaration chain when updating all the existing declarations of a record-like entity with a pointer to its definition. llvm-svn: 231901
2015-03-11 09:44:51 +08:00
Decl *ASTReader::getMostRecentExistingDecl(Decl *D) {
return ASTDeclReader::getMostRecentDecl(D->getCanonicalDecl());
}
Refactor to avoid explicitly listing all the different flavours of redeclarable declarations, and duplicating code between them. llvm-svn: 208662
2014-05-13 09:15:00 +08:00
template<typename DeclT>
[modules] Maintain an AST invariant across module load/save: if any declaration of a function has a resolved exception specification, then all declarations of the function do. We should probably improve the AST representation to make this implicit (perhaps only store the exception specification on the canonical declaration), but this fixes things for now. The testcase for this (which used to assert) also exposes the actual bug I was trying to reduce here: we sometimes fail to emit the body of an imported special member function definition. Fix for that to follow. llvm-svn: 214458
2014-08-01 07:46:44 +08:00
void ASTDeclReader::attachPreviousDeclImpl(ASTReader &Reader,
Redeclarable<DeclT> *D,
[modules] Remove redundant import of lexical decls when building a lookup table for a DeclContext, and fix propagation of exception specifications along redeclaration chains. This reverts r232905, r232907, and r232907, which reverted r232793, r232853, and r232853. One additional change is present here to resolve issues with LLDB: distinguish between whether lexical decls missing from the lookup table are local or are provided by the external AST source, and still look in the external source if that's where they came from. llvm-svn: 232928
2015-03-23 11:25:59 +08:00
Decl *Previous, Decl *Canon) {
If a declaration is loaded, and then a module import adds a redeclaration, then ensure that querying the first declaration for its most recent declaration checks for redeclarations from the imported module. This works as follows: * The 'most recent' pointer on a canonical declaration grows a pointer to the external AST source and a generation number (space- and time-optimized for the case where there is no external source). * Each time the 'most recent' pointer is queried, if it has an external source, we check whether it's up to date, and update it if not. * The ancillary data stored on the canonical declaration is allocated lazily to avoid filling it in for declarations that end up being non-canonical. We'll still perform a redundant (ASTContext) allocation if someone asks for the most recent declaration from a decl before setPreviousDecl is called, but such cases are probably all bugs, and are now easy to find. Some finessing is still in order here -- in particular, we use a very general mechanism for handling the DefinitionData pointer on CXXRecordData, and a more targeted approach would be more compact. Also, the MayHaveOutOfDateDef mechanism should now be expunged, since it was addressing only a corner of the full problem space here. That's not covered by this patch. Early performance benchmarks show that this makes no measurable difference to Clang performance without modules enabled (and fixes a major correctness issue with modules enabled). I'll revert if a full performance comparison shows any problems. llvm-svn: 209046
2014-05-17 07:01:30 +08:00
D->RedeclLink.setPrevious(cast<DeclT>(Previous));
Keep track of canonical decls in Redeclarable. More than 2x speedup on modules builds with large redecl chains. Roughly 15-20% speedup on non-modules builds for very large TUs. Between 2-3% cost in memory on large TUs. llvm-svn: 233228
2015-03-26 07:18:30 +08:00
D->First = cast<DeclT>(Previous)->First;
Refactor to avoid explicitly listing all the different flavours of redeclarable declarations, and duplicating code between them. llvm-svn: 208662
2014-05-13 09:15:00 +08:00
}
Fix Clang-tidy modernize-use-nullptr warnings in source directories; other minor cleanups Patch by Eugene Zelenko! Differential Revision: http://reviews.llvm.org/D13406 llvm-svn: 249484
2015-10-07 07:40:43 +08:00
Fix buildbot: work around missing GCC C++11 feature. llvm-svn: 214459
2014-08-01 07:52:38 +08:00
namespace clang {
[modules] Maintain an AST invariant across module load/save: if any declaration of a function has a resolved exception specification, then all declarations of the function do. We should probably improve the AST representation to make this implicit (perhaps only store the exception specification on the canonical declaration), but this fixes things for now. The testcase for this (which used to assert) also exposes the actual bug I was trying to reduce here: we sometimes fail to emit the body of an imported special member function definition. Fix for that to follow. llvm-svn: 214458
2014-08-01 07:46:44 +08:00
template<>
void ASTDeclReader::attachPreviousDeclImpl(ASTReader &Reader,
Redeclarable<FunctionDecl> *D,
[modules] Remove redundant import of lexical decls when building a lookup table for a DeclContext, and fix propagation of exception specifications along redeclaration chains. This reverts r232905, r232907, and r232907, which reverted r232793, r232853, and r232853. One additional change is present here to resolve issues with LLDB: distinguish between whether lexical decls missing from the lookup table are local or are provided by the external AST source, and still look in the external source if that's where they came from. llvm-svn: 232928
2015-03-23 11:25:59 +08:00
Decl *Previous, Decl *Canon) {
[modules] Maintain an AST invariant across module load/save: if any declaration of a function has a resolved exception specification, then all declarations of the function do. We should probably improve the AST representation to make this implicit (perhaps only store the exception specification on the canonical declaration), but this fixes things for now. The testcase for this (which used to assert) also exposes the actual bug I was trying to reduce here: we sometimes fail to emit the body of an imported special member function definition. Fix for that to follow. llvm-svn: 214458
2014-08-01 07:46:44 +08:00
FunctionDecl *FD = static_cast<FunctionDecl*>(D);
FunctionDecl *PrevFD = cast<FunctionDecl>(Previous);
FD->RedeclLink.setPrevious(PrevFD);
Keep track of canonical decls in Redeclarable. More than 2x speedup on modules builds with large redecl chains. Roughly 15-20% speedup on non-modules builds for very large TUs. Between 2-3% cost in memory on large TUs. llvm-svn: 233228
2015-03-26 07:18:30 +08:00
FD->First = PrevFD->First;
[modules] Maintain an AST invariant across module load/save: if any declaration of a function has a resolved exception specification, then all declarations of the function do. We should probably improve the AST representation to make this implicit (perhaps only store the exception specification on the canonical declaration), but this fixes things for now. The testcase for this (which used to assert) also exposes the actual bug I was trying to reduce here: we sometimes fail to emit the body of an imported special member function definition. Fix for that to follow. llvm-svn: 214458
2014-08-01 07:46:44 +08:00
// If the previous declaration is an inline function declaration, then this
// declaration is too.
if (PrevFD->IsInline != FD->IsInline) {
// FIXME: [dcl.fct.spec]p4:
// If a function with external linkage is declared inline in one
// translation unit, it shall be declared inline in all translation
// units in which it appears.
//
// Be careful of this case:
//
// module A:
// template<typename T> struct X { void f(); };
// template<typename T> inline void X<T>::f() {}
//
// module B instantiates the declaration of X<int>::f
// module C instantiates the definition of X<int>::f
//
// If module B and C are merged, we do not have a violation of this rule.
FD->IsInline = true;
}
[modules] Remove redundant import of lexical decls when building a lookup table for a DeclContext, and fix propagation of exception specifications along redeclaration chains. This reverts r232905, r232907, and r232907, which reverted r232793, r232853, and r232853. One additional change is present here to resolve issues with LLDB: distinguish between whether lexical decls missing from the lookup table are local or are provided by the external AST source, and still look in the external source if that's where they came from. llvm-svn: 232928
2015-03-23 11:25:59 +08:00
// If we need to propagate an exception specification along the redecl
// chain, make a note of that so that we can do so later.
[modules] Maintain an AST invariant across module load/save: if any declaration of a function has a resolved exception specification, then all declarations of the function do. We should probably improve the AST representation to make this implicit (perhaps only store the exception specification on the canonical declaration), but this fixes things for now. The testcase for this (which used to assert) also exposes the actual bug I was trying to reduce here: we sometimes fail to emit the body of an imported special member function definition. Fix for that to follow. llvm-svn: 214458
2014-08-01 07:46:44 +08:00
auto *FPT = FD->getType()->getAs<FunctionProtoType>();
auto *PrevFPT = PrevFD->getType()->getAs<FunctionProtoType>();
PR21687: when adding a redeclaration of a function with an implicit exception specification, update all prior declarations if the new one has an explicit exception specification and the prior ones don't. Patch by Vassil Vassilev! Some minor tweaking and test case by me. llvm-svn: 231738
2015-03-10 10:00:53 +08:00
if (FPT && PrevFPT) {
[modules] Remove redundant import of lexical decls when building a lookup table for a DeclContext, and fix propagation of exception specifications along redeclaration chains. This reverts r232905, r232907, and r232907, which reverted r232793, r232853, and r232853. One additional change is present here to resolve issues with LLDB: distinguish between whether lexical decls missing from the lookup table are local or are provided by the external AST source, and still look in the external source if that's where they came from. llvm-svn: 232928
2015-03-23 11:25:59 +08:00
bool IsUnresolved = isUnresolvedExceptionSpec(FPT->getExceptionSpecType());
bool WasUnresolved =
isUnresolvedExceptionSpec(PrevFPT->getExceptionSpecType());
if (IsUnresolved != WasUnresolved)
Reader.PendingExceptionSpecUpdates.insert(
std::make_pair(Canon, IsUnresolved ? PrevFD : FD));
[modules] Maintain an AST invariant across module load/save: if any declaration of a function has a resolved exception specification, then all declarations of the function do. We should probably improve the AST representation to make this implicit (perhaps only store the exception specification on the canonical declaration), but this fixes things for now. The testcase for this (which used to assert) also exposes the actual bug I was trying to reduce here: we sometimes fail to emit the body of an imported special member function definition. Fix for that to follow. llvm-svn: 214458
2014-08-01 07:46:44 +08:00
}
}
Fix Clang-tidy modernize-use-nullptr warnings in source directories; other minor cleanups Patch by Eugene Zelenko! Differential Revision: http://reviews.llvm.org/D13406 llvm-svn: 249484
2015-10-07 07:40:43 +08:00
} // end namespace clang
[modules] Maintain an AST invariant across module load/save: if any declaration of a function has a resolved exception specification, then all declarations of the function do. We should probably improve the AST representation to make this implicit (perhaps only store the exception specification on the canonical declaration), but this fixes things for now. The testcase for this (which used to assert) also exposes the actual bug I was trying to reduce here: we sometimes fail to emit the body of an imported special member function definition. Fix for that to follow. llvm-svn: 214458
2014-08-01 07:46:44 +08:00
void ASTDeclReader::attachPreviousDeclImpl(ASTReader &Reader, ...) {
Refactor to avoid explicitly listing all the different flavours of redeclarable declarations, and duplicating code between them. llvm-svn: 208662
2014-05-13 09:15:00 +08:00
llvm_unreachable("attachPreviousDecl on non-redeclarable declaration");
}
[modules] Reconstruct template default argument inheritance on reload rather than wasting storage and triggering eager deserializations by serializing it. llvm-svn: 239454
2015-06-10 09:47:58 +08:00
/// Inherit the default template argument from \p From to \p To. Returns
/// \c false if there is no default template for \p From.
template <typename ParmDecl>
static bool inheritDefaultTemplateArgument(ASTContext &Context, ParmDecl *From,
Decl *ToD) {
auto *To = cast<ParmDecl>(ToD);
if (!From->hasDefaultArgument())
return false;
[modules] Track all default template arguments for a given parameter across modules, and allow use of a default template argument if any of the parameters providing it is visible. llvm-svn: 239485
2015-06-11 04:30:23 +08:00
To->setInheritedDefaultArgument(Context, From);
[modules] Reconstruct template default argument inheritance on reload rather than wasting storage and triggering eager deserializations by serializing it. llvm-svn: 239454
2015-06-10 09:47:58 +08:00
return true;
}
static void inheritDefaultTemplateArguments(ASTContext &Context,
TemplateDecl *From,
TemplateDecl *To) {
auto *FromTP = From->getTemplateParameters();
auto *ToTP = To->getTemplateParameters();
assert(FromTP->size() == ToTP->size() && "merged mismatched templates?");
for (unsigned I = 0, N = FromTP->size(); I != N; ++I) {
NamedDecl *FromParam = FromTP->getParam(N - I - 1);
PR25271: When attaching default template arguments to redeclarations of a template, keep looking for default arguments if we see a template parameter pack. There may be default arguments preceding a pack with no default argument. Patch by Jannis Harder! llvm-svn: 259836
2016-02-05 06:54:41 +08:00
if (FromParam->isParameterPack())
continue;
[modules] Reconstruct template default argument inheritance on reload rather than wasting storage and triggering eager deserializations by serializing it. llvm-svn: 239454
2015-06-10 09:47:58 +08:00
NamedDecl *ToParam = ToTP->getParam(N - I - 1);
if (auto *FTTP = dyn_cast<TemplateTypeParmDecl>(FromParam)) {
[modules] Fix typo in default argument merging. llvm-svn: 239954
2015-06-18 06:13:23 +08:00
if (!inheritDefaultTemplateArgument(Context, FTTP, ToParam))
[modules] Reconstruct template default argument inheritance on reload rather than wasting storage and triggering eager deserializations by serializing it. llvm-svn: 239454
2015-06-10 09:47:58 +08:00
break;
} else if (auto *FNTTP = dyn_cast<NonTypeTemplateParmDecl>(FromParam)) {
[modules] Fix typo in default argument merging. llvm-svn: 239954
2015-06-18 06:13:23 +08:00
if (!inheritDefaultTemplateArgument(Context, FNTTP, ToParam))
[modules] Reconstruct template default argument inheritance on reload rather than wasting storage and triggering eager deserializations by serializing it. llvm-svn: 239454
2015-06-10 09:47:58 +08:00
break;
} else {
[modules] Fix typo in default argument merging. llvm-svn: 239954
2015-06-18 06:13:23 +08:00
if (!inheritDefaultTemplateArgument(
[modules] Reconstruct template default argument inheritance on reload rather than wasting storage and triggering eager deserializations by serializing it. llvm-svn: 239454
2015-06-10 09:47:58 +08:00
Context, cast<TemplateTemplateParmDecl>(FromParam), ToParam))
break;
}
}
}
[modules] Maintain an AST invariant across module load/save: if any declaration of a function has a resolved exception specification, then all declarations of the function do. We should probably improve the AST representation to make this implicit (perhaps only store the exception specification on the canonical declaration), but this fixes things for now. The testcase for this (which used to assert) also exposes the actual bug I was trying to reduce here: we sometimes fail to emit the body of an imported special member function definition. Fix for that to follow. llvm-svn: 214458
2014-08-01 07:46:44 +08:00
void ASTDeclReader::attachPreviousDecl(ASTReader &Reader, Decl *D,
[modules] Remove redundant import of lexical decls when building a lookup table for a DeclContext, and fix propagation of exception specifications along redeclaration chains. This reverts r232905, r232907, and r232907, which reverted r232793, r232853, and r232853. One additional change is present here to resolve issues with LLDB: distinguish between whether lexical decls missing from the lookup table are local or are provided by the external AST source, and still look in the external source if that's where they came from. llvm-svn: 232928
2015-03-23 11:25:59 +08:00
Decl *Previous, Decl *Canon) {
Refactor to avoid explicitly listing all the different flavours of redeclarable declarations, and duplicating code between them. llvm-svn: 208662
2014-05-13 09:15:00 +08:00
assert(D && Previous);
switch (D->getKind()) {
#define ABSTRACT_DECL(TYPE)
[modules] Remove redundant import of lexical decls when building a lookup table for a DeclContext, and fix propagation of exception specifications along redeclaration chains. This reverts r232905, r232907, and r232907, which reverted r232793, r232853, and r232853. One additional change is present here to resolve issues with LLDB: distinguish between whether lexical decls missing from the lookup table are local or are provided by the external AST source, and still look in the external source if that's where they came from. llvm-svn: 232928
2015-03-23 11:25:59 +08:00
#define DECL(TYPE, BASE) \
case Decl::TYPE: \
attachPreviousDeclImpl(Reader, cast<TYPE##Decl>(D), Previous, Canon); \
Refactor to avoid explicitly listing all the different flavours of redeclarable declarations, and duplicating code between them. llvm-svn: 208662
2014-05-13 09:15:00 +08:00
break;
#include "clang/AST/DeclNodes.inc"
When reading the AST, delay loading of the redeclaration chain to avoid deeply nested calls. Temporarily set the first (canonical) declaration as the previous one, which is the one that matters, and mark the real previous DeclID to be loaded & attached later on. Fixes rdar://8956193. llvm-svn: 125434
2011-02-12 15:50:47 +08:00
}
When merging redeclaration chains across modules, if a declaration is visible in one module but is only declared as a friend in another module, keep it visible in the result of the merge. This is incomplete on two axes: 1) Our handling of local extern declarations is basically broken (we put them in the wrong decl context, and don't find them in redeclaration lookup, unless they've previously been declared), and this results in them making friends visible after a merge. 2) Eventually we'll need to mark that this has happened, and more carefully check whether a declaration should be visible if it was only visible in some of the modules in which it was declared. Fortunately it's rare for the identifier namespace of a declaration to change along its redeclaration chain. llvm-svn: 187639
2013-08-02 09:09:12 +08:00
// If the declaration was visible in one module, a redeclaration of it in
// another module remains visible even if it wouldn't be visible by itself.
//
// FIXME: In this case, the declaration should only be visible if a module
// that makes it visible has been imported.
D->IdentifierNamespace |=
Refactor to avoid explicitly listing all the different flavours of redeclarable declarations, and duplicating code between them. llvm-svn: 208662
2014-05-13 09:15:00 +08:00
Previous->IdentifierNamespace &
When merging redeclaration chains across modules, if a declaration is visible in one module but is only declared as a friend in another module, keep it visible in the result of the merge. This is incomplete on two axes: 1) Our handling of local extern declarations is basically broken (we put them in the wrong decl context, and don't find them in redeclaration lookup, unless they've previously been declared), and this results in them making friends visible after a merge. 2) Eventually we'll need to mark that this has happened, and more carefully check whether a declaration should be visible if it was only visible in some of the modules in which it was declared. Fortunately it's rare for the identifier namespace of a declaration to change along its redeclaration chain. llvm-svn: 187639
2013-08-02 09:09:12 +08:00
(Decl::IDNS_Ordinary | Decl::IDNS_Tag | Decl::IDNS_Type);
When merging functions across modules (and in particular, instantiations of member functions), ensure that the redecl chain never transitions from 'inline' to 'not inline', since that violates an AST invariant. llvm-svn: 209794
2014-05-29 11:15:31 +08:00
[modules] When we merge redecl chains or mark a decl used with an update record, mark all subsequent decls as 'used' too, to maintain the AST invariant that getPreviousDecl()->Used implies this->Used. llvm-svn: 211050
2014-06-17 04:26:19 +08:00
// If the previous declaration is marked as used, then this declaration should
// be too.
if (Previous->Used)
D->Used = true;
[modules] Reconstruct template default argument inheritance on reload rather than wasting storage and triggering eager deserializations by serializing it. llvm-svn: 239454
2015-06-10 09:47:58 +08:00
// If the declaration declares a template, it may inherit default arguments
// from the previous declaration.
if (TemplateDecl *TD = dyn_cast<TemplateDecl>(D))
inheritDefaultTemplateArguments(Reader.getContext(),
cast<TemplateDecl>(Previous), TD);
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
}
Refactor to avoid explicitly listing all the different flavours of redeclarable declarations, and duplicating code between them. llvm-svn: 208662
2014-05-13 09:15:00 +08:00
template<typename DeclT>
void ASTDeclReader::attachLatestDeclImpl(Redeclarable<DeclT> *D, Decl *Latest) {
If a declaration is loaded, and then a module import adds a redeclaration, then ensure that querying the first declaration for its most recent declaration checks for redeclarations from the imported module. This works as follows: * The 'most recent' pointer on a canonical declaration grows a pointer to the external AST source and a generation number (space- and time-optimized for the case where there is no external source). * Each time the 'most recent' pointer is queried, if it has an external source, we check whether it's up to date, and update it if not. * The ancillary data stored on the canonical declaration is allocated lazily to avoid filling it in for declarations that end up being non-canonical. We'll still perform a redundant (ASTContext) allocation if someone asks for the most recent declaration from a decl before setPreviousDecl is called, but such cases are probably all bugs, and are now easy to find. Some finessing is still in order here -- in particular, we use a very general mechanism for handling the DefinitionData pointer on CXXRecordData, and a more targeted approach would be more compact. Also, the MayHaveOutOfDateDef mechanism should now be expunged, since it was addressing only a corner of the full problem space here. That's not covered by this patch. Early performance benchmarks show that this makes no measurable difference to Clang performance without modules enabled (and fixes a major correctness issue with modules enabled). I'll revert if a full performance comparison shows any problems. llvm-svn: 209046
2014-05-17 07:01:30 +08:00
D->RedeclLink.setLatest(cast<DeclT>(Latest));
Refactor to avoid explicitly listing all the different flavours of redeclarable declarations, and duplicating code between them. llvm-svn: 208662
2014-05-13 09:15:00 +08:00
}
void ASTDeclReader::attachLatestDeclImpl(...) {
llvm_unreachable("attachLatestDecl on non-redeclarable declaration");
}
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);
Refactor to avoid explicitly listing all the different flavours of redeclarable declarations, and duplicating code between them. llvm-svn: 208662
2014-05-13 09:15:00 +08:00
switch (D->getKind()) {
#define ABSTRACT_DECL(TYPE)
If a declaration is loaded, and then a module import adds a redeclaration, then ensure that querying the first declaration for its most recent declaration checks for redeclarations from the imported module. This works as follows: * The 'most recent' pointer on a canonical declaration grows a pointer to the external AST source and a generation number (space- and time-optimized for the case where there is no external source). * Each time the 'most recent' pointer is queried, if it has an external source, we check whether it's up to date, and update it if not. * The ancillary data stored on the canonical declaration is allocated lazily to avoid filling it in for declarations that end up being non-canonical. We'll still perform a redundant (ASTContext) allocation if someone asks for the most recent declaration from a decl before setPreviousDecl is called, but such cases are probably all bugs, and are now easy to find. Some finessing is still in order here -- in particular, we use a very general mechanism for handling the DefinitionData pointer on CXXRecordData, and a more targeted approach would be more compact. Also, the MayHaveOutOfDateDef mechanism should now be expunged, since it was addressing only a corner of the full problem space here. That's not covered by this patch. Early performance benchmarks show that this makes no measurable difference to Clang performance without modules enabled (and fixes a major correctness issue with modules enabled). I'll revert if a full performance comparison shows any problems. llvm-svn: 209046
2014-05-17 07:01:30 +08:00
#define DECL(TYPE, BASE) \
case Decl::TYPE: \
Refactor to avoid explicitly listing all the different flavours of redeclarable declarations, and duplicating code between them. llvm-svn: 208662
2014-05-13 09:15:00 +08:00
attachLatestDeclImpl(cast<TYPE##Decl>(D), Latest); \
break;
#include "clang/AST/DeclNodes.inc"
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
}
}
If two sibling modules declare the same entity, and we indirectly pull a declaration of that entity in from one of those modules, keep track of the fact that we've not completed the redeclaration chain yet so that we can pull the remaining declarations in from the other module if they're needed. llvm-svn: 209161
2014-05-20 04:59:20 +08:00
template<typename DeclT>
void ASTDeclReader::markIncompleteDeclChainImpl(Redeclarable<DeclT> *D) {
D->RedeclLink.markIncomplete();
}
void ASTDeclReader::markIncompleteDeclChainImpl(...) {
llvm_unreachable("markIncompleteDeclChain on non-redeclarable declaration");
}
void ASTReader::markIncompleteDeclChain(Decl *D) {
switch (D->getKind()) {
#define ABSTRACT_DECL(TYPE)
#define DECL(TYPE, BASE) \
case Decl::TYPE: \
ASTDeclReader::markIncompleteDeclChainImpl(cast<TYPE##Decl>(D)); \
break;
#include "clang/AST/DeclNodes.inc"
}
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
/// \brief Read the declaration at the given offset from the AST file.
Introduce the local -> global declaration ID mapping into the AST reader, to allow AST files to be loaded with their declarations remapped to different ID numbers. Fix a number of places where we were either failing to map local declaration IDs into global declaration IDs or where interpreting the local declaration IDs within the wrong module. I've tested this via the usual "random gaps" method. It works well except for the preamble tests, because our handling of the precompiled preamble requires declaration and preprocessed entity to be stable when parsing code and then loading that back into memory. This property will hold in general, but my randomized testing naturally breaks this property to get more coverage. In the future, I expect that the precompiled preamble logic won't need this property. I am very unhappy with the current handling of the translation unit, which is a rather egregious hack. We're going to have to do something very different here for loading multiple AST files, because we don't want to have to cope with merging two translation units. Likely, we'll just handle translation units entirely via "update" records, and predefine a single, fixed declaration ID for the translation unit. That will come later. llvm-svn: 136779
2011-08-03 23:48:04 +08:00
Decl *ASTReader::ReadDeclRecord(DeclID ID) {
In the serialized AST format, make the translation unit a "predefined" declaration that never actually gets serialized. Instead, serialize the various kinds of update records (lexical decls, visible decls, the addition of an anonymous namespace) for the translation unit, even if we're not chaining. This way, we won't have to deal with multiple loaded translation unit declarations. llvm-svn: 137395
2011-08-12 08:15:20 +08:00
unsigned Index = ID - NUM_PREDEF_DECL_IDS;
[PCH] Pull the location out of the serialized declarations and put it in the array of decl bit offsets. This allows us to easily get at the location of a decl without deserializing it. It increases size of Cocoa PCH by only 0.2%. llvm-svn: 143123
2011-10-28 02:47:35 +08:00
unsigned RawLocation = 0;
RecordLocation Loc = DeclCursorForID(ID, RawLocation);
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
llvm::BitstreamCursor &DeclsCursor = Loc.F->DeclsCursor;
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
// Keep track of where we are in the stream, then jump back there
// after reading this declaration.
read all decls (and attributes and stmts/exprs referenced by the decl) from the DeclsCursor. llvm-svn: 70190
2009-04-27 13:58:23 +08:00
SavedStreamPosition SavedPosition(DeclsCursor);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
Modify the way sub-statements are stored and retrieved from PCH. Before this commit, sub-stmts were stored as encountered and when they were placed in the Stmts stack we had to know what index each stmt operand has. This complicated supporting variable sub-stmts and sub-stmts that were contained in TypeSourceInfos, e.g. x = sizeof(int[1]); would crash PCH. Now, sub-stmts are stored in reverse order, from last to first, so that when reading them, in order to get the next sub-stmt we just need to pop the last stmt from the stack. This greatly simplified the way stmts are written and read (just use PCHWriter::AddStmt and PCHReader::ReadStmt accordingly) and allowed variable stmt operands and TypeSourceInfo exprs. llvm-svn: 107087
2010-06-29 06:28:35 +08:00
ReadingKindTracker ReadingKind(Read_Decl, *this);
Fix PR 4489, a crash in PCH loading that occurs when loading the name of a top-level declaration loads another top-level declaration of the same name whose type depends on the first declaration having been completed. This commit breaks the circular dependency by delaying loads of top-level declarations triggered by loading a name until we are no longer recursively loading types or declarations. llvm-svn: 74847
2009-07-07 02:54:52 +08:00
// Note that we are loading a declaration record.
Refactor the way PCHReader tracks whether we are in recursive loading. -Replace CurrentlyLoadingTypeOrDecl with a counting scheme (NumCurrentElementsDeserializing) -Provide outside access to the mechanism by adding methods StartedDeserializing/FinishedDeserializing to ExternalASTSource. These are preparation for the next commit. llvm-svn: 109856
2010-07-30 18:03:16 +08:00
Deserializing ADecl(this);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Thread PerFileData through the ASTReader again, this time with the LLVM changes. llvm-svn: 115625
2010-10-05 23:59:54 +08:00
DeclsCursor.JumpToBit(Loc.Offset);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
RecordData Record;
read all decls (and attributes and stmts/exprs referenced by the decl) from the DeclsCursor. llvm-svn: 70190
2009-04-27 13:58:23 +08:00
unsigned Code = DeclsCursor.ReadCode();
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
unsigned Idx = 0;
Remove an unused private field exposed by the recent LLVM_DELETED_FUNCTION changes. llvm-svn: 164106
2012-09-18 13:34:55 +08:00
ASTDeclReader Reader(*this, *Loc.F, ID, RawLocation, Record,Idx);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
Decl *D = nullptr;
update to use the new BitcodeCursor readRecord that takes a StringRef blob parameter, and adopt "advance" in more places. llvm-svn: 172951
2013-01-20 10:38:54 +08:00
switch ((DeclCode)DeclsCursor.readRecord(Code, Record)) {
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_CONTEXT_LEXICAL:
case DECL_CONTEXT_VISIBLE:
Switch assert(0/false) llvm_unreachable. llvm-svn: 140367
2011-09-23 13:06:16 +08:00
llvm_unreachable("Record cannot be de-serialized with ReadDeclRecord");
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_TYPEDEF:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = TypedefDecl::CreateDeserialized(Context, ID);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
break;
Support for C++11 (non-template) alias declarations. llvm-svn: 129567
2011-04-15 22:24:37 +08:00
case DECL_TYPEALIAS:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = TypeAliasDecl::CreateDeserialized(Context, ID);
Support for C++11 (non-template) alias declarations. llvm-svn: 129567
2011-04-15 22:24:37 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_ENUM:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = EnumDecl::CreateDeserialized(Context, ID);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_RECORD:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = RecordDecl::CreateDeserialized(Context, ID);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_ENUM_CONSTANT:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = EnumConstantDecl::CreateDeserialized(Context, ID);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_FUNCTION:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = FunctionDecl::CreateDeserialized(Context, ID);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_LINKAGE_SPEC:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = LinkageSpecDecl::CreateDeserialized(Context, ID);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
break;
Step #1/N of implementing support for __label__: split labels into LabelDecl and LabelStmt. There is a 1-1 correspondence between the two, but this simplifies a bunch of code by itself. This is because labels are the only place where we previously had references to random other statements, causing grief for AST serialization and other stuff. This does cause one regression (attr(unused) doesn't silence unused label warnings) which I'll address next. This does fix some minor bugs: 1. "The only valid attribute " diagnostic was capitalized. 2. Various diagnostics printed as ''labelname'' instead of 'labelname' 3. This reduces duplication of label checking between functions and blocks. Review appreciated, particularly for the cindex and template bits. llvm-svn: 125733
2011-02-17 15:39:24 +08:00
case DECL_LABEL:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = LabelDecl::CreateDeserialized(Context, ID);
Step #1/N of implementing support for __label__: split labels into LabelDecl and LabelStmt. There is a 1-1 correspondence between the two, but this simplifies a bunch of code by itself. This is because labels are the only place where we previously had references to random other statements, causing grief for AST serialization and other stuff. This does cause one regression (attr(unused) doesn't silence unused label warnings) which I'll address next. This does fix some minor bugs: 1. "The only valid attribute " diagnostic was capitalized. 2. Various diagnostics printed as ''labelname'' instead of 'labelname' 3. This reduces duplication of label checking between functions and blocks. Review appreciated, particularly for the cindex and template bits. llvm-svn: 125733
2011-02-17 15:39:24 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_NAMESPACE:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = NamespaceDecl::CreateDeserialized(Context, ID);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_NAMESPACE_ALIAS:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = NamespaceAliasDecl::CreateDeserialized(Context, ID);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_USING:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = UsingDecl::CreateDeserialized(Context, ID);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_USING_SHADOW:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = UsingShadowDecl::CreateDeserialized(Context, ID);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_USING_DIRECTIVE:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = UsingDirectiveDecl::CreateDeserialized(Context, ID);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_UNRESOLVED_USING_VALUE:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = UnresolvedUsingValueDecl::CreateDeserialized(Context, ID);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_UNRESOLVED_USING_TYPENAME:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = UnresolvedUsingTypenameDecl::CreateDeserialized(Context, ID);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_CXX_RECORD:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = CXXRecordDecl::CreateDeserialized(Context, ID);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_CXX_METHOD:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = CXXMethodDecl::CreateDeserialized(Context, ID);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_CXX_CONSTRUCTOR:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = CXXConstructorDecl::CreateDeserialized(Context, ID);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_CXX_DESTRUCTOR:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = CXXDestructorDecl::CreateDeserialized(Context, ID);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_CXX_CONVERSION:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = CXXConversionDecl::CreateDeserialized(Context, ID);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_ACCESS_SPEC:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = AccessSpecDecl::CreateDeserialized(Context, ID);
Added AccessSpecDecl node. llvm-svn: 105525
2010-06-05 13:09:32 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_FRIEND:
Added outer template parameter lists to friend type AST nodes. llvm-svn: 174050
2013-01-31 17:54:08 +08:00
D = FriendDecl::CreateDeserialized(Context, ID, Record[Idx++]);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_FRIEND_TEMPLATE:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = FriendTemplateDecl::CreateDeserialized(Context, ID);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_CLASS_TEMPLATE:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = ClassTemplateDecl::CreateDeserialized(Context, ID);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_CLASS_TEMPLATE_SPECIALIZATION:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = ClassTemplateSpecializationDecl::CreateDeserialized(Context, ID);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_CLASS_TEMPLATE_PARTIAL_SPECIALIZATION:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = ClassTemplatePartialSpecializationDecl::CreateDeserialized(Context, ID);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
break;
Started implementing variable templates. Top level declarations should be fully supported, up to some limitations documented as FIXMEs or TODO. Static data member templates work very partially. Static data member templates of class templates need particular attention... llvm-svn: 187762
2013-08-06 09:03:05 +08:00
case DECL_VAR_TEMPLATE:
D = VarTemplateDecl::CreateDeserialized(Context, ID);
break;
case DECL_VAR_TEMPLATE_SPECIALIZATION:
D = VarTemplateSpecializationDecl::CreateDeserialized(Context, ID);
break;
case DECL_VAR_TEMPLATE_PARTIAL_SPECIALIZATION:
D = VarTemplatePartialSpecializationDecl::CreateDeserialized(Context, ID);
break;
Implement function template specialization at class scope extension in Microsoft mode. A new AST node is introduced: ClassScopeFunctionSpecialization. This node holds a FunctionDecl that is not yet specialized; then during the class template instantiation the ClassScopeFunctionSpecialization will spawn the actual function specialization. Example: template <class T> class A { public: template <class U> void f(U p) { } template <> void f(int p) { } // <== class scope specialization }; This extension is necessary to parse MSVC standard C++ headers, MFC and ATL code. BTW, with this feature in, clang can parse (-fsyntax-only) all the MSVC 2010 standard header files without any error. llvm-svn: 137573
2011-08-14 11:52:19 +08:00
case DECL_CLASS_SCOPE_FUNCTION_SPECIALIZATION:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = ClassScopeFunctionSpecializationDecl::CreateDeserialized(Context, ID);
Implement function template specialization at class scope extension in Microsoft mode. A new AST node is introduced: ClassScopeFunctionSpecialization. This node holds a FunctionDecl that is not yet specialized; then during the class template instantiation the ClassScopeFunctionSpecialization will spawn the actual function specialization. Example: template <class T> class A { public: template <class U> void f(U p) { } template <> void f(int p) { } // <== class scope specialization }; This extension is necessary to parse MSVC standard C++ headers, MFC and ATL code. BTW, with this feature in, clang can parse (-fsyntax-only) all the MSVC 2010 standard header files without any error. llvm-svn: 137573
2011-08-14 11:52:19 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_FUNCTION_TEMPLATE:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = FunctionTemplateDecl::CreateDeserialized(Context, ID);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_TEMPLATE_TYPE_PARM:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = TemplateTypeParmDecl::CreateDeserialized(Context, ID);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_NON_TYPE_TEMPLATE_PARM:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = NonTypeTemplateParmDecl::CreateDeserialized(Context, ID);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
break;
Implement support for non-type template parameter packs whose type is a pack expansion, e.g., the parameter pack Values in: template<typename ...Types> struct Outer { template<Types ...Values> struct Inner; }; This new implementation approach introduces the notion of an "expanded" non-type template parameter pack, for which we have already expanded the types of the parameter pack (to, say, "int*, float*", for Outer<int*, float*>) but have not yet expanded the values. Aside from creating these expanded non-type template parameter packs, this patch updates template argument checking and non-type template parameter pack instantiation to make use of the appropriate types in the parameter pack. llvm-svn: 123845
2011-01-20 04:10:05 +08:00
case DECL_EXPANDED_NON_TYPE_TEMPLATE_PARM_PACK:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = NonTypeTemplateParmDecl::CreateDeserialized(Context, ID, Record[Idx++]);
Implement support for non-type template parameter packs whose type is a pack expansion, e.g., the parameter pack Values in: template<typename ...Types> struct Outer { template<Types ...Values> struct Inner; }; This new implementation approach introduces the notion of an "expanded" non-type template parameter pack, for which we have already expanded the types of the parameter pack (to, say, "int*, float*", for Outer<int*, float*>) but have not yet expanded the values. Aside from creating these expanded non-type template parameter packs, this patch updates template argument checking and non-type template parameter pack instantiation to make use of the appropriate types in the parameter pack. llvm-svn: 123845
2011-01-20 04:10:05 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_TEMPLATE_TEMPLATE_PARM:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = TemplateTemplateParmDecl::CreateDeserialized(Context, ID);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
break;
PR9023: A template template parameter whose template parameter list contains an unexpanded parameter pack is a pack expansion. Thus, as with a non-type template parameter which is a pack expansion, it needs to be expanded early into a fixed list of template parameters. Since the expanded list of template parameters is not itself a parameter pack, it is permitted to appear before the end of the template parameter list, so also remove that restriction (for both template template parameter pack expansions and non-type template parameter pack expansions). llvm-svn: 163369
2012-09-07 10:06:42 +08:00
case DECL_EXPANDED_TEMPLATE_TEMPLATE_PARM_PACK:
D = TemplateTemplateParmDecl::CreateDeserialized(Context, ID,
Record[Idx++]);
break;
Implement support for C++0x alias templates. llvm-svn: 130953
2011-05-06 05:57:07 +08:00
case DECL_TYPE_ALIAS_TEMPLATE:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = TypeAliasTemplateDecl::CreateDeserialized(Context, ID);
Implement support for C++0x alias templates. llvm-svn: 130953
2011-05-06 05:57:07 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_STATIC_ASSERT:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = StaticAssertDecl::CreateDeserialized(Context, ID);
add PCH support for a bunch of C++ Decls, patch by Andrew Sutton! llvm-svn: 103301
2010-05-08 05:43:38 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_OBJC_METHOD:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = ObjCMethodDecl::CreateDeserialized(Context, ID);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_OBJC_INTERFACE:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = ObjCInterfaceDecl::CreateDeserialized(Context, ID);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_OBJC_IVAR:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = ObjCIvarDecl::CreateDeserialized(Context, ID);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_OBJC_PROTOCOL:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = ObjCProtocolDecl::CreateDeserialized(Context, ID);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_OBJC_AT_DEFS_FIELD:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = ObjCAtDefsFieldDecl::CreateDeserialized(Context, ID);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_OBJC_CATEGORY:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = ObjCCategoryDecl::CreateDeserialized(Context, ID);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_OBJC_CATEGORY_IMPL:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = ObjCCategoryImplDecl::CreateDeserialized(Context, ID);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_OBJC_IMPLEMENTATION:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = ObjCImplementationDecl::CreateDeserialized(Context, ID);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_OBJC_COMPATIBLE_ALIAS:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = ObjCCompatibleAliasDecl::CreateDeserialized(Context, ID);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_OBJC_PROPERTY:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = ObjCPropertyDecl::CreateDeserialized(Context, ID);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_OBJC_PROPERTY_IMPL:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = ObjCPropertyImplDecl::CreateDeserialized(Context, ID);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_FIELD:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = FieldDecl::CreateDeserialized(Context, ID);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
break;
Major anonymous union/struct redesign. A new AST node is introduced: def IndirectField : DDecl<Value>; IndirectFields are injected into the anonymous's parent scope and chain back to the original field. Name lookup for anonymous entities now result in an IndirectFieldDecl instead of a FieldDecl. There is no functionality change, the code generated should be the same. llvm-svn: 119919
2010-11-21 14:08:52 +08:00
case DECL_INDIRECTFIELD:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = IndirectFieldDecl::CreateDeserialized(Context, ID);
Major anonymous union/struct redesign. A new AST node is introduced: def IndirectField : DDecl<Value>; IndirectFields are injected into the anonymous's parent scope and chain back to the original field. Name lookup for anonymous entities now result in an IndirectFieldDecl instead of a FieldDecl. There is no functionality change, the code generated should be the same. llvm-svn: 119919
2010-11-21 14:08:52 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_VAR:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = VarDecl::CreateDeserialized(Context, ID);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_IMPLICIT_PARAM:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = ImplicitParamDecl::CreateDeserialized(Context, ID);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_PARM_VAR:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = ParmVarDecl::CreateDeserialized(Context, ID);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_FILE_SCOPE_ASM:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = FileScopeAsmDecl::CreateDeserialized(Context, ID);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
break;
Rename pch namespace to serialization. llvm-svn: 111478
2010-08-19 07:57:32 +08:00
case DECL_BLOCK:
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = BlockDecl::CreateDeserialized(Context, ID);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
break;
Basic support for Microsoft property declarations and references thereto. Patch by Tong Shen! llvm-svn: 179585
2013-04-16 15:28:30 +08:00
case DECL_MS_PROPERTY:
D = MSPropertyDecl::CreateDeserialized(Context, ID);
break;
Sema for Captured Statements Add CapturedDecl to be the DeclContext for CapturedStmt, and perform semantic analysis. Currently captures all variables by reference. TODO: templates Author: Ben Langmuir <ben.langmuir@intel.com> Differential Revision: http://llvm-reviews.chandlerc.com/D433 llvm-svn: 179618
2013-04-17 03:37:38 +08:00
case DECL_CAPTURED:
Serialization for captured statements Add serialization for captured statements and captured decls. Also add a const_capture_iterator to CapturedStmt. Test contributed by Wei Pan Differential Revision: http://llvm-reviews.chandlerc.com/D727 llvm-svn: 181048
2013-05-04 03:20:19 +08:00
D = CapturedDecl::CreateDeserialized(Context, ID, Record[Idx++]);
Sema for Captured Statements Add CapturedDecl to be the DeclContext for CapturedStmt, and perform semantic analysis. Currently captures all variables by reference. TODO: templates Author: Ben Langmuir <ben.langmuir@intel.com> Differential Revision: http://llvm-reviews.chandlerc.com/D433 llvm-svn: 179618
2013-04-17 03:37:38 +08:00
break;
Make the deserialization of C++ base class specifiers lazy, improving the performance of C++ PCH and reducing stack depth in the reader. llvm-svn: 117732
2010-10-30 06:39:52 +08:00
case DECL_CXX_BASE_SPECIFIERS:
Error("attempt to read a C++ base-specifier record as a declaration");
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
return nullptr;
[modules] Deserialize CXXCtorInitializer list for a constructor lazily. Previously we'd deserialize the list of mem-initializers for a constructor when we deserialized the declaration of the constructor. That could trigger a significant amount of unnecessary work (pulling in all base classes recursively, for a start) and was causing problems for the modules buildbot due to cyclic deserializations. We now deserialize these on demand. This creates a certain amount of duplication with the handling of CXXBaseSpecifiers; I'll look into reducing that next. llvm-svn: 233052
2015-03-24 14:36:48 +08:00
case DECL_CXX_CTOR_INITIALIZERS:
Error("attempt to read a C++ ctor initializer record as a declaration");
return nullptr;
Introduce a module import declaration, so that we properly represent, e.g., __import_module__ std.vector; in the AST. llvm-svn: 145725
2011-12-03 07:23:56 +08:00
case DECL_IMPORT:
// Note: last entry of the ImportDecl record is the number of stored source
// locations.
When creating declarations that are deserialized from an module file, go through a central allocation routine Decl::AllocateDeserializedDecl(). No actual functionality change (yet). llvm-svn: 147614
2012-01-06 05:55:30 +08:00
D = ImportDecl::CreateDeserialized(Context, ID, Record.back());
Introduce a module import declaration, so that we properly represent, e.g., __import_module__ std.vector; in the AST. llvm-svn: 145725
2011-12-03 07:23:56 +08:00
break;
OpenMP threadprivate directive parsing and semantic analysis llvm-svn: 177705
2013-03-22 14:34:35 +08:00
case DECL_OMP_THREADPRIVATE:
D = OMPThreadPrivateDecl::CreateDeserialized(Context, ID, Record[Idx++]);
break;
[OPENMP 4.0] Initial support for 'omp declare reduction' construct. Add parsing, sema analysis and serialization/deserialization for 'declare reduction' construct. User-defined reductions are defined as #pragma omp declare reduction( reduction-identifier : typename-list : combiner ) [initializer ( initializer-expr )] These custom reductions may be used in 'reduction' clauses of OpenMP constructs. The combiner specifies how partial results can be combined into a single value. The combiner can use the special variable identifiers omp_in and omp_out that are of the type of the variables being reduced with this reduction-identifier. Each of them will denote one of the values to be combined before executing the combiner. It is assumed that the special omp_out identifier will refer to the storage that holds the resulting combined value after executing the combiner. As the initializer-expr value of a user-defined reduction is not known a priori the initializer-clause can be used to specify one. Then the contents of the initializer-clause will be used as the initializer for private copies of reduction list items where the omp_priv identifier will refer to the storage to be initialized. The special identifier omp_orig can also appear in the initializer-clause and it will refer to the storage of the original variable to be reduced. Differential Revision: http://reviews.llvm.org/D11182 llvm-svn: 262582
2016-03-03 13:21:39 +08:00
case DECL_OMP_DECLARE_REDUCTION:
D = OMPDeclareReductionDecl::CreateDeserialized(Context, ID);
break;
[OPENMP] Rename OMPCapturedFieldDecl to OMPCapturedExprDecl, NFC. OMPCapturedExprDecl allows caopturing not only of fielddecls, but also other expressions. It also allows to simplify codegen for several clauses. llvm-svn: 260492
2016-02-11 13:35:55 +08:00
case DECL_OMP_CAPTUREDEXPR:
D = OMPCapturedExprDecl::CreateDeserialized(Context, ID);
[OPENMP 4.5] Ccapture/codegen of private non-static data members. OpenMP 4.5 introduces privatization of non-static data members of current class in non-static member functions. To correctly handle such kind of privatization a new (pseudo)declaration VarDecl-based node is added. It allows to reuse an existing code for capturing variables in Lambdas/Block/Captured blocks of code for correct privatization and codegen. llvm-svn: 260077
2016-02-08 17:29:13 +08:00
break;
Serialize `#pragma comment`. `#pragma comment` was handled by Sema calling a function on ASTConsumer, and CodeGen then implementing this function and writing things to its output. Instead, introduce a PragmaCommentDecl AST node and hang one off the TranslationUnitDecl for every `#pragma comment` line, and then use the regular serialization machinery. (Since PragmaCommentDecl has codegen relevance, it's eagerly deserialized.) http://reviews.llvm.org/D17799 llvm-svn: 262493
2016-03-03 01:28:48 +08:00
case DECL_PRAGMA_COMMENT:
D = PragmaCommentDecl::CreateDeserialized(Context, ID, Record[Idx++]);
break;
Serialize `#pragma detect_mismatch`. This is like r262493, but for pragma detect_mismatch instead of pragma comment. The two pragmas have similar behavior, so use the same approach for both. llvm-svn: 262506
2016-03-03 03:28:54 +08:00
case DECL_PRAGMA_DETECT_MISMATCH:
D = PragmaDetectMismatchDecl::CreateDeserialized(Context, ID,
Record[Idx++]);
break;
[Sema] Semantic analysis for empty-declaration and attribute-declaration. Introduce a new AST Decl node "EmptyDecl" to model empty-declaration. Have attributes from attribute-declaration appertain to the EmptyDecl node by creating the AST representations of these attributes and attach them to the EmptyDecl node so these attributes can be sema checked just as attributes attached to "normal" declarations. llvm-svn: 175900
2013-02-23 01:15:32 +08:00
case DECL_EMPTY:
D = EmptyDecl::CreateDeserialized(Context, ID);
break;
Parsing, semantic analysis, and AST for Objective-C type parameters. Produce type parameter declarations for Objective-C type parameters, and attach lists of type parameters to Objective-C classes, categories, forward declarations, and extensions as appropriate. Perform semantic analysis of type bounds for type parameters, both in isolation and across classes/categories/extensions to ensure consistency. Also handle (de-)serialization of Objective-C type parameter lists, along with sundry other things one must do to add a new declaration to Clang. Note that Objective-C type parameters are typedef name declarations, like typedefs and C++11 type aliases, in support of type erasure. Part of rdar://problem/6294649. llvm-svn: 241541
2015-07-07 11:57:15 +08:00
case DECL_OBJC_TYPE_PARAM:
D = ObjCTypeParamDecl::CreateDeserialized(Context, ID);
break;
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Rename PCHDeclReader -> ASTDeclReader. llvm-svn: 111469
2010-08-19 07:56:48 +08:00
assert(D && "Unknown declaration reading AST file");
move attribute reading to PCHReaderDecl.cpp, remove some extraneous braces. llvm-svn: 70191
2009-04-27 14:01:06 +08:00
LoadedDecl(Index, D);
[PCH] Set the DeclContext before doing any deserialization, to make sure internal calls to Decl::getASTContext() by Decl's methods will find the TranslationUnitDecl without crashing due to a parent declaration context still deserializing. llvm-svn: 150153
2012-02-09 14:02:44 +08:00
// Set the DeclContext before doing any deserialization, to make sure internal
// calls to Decl::getASTContext() by Decl's methods will find the
// TranslationUnitDecl without crashing.
D->setDeclContext(Context.getTranslationUnitDecl());
move attribute reading to PCHReaderDecl.cpp, remove some extraneous braces. llvm-svn: 70191
2009-04-27 14:01:06 +08:00
Reader.Visit(D);
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
// If this declaration is also a declaration context, get the
// offsets for its tables of lexical and visible declarations.
if (DeclContext *DC = dyn_cast<DeclContext>(D)) {
std::pair<uint64_t, uint64_t> Offsets = Reader.VisitDeclContext(DC);
[modules] Defer setting up the lookup table for a DeclContext until we can determine the primary context, rather than sometimes registering the lookup table on the wrong context. This exposed a couple of bugs: * the odr violation check didn't deal properly with mergeable declarations if the declaration retained by name lookup wasn't in the canonical definition of the class * the (broken) RewriteDecl mechanism would emit two name lookup tables for the same DeclContext into the same module file (one as part of the rewritten declaration and one as a visible update for the old declaration) These are both fixed too. llvm-svn: 244192
2015-08-06 12:23:48 +08:00
if (Offsets.first &&
ReadLexicalDeclContextStorage(*Loc.F, DeclsCursor, Offsets.first, DC))
return nullptr;
if (Offsets.second &&
ReadVisibleDeclContextStorage(*Loc.F, DeclsCursor, Offsets.second, ID))
return nullptr;
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
assert(Idx == Record.size());
In the serialized AST format, make the translation unit a "predefined" declaration that never actually gets serialized. Instead, serialize the various kinds of update records (lexical decls, visible decls, the addition of an anonymous namespace) for the translation unit, even if we're not chaining. This way, we won't have to deal with multiple loaded translation unit declarations. llvm-svn: 137395
2011-08-12 08:15:20 +08:00
// Load any relevant update records.
Defer loading any pending update records until we've finished deserializing. This fixes a bug where an update record causes us to load an entity that refers to an entity we've not finished loading yet, resulting in badness. llvm-svn: 207603
2014-04-30 10:24:17 +08:00
PendingUpdateRecords.push_back(std::make_pair(ID, D));
[PCH] Load the chained objc categories only after recursive loading is finished otherwise we may crash. llvm-svn: 144524
2011-11-14 15:07:59 +08:00
Reimplement (de-)serialization of Objective-C categories to eliminate the direct serialization of the linked-list structure. Instead, use a scheme similar to how we handle redeclarations, with redeclaration lists on the side. This addresses several issues: - In cases involving mixing and matching of many categories across many modules, the linked-list structure would not be consistent across different modules, and categories would get lost. - If a module is loaded after the class definition and its other categories have already been loaded, we wouldn't see any categories in the newly-loaded module. llvm-svn: 149112
2012-01-27 09:47:08 +08:00
// Load the categories after recursive loading is finished.
if (ObjCInterfaceDecl *Class = dyn_cast<ObjCInterfaceDecl>(D))
if (Class->isThisDeclarationADefinition())
loadObjCCategories(ID, Class);
Support importing of ObjC categories from modules. The initial incentive was to fix a crash when PCH chaining categories to an interface, but the fix was done in the "modules way" that I hear is popular with the kids these days. Each module stores the local chain of categories and we combine them when the interface is loaded. We also warn if non-dependent modules introduce duplicate named categories. llvm-svn: 138926
2011-09-01 08:58:55 +08:00
In the serialized AST format, make the translation unit a "predefined" declaration that never actually gets serialized. Instead, serialize the various kinds of update records (lexical decls, visible decls, the addition of an anonymous namespace) for the translation unit, even if we're not chaining. This way, we won't have to deal with multiple loaded translation unit declarations. llvm-svn: 137395
2011-08-12 08:15:20 +08:00
// If we have deserialized a declaration that has a definition the
// AST consumer might need to know about, queue it.
// We don't pass it to the consumer immediately because we may be in recursive
// loading, and some declarations may still be initializing.
When we load a function or method body from an AST file, we check whether that function/method already has a body (loaded from some other AST file), as introduced in r165137. Delay this check until after the redeclaration chains have been wired up. While I'm here, make the loading of method bodies lazy. llvm-svn: 165513
2012-10-10 01:21:28 +08:00
if (isConsumerInterestedIn(D, Reader.hasPendingBody()))
Reimplement (de-)serialization of Objective-C categories to eliminate the direct serialization of the linked-list structure. Instead, use a scheme similar to how we handle redeclarations, with redeclaration lists on the side. This addresses several issues: - In cases involving mixing and matching of many categories across many modules, the linked-list structure would not be consistent across different modules, and categories would get lost. - If a module is loaded after the class definition and its other categories have already been loaded, we wouldn't see any categories in the newly-loaded module. llvm-svn: 149112
2012-01-27 09:47:08 +08:00
InterestingDecls.push_back(D);
Merge pending instantiations instead of overwriting existing ones. Check whether a pending instantiation needs to be instantiated (or whether an instantiation already exists). Verify the size of the PendingInstantiations record (was only checking size of existing PendingInstantiations). Migrate Obj-C++ part of redecl-merge into separate test, now that this is growing. templates.mm: test that CodeGen has seen exactly one definition of template instantiations. redecl-merge.m: use "@" specifier for expected-diagnostics. llvm-svn: 164993
2012-10-02 17:09:43 +08:00
In the serialized AST format, make the translation unit a "predefined" declaration that never actually gets serialized. Instead, serialize the various kinds of update records (lexical decls, visible decls, the addition of an anonymous namespace) for the translation unit, even if we're not chaining. This way, we won't have to deal with multiple loaded translation unit declarations. llvm-svn: 137395
2011-08-12 08:15:20 +08:00
return D;
}
void ASTReader::loadDeclUpdateRecords(serialization::DeclID ID, Decl *D) {
[modules] Defer setting up the lookup table for a DeclContext until we can determine the primary context, rather than sometimes registering the lookup table on the wrong context. This exposed a couple of bugs: * the odr violation check didn't deal properly with mergeable declarations if the declaration retained by name lookup wasn't in the canonical definition of the class * the (broken) RewriteDecl mechanism would emit two name lookup tables for the same DeclContext into the same module file (one as part of the rewritten declaration and one as a visible update for the old declaration) These are both fixed too. llvm-svn: 244192
2015-08-06 12:23:48 +08:00
// Load the pending visible updates for this decl context, if it has any.
auto I = PendingVisibleUpdates.find(ID);
if (I != PendingVisibleUpdates.end()) {
auto VisibleUpdates = std::move(I->second);
PendingVisibleUpdates.erase(I);
auto *DC = cast<DeclContext>(D)->getPrimaryContext();
Re-commit r246497 (and dependent changes r246524 and r246521), reverted in r246546, with a workaround for an MSVC 2013 miscompile and an MSVC 2015 rejects-valid. Original commit message: [modules] Rework serialized DeclContext lookup table management. Instead of walking the loaded ModuleFiles looking for lookup tables for the context, store them all in one place, and merge them together if we find we have too many (currently, more than 4). If we do merge, include the merged form in our serialized lookup table, so that downstream readers never need to look at our imports' tables. This gives a huge performance improvement to builds with very large numbers of modules (in some cases, more than a 2x speedup was observed). llvm-svn: 246582
2015-09-02 04:35:42 +08:00
for (const PendingVisibleUpdate &Update : VisibleUpdates)
Lookups[DC].Table.add(
Update.Mod, Update.Data,
[modules] Defer setting up the lookup table for a DeclContext until we can determine the primary context, rather than sometimes registering the lookup table on the wrong context. This exposed a couple of bugs: * the odr violation check didn't deal properly with mergeable declarations if the declaration retained by name lookup wasn't in the canonical definition of the class * the (broken) RewriteDecl mechanism would emit two name lookup tables for the same DeclContext into the same module file (one as part of the rewritten declaration and one as a visible update for the old declaration) These are both fixed too. llvm-svn: 244192
2015-08-06 12:23:48 +08:00
reader::ASTDeclContextNameLookupTrait(*this, *Update.Mod));
DC->setHasExternalVisibleStorage(true);
}
Put the mechanism in place to track modifications in an AST entity that were committed after its initial creation/deserialization and store the changes in a chained PCH. The idea is that the AST entities call methods on the ASTMutationListener to give notifications of changes; the PCHWriter implements the ASTMutationListener interface and stores the incremental changes of the updated entity. WIP llvm-svn: 117235
2010-10-25 01:26:36 +08:00
// 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()) {
[modules] Defer setting up the lookup table for a DeclContext until we can determine the primary context, rather than sometimes registering the lookup table on the wrong context. This exposed a couple of bugs: * the odr violation check didn't deal properly with mergeable declarations if the declaration retained by name lookup wasn't in the canonical definition of the class * the (broken) RewriteDecl mechanism would emit two name lookup tables for the same DeclContext into the same module file (one as part of the rewritten declaration and one as a visible update for the old declaration) These are both fixed too. llvm-svn: 244192
2015-08-06 12:23:48 +08:00
auto UpdateOffsets = std::move(UpdI->second);
DeclUpdateOffsets.erase(UpdI);
If an update record makes a declaration interesting, pass it to the consumer. llvm-svn: 204550
2014-03-23 08:27:18 +08:00
bool WasInteresting = isConsumerInterestedIn(D, false);
[modules] Defer setting up the lookup table for a DeclContext until we can determine the primary context, rather than sometimes registering the lookup table on the wrong context. This exposed a couple of bugs: * the odr violation check didn't deal properly with mergeable declarations if the declaration retained by name lookup wasn't in the canonical definition of the class * the (broken) RewriteDecl mechanism would emit two name lookup tables for the same DeclContext into the same module file (one as part of the rewritten declaration and one as a visible update for the old declaration) These are both fixed too. llvm-svn: 244192
2015-08-06 12:23:48 +08:00
for (auto &FileAndOffset : UpdateOffsets) {
ModuleFile *F = FileAndOffset.first;
uint64_t Offset = FileAndOffset.second;
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
llvm::BitstreamCursor &Cursor = F->DeclsCursor;
SavedStreamPosition SavedPosition(Cursor);
Cursor.JumpToBit(Offset);
RecordData Record;
unsigned Code = Cursor.ReadCode();
update to use the new BitcodeCursor readRecord that takes a StringRef blob parameter, and adopt "advance" in more places. llvm-svn: 172951
2013-01-20 10:38:54 +08:00
unsigned RecCode = Cursor.readRecord(Code, Record);
Put the mechanism in place to track modifications in an AST entity that were committed after its initial creation/deserialization and store the changes in a chained PCH. The idea is that the AST entities call methods on the ASTMutationListener to give notifications of changes; the PCHWriter implements the ASTMutationListener interface and stores the incremental changes of the updated entity. WIP llvm-svn: 117235
2010-10-25 01:26:36 +08:00
(void)RecCode;
assert(RecCode == DECL_UPDATES && "Expected DECL_UPDATES record!");
If an update record makes a declaration interesting, pass it to the consumer. llvm-svn: 204550
2014-03-23 08:27:18 +08:00
In the serialized AST format, make the translation unit a "predefined" declaration that never actually gets serialized. Instead, serialize the various kinds of update records (lexical decls, visible decls, the addition of an anonymous namespace) for the translation unit, even if we're not chaining. This way, we won't have to deal with multiple loaded translation unit declarations. llvm-svn: 137395
2011-08-12 08:15:20 +08:00
unsigned Idx = 0;
Remove an unused private field exposed by the recent LLVM_DELETED_FUNCTION changes. llvm-svn: 164106
2012-09-18 13:34:55 +08:00
ASTDeclReader Reader(*this, *F, ID, 0, Record, Idx);
Add a decl update when a static data member of a class template is instantiated in a different PCH than its containing class. Otherwise we get double definition errors. Fixes a Boost.MPL problem that affects Boost.Accumulators and probably a lot more of Boost. llvm-svn: 130488
2011-04-29 16:19:30 +08:00
Reader.UpdateDecl(D, *F, Record);
If an update record makes a declaration interesting, pass it to the consumer. llvm-svn: 204550
2014-03-23 08:27:18 +08:00
// We might have made this declaration interesting. If so, remember that
// we need to hand it off to the consumer.
if (!WasInteresting &&
isConsumerInterestedIn(D, Reader.hasPendingBody())) {
InterestingDecls.push_back(D);
WasInteresting = true;
}
Put the mechanism in place to track modifications in an AST entity that were committed after its initial creation/deserialization and store the changes in a chained PCH. The idea is that the AST entities call methods on the ASTMutationListener to give notifications of changes; the PCHWriter implements the ASTMutationListener interface and stores the incremental changes of the updated entity. WIP llvm-svn: 117235
2010-10-25 01:26:36 +08:00
}
}
split decl reading out to its own PCHReaderDecl.cpp file. llvm-svn: 70187
2009-04-27 13:27:42 +08:00
}
Put the mechanism in place to track modifications in an AST entity that were committed after its initial creation/deserialization and store the changes in a chained PCH. The idea is that the AST entities call methods on the ASTMutationListener to give notifications of changes; the PCHWriter implements the ASTMutationListener interface and stores the incremental changes of the updated entity. WIP llvm-svn: 117235
2010-10-25 01:26:36 +08:00
[modules] Further simplification and speedup of redeclaration chain loading. Instead of eagerly deserializing a list of DeclIDs when we load a module file and doing a binary search to find the redeclarations of a decl, store a list of redeclarations of each chain before the first declaration and load it directly. llvm-svn: 245789
2015-08-23 04:13:39 +08:00
void ASTReader::loadPendingDeclChain(Decl *FirstLocal, uint64_t LocalOffset) {
// Attach FirstLocal to the end of the decl chain.
Decl *CanonDecl = FirstLocal->getCanonicalDecl();
if (FirstLocal != CanonDecl) {
Decl *PrevMostRecent = ASTDeclReader::getMostRecentDecl(CanonDecl);
ASTDeclReader::attachPreviousDecl(
*this, FirstLocal, PrevMostRecent ? PrevMostRecent : CanonDecl,
CanonDecl);
}
[modules] Remove some dead code after r245779. llvm-svn: 245780
2015-08-22 10:09:38 +08:00
[modules] Further simplification and speedup of redeclaration chain loading. Instead of eagerly deserializing a list of DeclIDs when we load a module file and doing a binary search to find the redeclarations of a decl, store a list of redeclarations of each chain before the first declaration and load it directly. llvm-svn: 245789
2015-08-23 04:13:39 +08:00
if (!LocalOffset) {
ASTDeclReader::attachLatestDecl(CanonDecl, FirstLocal);
return;
[modules] Remove some dead code after r245779. llvm-svn: 245780
2015-08-22 10:09:38 +08:00
}
[modules] Further simplification and speedup of redeclaration chain loading. Instead of eagerly deserializing a list of DeclIDs when we load a module file and doing a binary search to find the redeclarations of a decl, store a list of redeclarations of each chain before the first declaration and load it directly. llvm-svn: 245789
2015-08-23 04:13:39 +08:00
// Load the list of other redeclarations from this module file.
ModuleFile *M = getOwningModuleFile(FirstLocal);
assert(M && "imported decl from no module file");
llvm::BitstreamCursor &Cursor = M->DeclsCursor;
SavedStreamPosition SavedPosition(Cursor);
Cursor.JumpToBit(LocalOffset);
RecordData Record;
unsigned Code = Cursor.ReadCode();
unsigned RecCode = Cursor.readRecord(Code, Record);
(void)RecCode;
assert(RecCode == LOCAL_REDECLARATIONS && "expected LOCAL_REDECLARATIONS record!");
// FIXME: We have several different dispatches on decl kind here; maybe
[modules] Avoid adding a redecl chain to the 'pending out of date' list as the very first step in updating it. llvm-svn: 230840
2015-02-28 13:57:02 +08:00
// we should instead generate one loop per kind and dispatch up-front?
[modules] Further simplification and speedup of redeclaration chain loading. Instead of eagerly deserializing a list of DeclIDs when we load a module file and doing a binary search to find the redeclarations of a decl, store a list of redeclarations of each chain before the first declaration and load it directly. llvm-svn: 245789
2015-08-23 04:13:39 +08:00
Decl *MostRecent = FirstLocal;
for (unsigned I = 0, N = Record.size(); I != N; ++I) {
auto *D = GetLocalDecl(*M, Record[N - I - 1]);
[modules] Switch to the normal reverse postorder visitation algorithm when computing redeclaration chains. llvm-svn: 242253
2015-07-15 08:02:40 +08:00
ASTDeclReader::attachPreviousDecl(*this, D, MostRecent, CanonDecl);
MostRecent = D;
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
}
[modules] Avoid adding a redecl chain to the 'pending out of date' list as the very first step in updating it. llvm-svn: 230840
2015-02-28 13:57:02 +08:00
ASTDeclReader::attachLatestDecl(CanonDecl, MostRecent);
Completely re-implement (de-)serialization of declaration chains. The previous implementation relied heavily on the declaration chain being stored as a (circular) linked list on disk, as it is in memory. However, when deserializing from multiple modules, the different chains could get mixed up, leading to broken declaration chains. The new solution keeps track of the first and last declarations in the chain for each module file. When we load a declaration, we search all of the module files for redeclarations of that declaration, then splice together all of the lists into a coherent whole (along with any redeclarations that were actually parsed). As a drive-by fix, (de-)serialize the redeclaration chains of TypedefNameDecls, which had somehow gotten missed previously. Add a test of this serialization. This new scheme creates a redeclaration table that is fairly large in the PCH file (on the order of 400k for Cocoa.h's 12MB PCH file). The table is mmap'd in and searched via a binary search, but it's still quite large. A future tweak will eliminate entries for declarations that have no redeclarations anywhere, and should drastically reduce the size of this table. llvm-svn: 146841
2011-12-18 07:38:30 +08:00
}
Support importing of ObjC categories from modules. The initial incentive was to fix a crash when PCH chaining categories to an interface, but the fix was done in the "modules way" that I hear is popular with the kids these days. Each module stores the local chain of categories and we combine them when the interface is loaded. We also warn if non-dependent modules introduce duplicate named categories. llvm-svn: 138926
2011-09-01 08:58:55 +08:00
namespace {
/// \brief Given an ObjC interface, goes through the modules and links to the
/// interface all the categories for it.
Reimplement (de-)serialization of Objective-C categories to eliminate the direct serialization of the linked-list structure. Instead, use a scheme similar to how we handle redeclarations, with redeclaration lists on the side. This addresses several issues: - In cases involving mixing and matching of many categories across many modules, the linked-list structure would not be consistent across different modules, and categories would get lost. - If a module is loaded after the class definition and its other categories have already been loaded, we wouldn't see any categories in the newly-loaded module. llvm-svn: 149112
2012-01-27 09:47:08 +08:00
class ObjCCategoriesVisitor {
Support importing of ObjC categories from modules. The initial incentive was to fix a crash when PCH chaining categories to an interface, but the fix was done in the "modules way" that I hear is popular with the kids these days. Each module stores the local chain of categories and we combine them when the interface is loaded. We also warn if non-dependent modules introduce duplicate named categories. llvm-svn: 138926
2011-09-01 08:58:55 +08:00
ASTReader &Reader;
serialization::GlobalDeclID InterfaceID;
ObjCInterfaceDecl *Interface;
Repace SmallPtrSet with SmallPtrSetImpl in function arguments to avoid needing to mention the size. llvm-svn: 215869
2014-08-18 07:49:53 +08:00
llvm::SmallPtrSetImpl<ObjCCategoryDecl *> &Deserialized;
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
unsigned PreviousGeneration;
ObjCCategoryDecl *Tail;
Support importing of ObjC categories from modules. The initial incentive was to fix a crash when PCH chaining categories to an interface, but the fix was done in the "modules way" that I hear is popular with the kids these days. Each module stores the local chain of categories and we combine them when the interface is loaded. We also warn if non-dependent modules introduce duplicate named categories. llvm-svn: 138926
2011-09-01 08:58:55 +08:00
llvm::DenseMap<DeclarationName, ObjCCategoryDecl *> NameCategoryMap;
Reimplement (de-)serialization of Objective-C categories to eliminate the direct serialization of the linked-list structure. Instead, use a scheme similar to how we handle redeclarations, with redeclaration lists on the side. This addresses several issues: - In cases involving mixing and matching of many categories across many modules, the linked-list structure would not be consistent across different modules, and categories would get lost. - If a module is loaded after the class definition and its other categories have already been loaded, we wouldn't see any categories in the newly-loaded module. llvm-svn: 149112
2012-01-27 09:47:08 +08:00
void add(ObjCCategoryDecl *Cat) {
// Only process each category once.
Reduce duplicated hash map lookups. llvm-svn: 162361
2012-08-22 23:37:55 +08:00
if (!Deserialized.erase(Cat))
Reimplement (de-)serialization of Objective-C categories to eliminate the direct serialization of the linked-list structure. Instead, use a scheme similar to how we handle redeclarations, with redeclaration lists on the side. This addresses several issues: - In cases involving mixing and matching of many categories across many modules, the linked-list structure would not be consistent across different modules, and categories would get lost. - If a module is loaded after the class definition and its other categories have already been loaded, we wouldn't see any categories in the newly-loaded module. llvm-svn: 149112
2012-01-27 09:47:08 +08:00
return;
// Check for duplicate categories.
if (Cat->getDeclName()) {
ObjCCategoryDecl *&Existing = NameCategoryMap[Cat->getDeclName()];
if (Existing &&
Reader.getOwningModuleFile(Existing)
!= Reader.getOwningModuleFile(Cat)) {
// FIXME: We should not warn for duplicates in diamond:
//
// MT //
// / \ //
// ML MR //
// \ / //
// MB //
//
// If there are duplicates in ML/MR, there will be warning when
// creating MB *and* when importing MB. We should not warn when
// importing.
Reader.Diag(Cat->getLocation(), diag::warn_dup_category_def)
<< Interface->getDeclName() << Cat->getDeclName();
Reader.Diag(Existing->getLocation(), diag::note_previous_definition);
} else if (!Existing) {
// Record this category.
Existing = Cat;
}
}
// Add this category to the end of the chain.
if (Tail)
ASTDeclReader::setNextObjCCategory(Tail, Cat);
else
Rework the traversal of Objective-C categories and extensions to consider (sub)module visibility. The bulk of this change replaces myriad hand-rolled loops over the linked list of Objective-C categories/extensions attached to an interface declaration with loops using one of the four new category iterator kinds: visible_categories_iterator: Iterates over all visible categories and extensions, hiding any that have their "hidden" bit set. This is by far the most commonly used iterator. known_categories_iterator: Iterates over all categories and extensions, ignoring the "hidden" bit. This tends to be used for redeclaration-like traversals. visible_extensions_iterator: Iterates over all visible extensions, hiding any that have their "hidden" bit set. known_extensions_iterator: Iterates over all extensions, whether they are visible to normal name lookup or not. The effect of this change is that any uses of the visible_ iterators will respect module-import visibility. See the new tests for examples. Note that the old accessors for categories and extensions are gone; there are *Raw() forms for some of them, for those (few) areas of the compiler that have to manipulate the linked list of categories directly. This is generally discouraged. Part two of <rdar://problem/10634711>. llvm-svn: 172665
2013-01-17 07:00:23 +08:00
Interface->setCategoryListRaw(Cat);
Reimplement (de-)serialization of Objective-C categories to eliminate the direct serialization of the linked-list structure. Instead, use a scheme similar to how we handle redeclarations, with redeclaration lists on the side. This addresses several issues: - In cases involving mixing and matching of many categories across many modules, the linked-list structure would not be consistent across different modules, and categories would get lost. - If a module is loaded after the class definition and its other categories have already been loaded, we wouldn't see any categories in the newly-loaded module. llvm-svn: 149112
2012-01-27 09:47:08 +08:00
Tail = Cat;
}
Support importing of ObjC categories from modules. The initial incentive was to fix a crash when PCH chaining categories to an interface, but the fix was done in the "modules way" that I hear is popular with the kids these days. Each module stores the local chain of categories and we combine them when the interface is loaded. We also warn if non-dependent modules introduce duplicate named categories. llvm-svn: 138926
2011-09-01 08:58:55 +08:00
public:
Reimplement (de-)serialization of Objective-C categories to eliminate the direct serialization of the linked-list structure. Instead, use a scheme similar to how we handle redeclarations, with redeclaration lists on the side. This addresses several issues: - In cases involving mixing and matching of many categories across many modules, the linked-list structure would not be consistent across different modules, and categories would get lost. - If a module is loaded after the class definition and its other categories have already been loaded, we wouldn't see any categories in the newly-loaded module. llvm-svn: 149112
2012-01-27 09:47:08 +08:00
ObjCCategoriesVisitor(ASTReader &Reader,
serialization::GlobalDeclID InterfaceID,
ObjCInterfaceDecl *Interface,
Repace SmallPtrSet with SmallPtrSetImpl in function arguments to avoid needing to mention the size. llvm-svn: 215869
2014-08-18 07:49:53 +08:00
llvm::SmallPtrSetImpl<ObjCCategoryDecl *> &Deserialized,
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
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),
[C++11] Use 'nullptr'. Serialization edition. llvm-svn: 209392
2014-05-22 13:54:18 +08:00
Tail(nullptr)
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
{
// Populate the name -> category map with the set of known categories.
[C++11] Replacing ObjCInterfaceDecl iterators known_categories_begin() and known_categories_end() with iterator_range known_categories(). Updating all of the usages of the iterators with range-based for loops. llvm-svn: 203854
2014-03-14 05:35:02 +08:00
for (auto *Cat : Interface->known_categories()) {
Reimplement (de-)serialization of Objective-C categories to eliminate the direct serialization of the linked-list structure. Instead, use a scheme similar to how we handle redeclarations, with redeclaration lists on the side. This addresses several issues: - In cases involving mixing and matching of many categories across many modules, the linked-list structure would not be consistent across different modules, and categories would get lost. - If a module is loaded after the class definition and its other categories have already been loaded, we wouldn't see any categories in the newly-loaded module. llvm-svn: 149112
2012-01-27 09:47:08 +08:00
if (Cat->getDeclName())
[C++11] Replacing ObjCInterfaceDecl iterators known_categories_begin() and known_categories_end() with iterator_range known_categories(). Updating all of the usages of the iterators with range-based for loops. llvm-svn: 203854
2014-03-14 05:35:02 +08:00
NameCategoryMap[Cat->getDeclName()] = Cat;
Reimplement (de-)serialization of Objective-C categories to eliminate the direct serialization of the linked-list structure. Instead, use a scheme similar to how we handle redeclarations, with redeclaration lists on the side. This addresses several issues: - In cases involving mixing and matching of many categories across many modules, the linked-list structure would not be consistent across different modules, and categories would get lost. - If a module is loaded after the class definition and its other categories have already been loaded, we wouldn't see any categories in the newly-loaded module. llvm-svn: 149112
2012-01-27 09:47:08 +08:00
// Keep track of the tail of the category list.
[C++11] Replacing ObjCInterfaceDecl iterators known_categories_begin() and known_categories_end() with iterator_range known_categories(). Updating all of the usages of the iterators with range-based for loops. llvm-svn: 203854
2014-03-14 05:35:02 +08:00
Tail = Cat;
Reimplement (de-)serialization of Objective-C categories to eliminate the direct serialization of the linked-list structure. Instead, use a scheme similar to how we handle redeclarations, with redeclaration lists on the side. This addresses several issues: - In cases involving mixing and matching of many categories across many modules, the linked-list structure would not be consistent across different modules, and categories would get lost. - If a module is loaded after the class definition and its other categories have already been loaded, we wouldn't see any categories in the newly-loaded module. llvm-svn: 149112
2012-01-27 09:47:08 +08:00
}
}
Support importing of ObjC categories from modules. The initial incentive was to fix a crash when PCH chaining categories to an interface, but the fix was done in the "modules way" that I hear is popular with the kids these days. Each module stores the local chain of categories and we combine them when the interface is loaded. We also warn if non-dependent modules introduce duplicate named categories. llvm-svn: 138926
2011-09-01 08:58:55 +08:00
[Modules] Wrap the main ModuleManager visitor in a function_ref. Avoids the awkward passing of an opaque void *UserData argument. No functional change intended. llvm-svn: 243213
2015-07-25 20:14:04 +08:00
bool operator()(ModuleFile &M) {
Reimplement (de-)serialization of Objective-C categories to eliminate the direct serialization of the linked-list structure. Instead, use a scheme similar to how we handle redeclarations, with redeclaration lists on the side. This addresses several issues: - In cases involving mixing and matching of many categories across many modules, the linked-list structure would not be consistent across different modules, and categories would get lost. - If a module is loaded after the class definition and its other categories have already been loaded, we wouldn't see any categories in the newly-loaded module. llvm-svn: 149112
2012-01-27 09:47:08 +08:00
// If we've loaded all of the category information we care about from
// this module file, we're done.
if (M.Generation <= PreviousGeneration)
return true;
// Map global ID of the definition down to the local ID used in this
// module file. If there is no such mapping, we'll find nothing here
// (or in any module it imports).
DeclID LocalID = Reader.mapGlobalIDToModuleFileGlobalID(M, InterfaceID);
if (!LocalID)
return true;
Support importing of ObjC categories from modules. The initial incentive was to fix a crash when PCH chaining categories to an interface, but the fix was done in the "modules way" that I hear is popular with the kids these days. Each module stores the local chain of categories and we combine them when the interface is loaded. We also warn if non-dependent modules introduce duplicate named categories. llvm-svn: 138926
2011-09-01 08:58:55 +08:00
Reimplement (de-)serialization of Objective-C categories to eliminate the direct serialization of the linked-list structure. Instead, use a scheme similar to how we handle redeclarations, with redeclaration lists on the side. This addresses several issues: - In cases involving mixing and matching of many categories across many modules, the linked-list structure would not be consistent across different modules, and categories would get lost. - If a module is loaded after the class definition and its other categories have already been loaded, we wouldn't see any categories in the newly-loaded module. llvm-svn: 149112
2012-01-27 09:47:08 +08:00
// Perform a binary search to find the local redeclarations for this
// declaration (if any).
Serialization: Directly compare objects instead of using a functor duplicating the compare operators. No functionality change. llvm-svn: 204006
2014-03-15 22:21:58 +08:00
const ObjCCategoriesInfo Compare = { LocalID, 0 };
Reimplement (de-)serialization of Objective-C categories to eliminate the direct serialization of the linked-list structure. Instead, use a scheme similar to how we handle redeclarations, with redeclaration lists on the side. This addresses several issues: - In cases involving mixing and matching of many categories across many modules, the linked-list structure would not be consistent across different modules, and categories would get lost. - If a module is loaded after the class definition and its other categories have already been loaded, we wouldn't see any categories in the newly-loaded module. llvm-svn: 149112
2012-01-27 09:47:08 +08:00
const ObjCCategoriesInfo *Result
= std::lower_bound(M.ObjCCategoriesMap,
M.ObjCCategoriesMap + M.LocalNumObjCCategoriesInMap,
Serialization: Directly compare objects instead of using a functor duplicating the compare operators. No functionality change. llvm-svn: 204006
2014-03-15 22:21:58 +08:00
Compare);
Reimplement (de-)serialization of Objective-C categories to eliminate the direct serialization of the linked-list structure. Instead, use a scheme similar to how we handle redeclarations, with redeclaration lists on the side. This addresses several issues: - In cases involving mixing and matching of many categories across many modules, the linked-list structure would not be consistent across different modules, and categories would get lost. - If a module is loaded after the class definition and its other categories have already been loaded, we wouldn't see any categories in the newly-loaded module. llvm-svn: 149112
2012-01-27 09:47:08 +08:00
if (Result == M.ObjCCategoriesMap + M.LocalNumObjCCategoriesInMap ||
Result->DefinitionID != LocalID) {
// We didn't find anything. If the class definition is in this module
// file, then the module files it depends on cannot have any categories,
// so suppress further lookup.
return Reader.isDeclIDFromModule(InterfaceID, M);
Support importing of ObjC categories from modules. The initial incentive was to fix a crash when PCH chaining categories to an interface, but the fix was done in the "modules way" that I hear is popular with the kids these days. Each module stores the local chain of categories and we combine them when the interface is loaded. We also warn if non-dependent modules introduce duplicate named categories. llvm-svn: 138926
2011-09-01 08:58:55 +08:00
}
Reimplement (de-)serialization of Objective-C categories to eliminate the direct serialization of the linked-list structure. Instead, use a scheme similar to how we handle redeclarations, with redeclaration lists on the side. This addresses several issues: - In cases involving mixing and matching of many categories across many modules, the linked-list structure would not be consistent across different modules, and categories would get lost. - If a module is loaded after the class definition and its other categories have already been loaded, we wouldn't see any categories in the newly-loaded module. llvm-svn: 149112
2012-01-27 09:47:08 +08:00
// We found something. Dig out all of the categories.
unsigned Offset = Result->Offset;
unsigned N = M.ObjCCategories[Offset];
M.ObjCCategories[Offset++] = 0; // Don't try to deserialize again
for (unsigned I = 0; I != N; ++I)
add(cast_or_null<ObjCCategoryDecl>(
Reader.GetLocalDecl(M, M.ObjCCategories[Offset++])));
return true;
Support importing of ObjC categories from modules. The initial incentive was to fix a crash when PCH chaining categories to an interface, but the fix was done in the "modules way" that I hear is popular with the kids these days. Each module stores the local chain of categories and we combine them when the interface is loaded. We also warn if non-dependent modules introduce duplicate named categories. llvm-svn: 138926
2011-09-01 08:58:55 +08:00
}
};
Fix Clang-tidy modernize-use-nullptr warnings in source directories; other minor cleanups Patch by Eugene Zelenko! Differential Revision: http://reviews.llvm.org/D13406 llvm-svn: 249484
2015-10-07 07:40:43 +08:00
} // end anonymous namespace
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);
[Modules] Wrap the main ModuleManager visitor in a function_ref. Avoids the awkward passing of an opaque void *UserData argument. No functional change intended. llvm-svn: 243213
2015-07-25 20:14:04 +08:00
ModuleMgr.visit(Visitor);
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
[modules] Don't defer performing updates if we have incomplete redecl chains. Instead, perform them carefully immediately. llvm-svn: 215147
2014-08-08 04:58:41 +08:00
template<typename DeclT, typename Fn>
static void forAllLaterRedecls(DeclT *D, Fn F) {
F(D);
// Check whether we've already merged D into its redeclaration chain.
// MostRecent may or may not be nullptr if D has not been merged. If
// not, walk the merged redecl chain and see if it's there.
auto *MostRecent = D->getMostRecentDecl();
bool Found = false;
for (auto *Redecl = MostRecent; Redecl && !Found;
Redecl = Redecl->getPreviousDecl())
Found = (Redecl == D);
// If this declaration is merged, apply the functor to all later decls.
if (Found) {
for (auto *Redecl = MostRecent; Redecl != D;
Redecl = Redecl->getPreviousDecl())
F(Redecl);
}
}
Promote ModuleMap::Module to a namespace-scope class in the Basic library, since modules cut across all of the libraries. Rename serialization::Module to serialization::ModuleFile to side-step the annoying naming conflict. Prune a bunch of ModuleMap.h includes that are no longer needed (most files only needed the Module type). llvm-svn: 145538
2011-12-01 07:21:26 +08:00
void ASTDeclReader::UpdateDecl(Decl *D, ModuleFile &ModuleFile,
Add a decl update when a static data member of a class template is instantiated in a different PCH than its containing class. Otherwise we get double definition errors. Fixes a Boost.MPL problem that affects Boost.Accumulators and probably a lot more of Boost. llvm-svn: 130488
2011-04-29 16:19:30 +08:00
const RecordData &Record) {
Start fleshing out ASTMutationListener; notify when a tag definition is completed. In that case a chained PCH will record the updates to the DefinitionData pointer of forward references. If a forward reference mutated into a definition re-write it into the chained PCH, this is too big of a change. llvm-svn: 117239
2010-10-25 01:26:50 +08:00
while (Idx < Record.size()) {
switch ((DeclUpdateKind)Record[Idx++]) {
When a module completes the definition of a class template specialization imported from another module, emit an update record, rather than using the broken decl rewriting mechanism. If multiple modules do this, merge the definitions together, much as we would if they were separate declarations. llvm-svn: 206680
2014-04-19 11:48:30 +08:00
case UPD_CXX_ADDED_IMPLICIT_MEMBER: {
[modules] If we add an implicit special member to a class through an update record, and that class declaration is not the canonical definition of the class, be sure to add the class to the list of classes that are consulted when we look up a special member in the canonical definition. llvm-svn: 226778
2015-01-22 11:50:31 +08:00
auto *RD = cast<CXXRecordDecl>(D);
[modules] Don't defer performing updates if we have incomplete redecl chains. Instead, perform them carefully immediately. llvm-svn: 215147
2014-08-08 04:58:41 +08:00
// FIXME: If we also have an update record for instantiating the
// definition of D, we need that to happen before we get here.
When a module completes the definition of a class template specialization imported from another module, emit an update record, rather than using the broken decl rewriting mechanism. If multiple modules do this, merge the definitions together, much as we would if they were separate declarations. llvm-svn: 206680
2014-04-19 11:48:30 +08:00
Decl *MD = Reader.ReadDecl(ModuleFile, Record, Idx);
assert(MD && "couldn't read decl from update record");
[modules] Remove IRGen special case for emitting implicit special members if they're somehow missing a body. Looks like this was left behind when the loop was generalized, and it's not been problematic before because without modules, a used, implicit special member function declaration must be a definition. This was resulting in us trying to emit a constructor declaration rather than a definition, and producing a constructor missing its member initializers. llvm-svn: 214473
2014-08-01 09:56:39 +08:00
// FIXME: We should call addHiddenDecl instead, to add the member
// to its DeclContext.
[modules] If we add an implicit special member to a class through an update record, and that class declaration is not the canonical definition of the class, be sure to add the class to the list of classes that are consulted when we look up a special member in the canonical definition. llvm-svn: 226778
2015-01-22 11:50:31 +08:00
RD->addedMember(MD);
Keep track in chained PCH of implicit members that were added after the definition was completed. llvm-svn: 117240
2010-10-25 01:26:54 +08:00
break;
When a module completes the definition of a class template specialization imported from another module, emit an update record, rather than using the broken decl rewriting mechanism. If multiple modules do this, merge the definitions together, much as we would if they were separate declarations. llvm-svn: 206680
2014-04-19 11:48:30 +08:00
}
Use the ASTMutationListener to track added template specializations in a chained PCH. llvm-svn: 117533
2010-10-28 15:38:42 +08:00
case UPD_CXX_ADDED_TEMPLATE_SPECIALIZATION:
// It will be added to the template's specializations set when loaded.
Promote ModuleMap::Module to a namespace-scope class in the Basic library, since modules cut across all of the libraries. Rename serialization::Module to serialization::ModuleFile to side-step the annoying naming conflict. Prune a bunch of ModuleMap.h includes that are no longer needed (most files only needed the Module type). llvm-svn: 145538
2011-12-01 07:21:26 +08:00
(void)Reader.ReadDecl(ModuleFile, Record, Idx);
Fix adding an anonymous namespace in a chained PCH to a namespace from a previous PCH. Fix anonymous namespaces in PCH. llvm-svn: 130104
2011-04-25 00:28:13 +08:00
break;
case UPD_CXX_ADDED_ANONYMOUS_NAMESPACE: {
Introduce the local -> global declaration ID mapping into the AST reader, to allow AST files to be loaded with their declarations remapped to different ID numbers. Fix a number of places where we were either failing to map local declaration IDs into global declaration IDs or where interpreting the local declaration IDs within the wrong module. I've tested this via the usual "random gaps" method. It works well except for the preamble tests, because our handling of the precompiled preamble requires declaration and preprocessed entity to be stable when parsing code and then loading that back into memory. This property will hold in general, but my randomized testing naturally breaks this property to get more coverage. In the future, I expect that the precompiled preamble logic won't need this property. I am very unhappy with the current handling of the translation unit, which is a rather egregious hack. We're going to have to do something very different here for loading multiple AST files, because we don't want to have to cope with merging two translation units. Likely, we'll just handle translation units entirely via "update" records, and predefine a single, fixed declaration ID for the translation unit. That will come later. llvm-svn: 136779
2011-08-03 23:48:04 +08:00
NamespaceDecl *Anon
Promote ModuleMap::Module to a namespace-scope class in the Basic library, since modules cut across all of the libraries. Rename serialization::Module to serialization::ModuleFile to side-step the annoying naming conflict. Prune a bunch of ModuleMap.h includes that are no longer needed (most files only needed the Module type). llvm-svn: 145538
2011-12-01 07:21:26 +08:00
= Reader.ReadDeclAs<NamespaceDecl>(ModuleFile, Record, Idx);
When deserializing an anonymous namespace from a module, do not attach the anonymous namespace to its parent. Semantically, this means that the anonymous namespaces defined in one module are distinct from the anonymous namespaces defined in another module. llvm-svn: 147782
2012-01-10 02:07:24 +08:00
// Each module has its own anonymous namespace, which is disjoint from
// any other module's anonymous namespaces, so don't attach the anonymous
// namespace at all.
[modules] Initial support for explicitly loading .pcm files. Implicit module builds are not well-suited to a lot of build systems. In particular, they fare badly in distributed build systems, and they lead to build artifacts that are not tracked as part of the usual dependency management process. This change allows explicitly-built module files (which are already supported through the -emit-module flag) to be explicitly loaded into a build, allowing build systems to opt to manage module builds and dependencies themselves. This is only the first step in supporting such configurations, and it should be considered experimental and subject to change or removal for now. llvm-svn: 220359
2014-10-22 10:05:46 +08:00
if (ModuleFile.Kind != MK_ImplicitModule &&
ModuleFile.Kind != MK_ExplicitModule) {
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
if (TranslationUnitDecl *TU = dyn_cast<TranslationUnitDecl>(D))
TU->setAnonymousNamespace(Anon);
else
cast<NamespaceDecl>(D)->setAnonymousNamespace(Anon);
}
Fix adding an anonymous namespace in a chained PCH to a namespace from a previous PCH. Fix anonymous namespaces in PCH. llvm-svn: 130104
2011-04-25 00:28:13 +08:00
break;
}
Add a decl update when a static data member of a class template is instantiated in a different PCH than its containing class. Otherwise we get double definition errors. Fixes a Boost.MPL problem that affects Boost.Accumulators and probably a lot more of Boost. llvm-svn: 130488
2011-04-29 16:19:30 +08:00
case UPD_CXX_INSTANTIATED_STATIC_DATA_MEMBER:
cast<VarDecl>(D)->getMemberSpecializationInfo()->setPointOfInstantiation(
Promote ModuleMap::Module to a namespace-scope class in the Basic library, since modules cut across all of the libraries. Rename serialization::Module to serialization::ModuleFile to side-step the annoying naming conflict. Prune a bunch of ModuleMap.h includes that are no longer needed (most files only needed the Module type). llvm-svn: 145538
2011-12-01 07:21:26 +08:00
Reader.ReadSourceLocation(ModuleFile, Record, Idx));
Add a decl update when a static data member of a class template is instantiated in a different PCH than its containing class. Otherwise we get double definition errors. Fixes a Boost.MPL problem that affects Boost.Accumulators and probably a lot more of Boost. llvm-svn: 130488
2011-04-29 16:19:30 +08:00
break;
C++1y deduced return types: when we deduce a return type for a function which we loaded from PCH, if we're building another PCH, create an update record to patch the return type of the earlier declaration. llvm-svn: 181659
2013-05-11 13:45:24 +08:00
Only instantiate a default argument once. By storing the instantiated expression back in the ParmVarDecl, we remove the last need for separately storing the sub-expression of a CXXDefaultArgExpr. This makes PCH/Modules merging quite simple: CXXDefaultArgExpr records are serialized as references to the ParmVarDecl, and we ignore redundant attempts to overwrite the instantiated expression. This has some extremely marginal impact on user-facing semantics. However, the major effect is that it avoids IRGen errors about conflicting definitions due to lambdas in the argument being instantiated multiple times while sharing the same mangling. It should also slightly improve memory usage and module file size. rdar://23810407 llvm-svn: 256983
2016-01-07 06:34:54 +08:00
case UPD_CXX_INSTANTIATED_DEFAULT_ARGUMENT: {
auto Param = cast<ParmVarDecl>(D);
// We have to read the default argument regardless of whether we use it
// so that hypothetical further update records aren't messed up.
// TODO: Add a function to skip over the next expr record.
auto DefaultArg = Reader.ReadExpr(F);
// Only apply the update if the parameter still has an uninstantiated
// default argument.
if (Param->hasUninstantiatedDefaultArg())
Param->setDefaultArg(DefaultArg);
break;
}
[modules] When emitting an update record containing the body of a destructor, also emit the updated 'operator delete' looked up for that destructor. Switch from UpdateDecl to an actual update record when this happens due to implicitly defining a special member function and unify this code path and the one for instantiating a function definition. llvm-svn: 215132
2014-08-08 02:53:08 +08:00
case UPD_CXX_ADDED_FUNCTION_DEFINITION: {
Emit an update record if we instantiate the definition of a function template specialization from a module. (This can also happen for function template specializations in PCHs if they're instantiated eagerly, because they're constexpr or have a deduced return type.) llvm-svn: 204547
2014-03-23 07:33:22 +08:00
FunctionDecl *FD = cast<FunctionDecl>(D);
When a module completes the definition of a class template specialization imported from another module, emit an update record, rather than using the broken decl rewriting mechanism. If multiple modules do this, merge the definitions together, much as we would if they were separate declarations. llvm-svn: 206680
2014-04-19 11:48:30 +08:00
if (Reader.PendingBodies[FD]) {
Emit an update record if we instantiate the definition of a function template specialization from a module. (This can also happen for function template specializations in PCHs if they're instantiated eagerly, because they're constexpr or have a deduced return type.) llvm-svn: 204547
2014-03-23 07:33:22 +08:00
// FIXME: Maybe check for ODR violations.
When a module completes the definition of a class template specialization imported from another module, emit an update record, rather than using the broken decl rewriting mechanism. If multiple modules do this, merge the definitions together, much as we would if they were separate declarations. llvm-svn: 206680
2014-04-19 11:48:30 +08:00
// It's safe to stop now because this update record is always last.
return;
}
Emit an update record if we instantiate the definition of a function template specialization from a module. (This can also happen for function template specializations in PCHs if they're instantiated eagerly, because they're constexpr or have a deduced return type.) llvm-svn: 204547
2014-03-23 07:33:22 +08:00
When merging functions across modules (and in particular, instantiations of member functions), ensure that the redecl chain never transitions from 'inline' to 'not inline', since that violates an AST invariant. llvm-svn: 209794
2014-05-29 11:15:31 +08:00
if (Record[Idx++]) {
// Maintain AST consistency: any later redeclarations of this function
// are inline if this one is. (We might have merged another declaration
// into this one.)
[modules] Don't defer performing updates if we have incomplete redecl chains. Instead, perform them carefully immediately. llvm-svn: 215147
2014-08-08 04:58:41 +08:00
forAllLaterRedecls(FD, [](FunctionDecl *FD) {
FD->setImplicitlyInline();
});
When merging functions across modules (and in particular, instantiations of member functions), ensure that the redecl chain never transitions from 'inline' to 'not inline', since that violates an AST invariant. llvm-svn: 209794
2014-05-29 11:15:31 +08:00
}
Emit an update record if we instantiate the definition of a function template specialization from a module. (This can also happen for function template specializations in PCHs if they're instantiated eagerly, because they're constexpr or have a deduced return type.) llvm-svn: 204547
2014-03-23 07:33:22 +08:00
FD->setInnerLocStart(Reader.ReadSourceLocation(ModuleFile, Record, Idx));
[modules] Deserialize CXXCtorInitializer list for a constructor lazily. Previously we'd deserialize the list of mem-initializers for a constructor when we deserialized the declaration of the constructor. That could trigger a significant amount of unnecessary work (pulling in all base classes recursively, for a start) and was causing problems for the modules buildbot due to cyclic deserializations. We now deserialize these on demand. This creates a certain amount of duplication with the handling of CXXBaseSpecifiers; I'll look into reducing that next. llvm-svn: 233052
2015-03-24 14:36:48 +08:00
if (auto *CD = dyn_cast<CXXConstructorDecl>(FD)) {
CD->NumCtorInitializers = Record[Idx++];
if (CD->NumCtorInitializers)
CD->CtorInitializers =
Reader.ReadCXXCtorInitializersRef(F, Record, Idx);
}
Emit an update record if we instantiate the definition of a function template specialization from a module. (This can also happen for function template specializations in PCHs if they're instantiated eagerly, because they're constexpr or have a deduced return type.) llvm-svn: 204547
2014-03-23 07:33:22 +08:00
// Store the offset of the body so we can lazily load it later.
Reader.PendingBodies[FD] = GetCurrentCursorOffset();
If an update record makes a declaration interesting, pass it to the consumer. llvm-svn: 204550
2014-03-23 08:27:18 +08:00
HasPendingBody = true;
Emit an update record if we instantiate the definition of a function template specialization from a module. (This can also happen for function template specializations in PCHs if they're instantiated eagerly, because they're constexpr or have a deduced return type.) llvm-svn: 204547
2014-03-23 07:33:22 +08:00
assert(Idx == Record.size() && "lazy body must be last");
break;
}
When a module completes the definition of a class template specialization imported from another module, emit an update record, rather than using the broken decl rewriting mechanism. If multiple modules do this, merge the definitions together, much as we would if they were separate declarations. llvm-svn: 206680
2014-04-19 11:48:30 +08:00
case UPD_CXX_INSTANTIATED_CLASS_DEFINITION: {
auto *RD = cast<CXXRecordDecl>(D);
[modules] Be sure to load the lexical definition of a class template specialization from an update record exactly once, even if we needed to fake up the definition. llvm-svn: 227939
2015-02-03 11:32:14 +08:00
auto *OldDD = RD->DefinitionData.getNotUpdated();
bool HadRealDefinition =
[modules] If we already have a fake definition for one declaration of a class, don't think we're providing a new one in an update record adding a definition to another declaration of the same class. llvm-svn: 228104
2015-02-04 09:23:46 +08:00
OldDD && (OldDD->Definition != RD ||
!Reader.PendingFakeDefinitionData.count(OldDD));
[modules] Be sure to load the lexical definition of a class template specialization from an update record exactly once, even if we needed to fake up the definition. llvm-svn: 227939
2015-02-03 11:32:14 +08:00
ReadCXXRecordDefinition(RD, /*Update*/true);
When a module completes the definition of a class template specialization imported from another module, emit an update record, rather than using the broken decl rewriting mechanism. If multiple modules do this, merge the definitions together, much as we would if they were separate declarations. llvm-svn: 206680
2014-04-19 11:48:30 +08:00
// Visible update is handled separately.
uint64_t LexicalOffset = Record[Idx++];
[modules] Sometimes we can deserialize a class member but not have yet encountered any definition for the class; this happens when the definition is added by an update record that is not yet loaded. In such a case, eagerly pick the original parent of the member as the canonical definition of the class rather than muddling through with the canonical declaration (the latter can lead to us failing to merge properly later if the canonical definition turns out to be some other declaration). llvm-svn: 226977
2015-01-24 09:07:20 +08:00
if (!HadRealDefinition && LexicalOffset) {
[modules] Defer setting up the lookup table for a DeclContext until we can determine the primary context, rather than sometimes registering the lookup table on the wrong context. This exposed a couple of bugs: * the odr violation check didn't deal properly with mergeable declarations if the declaration retained by name lookup wasn't in the canonical definition of the class * the (broken) RewriteDecl mechanism would emit two name lookup tables for the same DeclContext into the same module file (one as part of the rewritten declaration and one as a visible update for the old declaration) These are both fixed too. llvm-svn: 244192
2015-08-06 12:23:48 +08:00
Reader.ReadLexicalDeclContextStorage(ModuleFile, ModuleFile.DeclsCursor,
LexicalOffset, RD);
[modules] Be sure to load the lexical definition of a class template specialization from an update record exactly once, even if we needed to fake up the definition. llvm-svn: 227939
2015-02-03 11:32:14 +08:00
Reader.PendingFakeDefinitionData.erase(OldDD);
When a module completes the definition of a class template specialization imported from another module, emit an update record, rather than using the broken decl rewriting mechanism. If multiple modules do this, merge the definitions together, much as we would if they were separate declarations. llvm-svn: 206680
2014-04-19 11:48:30 +08:00
}
auto TSK = (TemplateSpecializationKind)Record[Idx++];
SourceLocation POI = Reader.ReadSourceLocation(ModuleFile, Record, Idx);
if (MemberSpecializationInfo *MSInfo =
RD->getMemberSpecializationInfo()) {
MSInfo->setTemplateSpecializationKind(TSK);
MSInfo->setPointOfInstantiation(POI);
} else {
ClassTemplateSpecializationDecl *Spec =
cast<ClassTemplateSpecializationDecl>(RD);
Spec->setTemplateSpecializationKind(TSK);
Spec->setPointOfInstantiation(POI);
If a class template specialization from one module has its definition instantiated in another module, and the instantiation uses a partial specialization, include the partial specialization and its template arguments in the update record. We'll need them if someone imports the second module and tries to instantiate a member of the template. llvm-svn: 209472
2014-05-23 04:59:29 +08:00
if (Record[Idx++]) {
auto PartialSpec =
ReadDeclAs<ClassTemplatePartialSpecializationDecl>(Record, Idx);
SmallVector<TemplateArgument, 8> TemplArgs;
Reader.ReadTemplateArgumentList(TemplArgs, F, Record, Idx);
auto *TemplArgList = TemplateArgumentList::CreateCopy(
Reader.getContext(), TemplArgs.data(), TemplArgs.size());
[modules] Don't assert if the same imported class template specialization declaration has its definition instantiated in two sibling modules and they use a partial specialization. llvm-svn: 215616
2014-08-14 11:30:27 +08:00
// FIXME: If we already have a partial specialization set,
// check that it matches.
if (!Spec->getSpecializedTemplateOrPartial()
.is<ClassTemplatePartialSpecializationDecl *>())
Spec->setInstantiationOf(PartialSpec, TemplArgList);
If a class template specialization from one module has its definition instantiated in another module, and the instantiation uses a partial specialization, include the partial specialization and its template arguments in the update record. We'll need them if someone imports the second module and tries to instantiate a member of the template. llvm-svn: 209472
2014-05-23 04:59:29 +08:00
}
When a module completes the definition of a class template specialization imported from another module, emit an update record, rather than using the broken decl rewriting mechanism. If multiple modules do this, merge the definitions together, much as we would if they were separate declarations. llvm-svn: 206680
2014-04-19 11:48:30 +08:00
}
RD->setTagKind((TagTypeKind)Record[Idx++]);
RD->setLocation(Reader.ReadSourceLocation(ModuleFile, Record, Idx));
RD->setLocStart(Reader.ReadSourceLocation(ModuleFile, Record, Idx));
RD->setRBraceLoc(Reader.ReadSourceLocation(ModuleFile, Record, Idx));
if (Record[Idx++]) {
AttrVec Attrs;
Reader.ReadAttributes(F, Attrs, Record, Idx);
D->setAttrsImpl(Attrs, Reader.getContext());
}
break;
}
[modules] Don't clobber a destructor's operator delete when adding another one; move the operator delete updating into a separate update record so we can cope with updating another module's destructor's operator delete. llvm-svn: 231735
2015-03-10 09:41:22 +08:00
case UPD_CXX_RESOLVED_DTOR_DELETE: {
// Set the 'operator delete' directly to avoid emitting another update
// record.
auto *Del = Reader.ReadDeclAs<FunctionDecl>(ModuleFile, Record, Idx);
auto *First = cast<CXXDestructorDecl>(D->getCanonicalDecl());
// FIXME: Check consistency if we have an old and new operator delete.
if (!First->OperatorDelete)
First->OperatorDelete = Del;
break;
}
When the exception specification for a function in an imported PCH or module is resolved, emit an update record. llvm-svn: 204403
2014-03-21 05:47:22 +08:00
case UPD_CXX_RESOLVED_EXCEPTION_SPEC: {
Factor out exception specification information from FunctionProtoType::ExtProtoInfo. Most of the users of these fields don't care about the other ExtProtoInfo bits and just want to talk about the exception specification. llvm-svn: 214450
2014-08-01 05:57:55 +08:00
FunctionProtoType::ExceptionSpecInfo ESI;
[modules] Maintain an AST invariant across module load/save: if any declaration of a function has a resolved exception specification, then all declarations of the function do. We should probably improve the AST representation to make this implicit (perhaps only store the exception specification on the canonical declaration), but this fixes things for now. The testcase for this (which used to assert) also exposes the actual bug I was trying to reduce here: we sometimes fail to emit the body of an imported special member function definition. Fix for that to follow. llvm-svn: 214458
2014-08-01 07:46:44 +08:00
SmallVector<QualType, 8> ExceptionStorage;
Factor out exception specification information from FunctionProtoType::ExtProtoInfo. Most of the users of these fields don't care about the other ExtProtoInfo bits and just want to talk about the exception specification. llvm-svn: 214450
2014-08-01 05:57:55 +08:00
Reader.readExceptionSpec(ModuleFile, ExceptionStorage, ESI, Record, Idx);
[modules] Remove redundant import of lexical decls when building a lookup table for a DeclContext, and fix propagation of exception specifications along redeclaration chains. This reverts r232905, r232907, and r232907, which reverted r232793, r232853, and r232853. One additional change is present here to resolve issues with LLDB: distinguish between whether lexical decls missing from the lookup table are local or are provided by the external AST source, and still look in the external source if that's where they came from. llvm-svn: 232928
2015-03-23 11:25:59 +08:00
// Update this declaration's exception specification, if needed.
auto *FD = cast<FunctionDecl>(D);
auto *FPT = FD->getType()->castAs<FunctionProtoType>();
// FIXME: If the exception specification is already present, check that it
// matches.
if (isUnresolvedExceptionSpec(FPT->getExceptionSpecType())) {
[modules] Maintain an AST invariant across module load/save: if any declaration of a function has a resolved exception specification, then all declarations of the function do. We should probably improve the AST representation to make this implicit (perhaps only store the exception specification on the canonical declaration), but this fixes things for now. The testcase for this (which used to assert) also exposes the actual bug I was trying to reduce here: we sometimes fail to emit the body of an imported special member function definition. Fix for that to follow. llvm-svn: 214458
2014-08-01 07:46:44 +08:00
FD->setType(Reader.Context.getFunctionType(
FPT->getReturnType(), FPT->getParamTypes(),
FPT->getExtProtoInfo().withExceptionSpec(ESI)));
[modules] Remove redundant import of lexical decls when building a lookup table for a DeclContext, and fix propagation of exception specifications along redeclaration chains. This reverts r232905, r232907, and r232907, which reverted r232793, r232853, and r232853. One additional change is present here to resolve issues with LLDB: distinguish between whether lexical decls missing from the lookup table are local or are provided by the external AST source, and still look in the external source if that's where they came from. llvm-svn: 232928
2015-03-23 11:25:59 +08:00
// When we get to the end of deserializing, see if there are other decls
// that we need to propagate this exception specification onto.
Reader.PendingExceptionSpecUpdates.insert(
std::make_pair(FD->getCanonicalDecl(), FD));
[modules] Maintain an AST invariant across module load/save: if any declaration of a function has a resolved exception specification, then all declarations of the function do. We should probably improve the AST representation to make this implicit (perhaps only store the exception specification on the canonical declaration), but this fixes things for now. The testcase for this (which used to assert) also exposes the actual bug I was trying to reduce here: we sometimes fail to emit the body of an imported special member function definition. Fix for that to follow. llvm-svn: 214458
2014-08-01 07:46:44 +08:00
}
When the exception specification for a function in an imported PCH or module is resolved, emit an update record. llvm-svn: 204403
2014-03-21 05:47:22 +08:00
break;
}
C++1y deduced return types: when we deduce a return type for a function which we loaded from PCH, if we're building another PCH, create an update record to patch the return type of the earlier declaration. llvm-svn: 181659
2013-05-11 13:45:24 +08:00
case UPD_CXX_DEDUCED_RETURN_TYPE: {
[modules] Don't defer performing updates if we have incomplete redecl chains. Instead, perform them carefully immediately. llvm-svn: 215147
2014-08-08 04:58:41 +08:00
// FIXME: Also do this when merging redecls.
QualType DeducedResultType = Reader.readType(ModuleFile, Record, Idx);
for (auto *Redecl : merged_redecls(D)) {
// FIXME: If the return type is already deduced, check that it matches.
FunctionDecl *FD = cast<FunctionDecl>(Redecl);
Reader.Context.adjustDeducedFunctionResultType(FD, DeducedResultType);
}
C++1y deduced return types: when we deduce a return type for a function which we loaded from PCH, if we're building another PCH, create an update record to patch the return type of the earlier declaration. llvm-svn: 181659
2013-05-11 13:45:24 +08:00
break;
}
Note when a decl is used in AST files. When an AST file is built based on another AST file, it can use a decl from the fist file, and therefore mark the "isUsed" bit. We need to note this in the AST file so that the bit is set correctly when the second AST file is loaded. This patch introduces the distinction between setIsUsed() and markUsed() so that we don't call into the ASTMutationListener callback when it wouldn't be appropriate. Fixes PR16635. llvm-svn: 190016
2013-09-05 08:02:25 +08:00
case UPD_DECL_MARKED_USED: {
Fix regression from r190016. I don't have a reduced testcase yet. llvm-svn: 190094
2013-09-06 04:13:32 +08:00
// FIXME: This doesn't send the right notifications if there are
// ASTMutationListeners other than an ASTWriter.
[modules] When we merge redecl chains or mark a decl used with an update record, mark all subsequent decls as 'used' too, to maintain the AST invariant that getPreviousDecl()->Used implies this->Used. llvm-svn: 211050
2014-06-17 04:26:19 +08:00
// Maintain AST consistency: any later redeclarations are used too.
[modules] Don't defer performing updates if we have incomplete redecl chains. Instead, perform them carefully immediately. llvm-svn: 215147
2014-08-08 04:58:41 +08:00
forAllLaterRedecls(D, [](Decl *D) { D->Used = true; });
Note when a decl is used in AST files. When an AST file is built based on another AST file, it can use a decl from the fist file, and therefore mark the "isUsed" bit. We need to note this in the AST file so that the bit is set correctly when the second AST file is loaded. This patch introduces the distinction between setIsUsed() and markUsed() so that we don't call into the ASTMutationListener callback when it wouldn't be appropriate. Fixes PR16635. llvm-svn: 190016
2013-09-05 08:02:25 +08:00
break;
}
Serialize and deserialize mangling numbers. llvm-svn: 204423
2014-03-21 09:48:23 +08:00
case UPD_MANGLING_NUMBER:
Reader.Context.setManglingNumber(cast<NamedDecl>(D), Record[Idx++]);
break;
case UPD_STATIC_LOCAL_NUMBER:
Reader.Context.setStaticLocalNumber(cast<VarDecl>(D), Record[Idx++]);
break;
[modules] If we reach a definition of a class for which we already have a non-visible definition, skip the new definition and make the old one visible instead of trying to parse it again and failing horribly. C++'s ODR allows us to assume that the two definitions are identical. llvm-svn: 233250
2015-03-26 12:09:53 +08:00
[OPENMP] Codegen for threadprivate variables For all threadprivate variables which have constructor/destructor emit call to void __kmpc_threadprivate_register(ident_t * <Current Location>, void *<Original Global Addr>, kmpc_ctor <Constructor>, kmpc_cctor NULL, kmpc_dtor <Destructor>); In expressions all references to such variables are replaced by calls to void *__kmpc_threadprivate_cached(ident_t *<Current Location>, kmp_int32 <Current Thread Id>, void *<Original Global Addr>, size_t <Size of Data>, void ***<Pointer to autogenerated cache – array of private copies of threadprivate variable>); Test test/OpenMP/threadprivate_codegen.cpp checks that codegen is correct. Also it checks that codegen is correct after serialization/deserialization and one of passes verifies debug info. Differential Revision: http://reviews.llvm.org/D4002 llvm-svn: 221663
2014-11-11 12:05:39 +08:00
case UPD_DECL_MARKED_OPENMP_THREADPRIVATE:
D->addAttr(OMPThreadPrivateDeclAttr::CreateImplicit(
Reader.Context, ReadSourceRange(Record, Idx)));
break;
[modules] If we reach a definition of a class for which we already have a non-visible definition, skip the new definition and make the old one visible instead of trying to parse it again and failing horribly. C++'s ODR allows us to assume that the two definitions are identical. llvm-svn: 233250
2015-03-26 12:09:53 +08:00
[ObjC] Add NSValue support for objc_boxed_expressions Patch extends ObjCBoxedExpr to accept records (structs and unions): typedef struct __attribute__((objc_boxable)) _Color { int r, g, b; } Color; Color color; NSValue *boxedColor = @(color); // [NSValue valueWithBytes:&color objCType:@encode(Color)]; llvm-svn: 240761
2015-06-26 13:28:36 +08:00
case UPD_DECL_EXPORTED: {
[modules] If we reach a definition of a class for which we already have a non-visible definition, skip the new definition and make the old one visible instead of trying to parse it again and failing horribly. C++'s ODR allows us to assume that the two definitions are identical. llvm-svn: 233250
2015-03-26 12:09:53 +08:00
unsigned SubmoduleID = readSubmoduleID(Record, Idx);
[modules] When determining whether a definition of a class is visible, check all modules even if we've already found a definition that's not visible. llvm-svn: 240204
2015-06-20 09:05:19 +08:00
auto *Exported = cast<NamedDecl>(D);
if (auto *TD = dyn_cast<TagDecl>(Exported))
Exported = TD->getDefinition();
[modules] If we reach a definition of a class for which we already have a non-visible definition, skip the new definition and make the old one visible instead of trying to parse it again and failing horribly. C++'s ODR allows us to assume that the two definitions are identical. llvm-svn: 233250
2015-03-26 12:09:53 +08:00
Module *Owner = SubmoduleID ? Reader.getSubmodule(SubmoduleID) : nullptr;
[modules] Add local submodule visibility support for declarations. With this change, enabling -fmodules-local-submodule-visibility results in name visibility rules being applied to submodules of the current module in addition to imported modules (that is, names no longer "leak" between submodules of the same top-level module). This also makes it much safer to textually include a non-modular library into a module: each submodule that textually includes that library will get its own "copy" of that library, and so the library becomes visible no matter which including submodule you import. llvm-svn: 237473
2015-05-16 04:05:43 +08:00
if (Reader.getContext().getLangOpts().ModulesLocalVisibility) {
// FIXME: This doesn't send the right notifications if there are
// ASTMutationListeners other than an ASTWriter.
[modules] Properly merge visibility of class definitions that got merged while parsing then merged again when the module was loaded. llvm-svn: 240700
2015-06-26 05:42:33 +08:00
Reader.getContext().mergeDefinitionIntoModule(
cast<NamedDecl>(Exported), Owner,
/*NotifyListeners*/ false);
Reader.PendingMergedDefinitionsToDeduplicate.insert(
cast<NamedDecl>(Exported));
[modules] Add local submodule visibility support for declarations. With this change, enabling -fmodules-local-submodule-visibility results in name visibility rules being applied to submodules of the current module in addition to imported modules (that is, names no longer "leak" between submodules of the same top-level module). This also makes it much safer to textually include a non-modular library into a module: each submodule that textually includes that library will get its own "copy" of that library, and so the library becomes visible no matter which including submodule you import. llvm-svn: 237473
2015-05-16 04:05:43 +08:00
} else if (Owner && Owner->NameVisibility != Module::AllVisible) {
[modules] If we reach a definition of a class for which we already have a non-visible definition, skip the new definition and make the old one visible instead of trying to parse it again and failing horribly. C++'s ODR allows us to assume that the two definitions are identical. llvm-svn: 233250
2015-03-26 12:09:53 +08:00
// If Owner is made visible at some later point, make this declaration
// visible too.
[modules] Properly merge visibility of class definitions that got merged while parsing then merged again when the module was loaded. llvm-svn: 240700
2015-06-26 05:42:33 +08:00
Reader.HiddenNamesMap[Owner].push_back(Exported);
[modules] If we reach a definition of a class for which we already have a non-visible definition, skip the new definition and make the old one visible instead of trying to parse it again and failing horribly. C++'s ODR allows us to assume that the two definitions are identical. llvm-svn: 233250
2015-03-26 12:09:53 +08:00
} else {
// The declaration is now visible.
[modules] Properly merge visibility of class definitions that got merged while parsing then merged again when the module was loaded. llvm-svn: 240700
2015-06-26 05:42:33 +08:00
Exported->Hidden = false;
[modules] If we reach a definition of a class for which we already have a non-visible definition, skip the new definition and make the old one visible instead of trying to parse it again and failing horribly. C++'s ODR allows us to assume that the two definitions are identical. llvm-svn: 233250
2015-03-26 12:09:53 +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
}
[ObjC] Add NSValue support for objc_boxed_expressions Patch extends ObjCBoxedExpr to accept records (structs and unions): typedef struct __attribute__((objc_boxable)) _Color { int r, g, b; } Color; Color color; NSValue *boxedColor = @(color); // [NSValue valueWithBytes:&color objCType:@encode(Color)]; llvm-svn: 240761
2015-06-26 13:28:36 +08:00
case UPD_ADDED_ATTR_TO_RECORD:
AttrVec Attrs;
Reader.ReadAttributes(F, Attrs, Record, Idx);
assert(Attrs.size() == 1);
D->addAttr(Attrs[0]);
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
}