OSchip
/
llvm-project
mirror of https://github.com/THU-DSP-LAB/llvm-project.git
13
0
Fork 2
Code Issues Packages Projects Releases Wiki Activity

Revert r366449: [CrossTU] Add a function to retrieve original source location. 

Reason: the commit breaks layering by adding a dependency on ASTUnit
(which is inside clangFrontend) from the ASTImporter (which is inside
clangAST).

llvm-svn: 366453
This commit is contained in:
Ilya Biryukov 2019-07-18 15:43:26 +00:00
parent 6acdf83cfa
commit abc744d263
6 changed files with 25 additions and 162 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
clang/include/clang/AST/ASTImporter.h
View File

@ -34,7 +34,6 @@ namespace clang {
class ASTContext;
class ASTImporterSharedState;
class ASTUnit;
class Attr;
class CXXBaseSpecifier;
class CXXCtorInitializer;
@ -230,11 +229,6 @@ class TypeSourceInfo;
/// The file managers we're importing to and from.
FileManager &ToFileManager, &FromFileManager;
/// The ASTUnit for the From context, if any.
/// This is used to create a mapping of imported ('To') FileID's to the
/// original ('From') FileID and ASTUnit.
ASTUnit *FromUnit;
/// Whether to perform a minimal import.
bool Minimal;
@ -283,11 +277,6 @@ class TypeSourceInfo;
void AddToLookupTable(Decl *ToD);
ASTImporter(ASTContext &ToContext, FileManager &ToFileManager,
ASTContext &FromContext, FileManager &FromFileManager,
ASTUnit *FromUnit, bool MinimalImport,
std::shared_ptr<ASTImporterSharedState> SharedState);
protected:
/// Can be overwritten by subclasses to implement their own import logic.
/// The overwritten method should call this method if it didn't import the
@ -298,6 +287,7 @@ class TypeSourceInfo;
virtual bool returnWithErrorInTest() { return false; };
public:
/// \param ToContext The context we'll be importing into.
///
/// \param ToFileManager The file manager we'll be importing into.
@ -317,23 +307,6 @@ class TypeSourceInfo;
ASTContext &FromContext, FileManager &FromFileManager,
bool MinimalImport,
std::shared_ptr<ASTImporterSharedState> SharedState = nullptr);
/// \param ToContext The context we'll be importing into.
///
/// \param ToFileManager The file manager we'll be importing into.
///
/// \param FromUnit Pointer to an ASTUnit that contains the context and
/// file manager to import from.
///
/// \param MinimalImport If true, the importer will attempt to import
/// as little as it can, e.g., by importing declarations as forward
/// declarations that can be completed at a later point.
///
/// \param SharedState The importer specific lookup table which may be
/// shared amongst several ASTImporter objects.
/// If not set then the original C/C++ lookup is used.
ASTImporter(ASTContext &ToContext, FileManager &ToFileManager,
ASTUnit &FromUnit, bool MinimalImport,
std::shared_ptr<ASTImporterSharedState> SharedState = nullptr);
virtual ~ASTImporter();

22
clang/include/clang/AST/ASTImporterSharedState.h
View File

@ -17,24 +17,18 @@
#include "clang/AST/ASTImporterLookupTable.h"
#include "clang/AST/Decl.h"
#include "clang/Basic/SourceLocation.h"
#include "llvm/ADT/DenseMap.h"
// FIXME We need this because of ImportError.
#include "clang/AST/ASTImporter.h"
namespace clang {
class ASTUnit;
class TranslationUnitDecl;
/// Importer specific state, which may be shared amongst several ASTImporter
/// objects.
class ASTImporterSharedState {
public:
using ImportedFileIDMap =
llvm::DenseMap<FileID, std::pair<FileID, ASTUnit *>>;
private:
/// Pointer to the import specific lookup table.
std::unique_ptr<ASTImporterLookupTable> LookupTable;
@ -49,16 +43,6 @@ private:
// FIXME put ImportedFromDecls here!
// And from that point we can better encapsulate the lookup table.
/// Map of imported FileID's (in "To" context) to FileID in "From" context
/// and the ASTUnit that contains the preprocessor and source manager for the
/// "From" FileID. This map is used to lookup a FileID and its SourceManager
/// when knowing only the FileID in the 'To' context. The FileID could be
/// imported by any of multiple ASTImporter objects. The map is used because
/// we do not want to loop over all ASTImporter's to find the one that
/// imported the FileID. (The ASTUnit is usable to get the SourceManager and
/// additional data.)
ImportedFileIDMap ImportedFileIDs;
public:
ASTImporterSharedState() = default;
@ -91,12 +75,6 @@ public:
void setImportDeclError(Decl *To, ImportError Error) {
ImportErrors[To] = Error;
}
ImportedFileIDMap &getImportedFileIDs() { return ImportedFileIDs; }
const ImportedFileIDMap &getImportedFileIDs() const {
return ImportedFileIDs;
}
};
} // namespace clang

20
clang/include/clang/CrossTU/CrossTranslationUnit.h
View File

@ -153,10 +153,8 @@ public:
/// was passed to the constructor.
///
/// \return Returns the resulting definition or an error.
llvm::Expected<const FunctionDecl *> importDefinition(const FunctionDecl *FD,
ASTUnit *Unit);
llvm::Expected<const VarDecl *> importDefinition(const VarDecl *VD,
ASTUnit *Unit);
llvm::Expected<const FunctionDecl *> importDefinition(const FunctionDecl *FD);
llvm::Expected<const VarDecl *> importDefinition(const VarDecl *VD);
/// Get a name to identify a named decl.
static std::string getLookupName(const NamedDecl *ND);
@ -164,19 +162,9 @@ public:
/// Emit diagnostics for the user for potential configuration errors.
void emitCrossTUDiagnostics(const IndexError &IE);
/// Determine the original source location in the original TU for an
/// imported source location.
/// \p ToLoc Source location in the imported-to AST.
/// \return Source location in the imported-from AST and the corresponding
/// ASTUnit.
/// If any error happens (ToLoc is a non-imported source location) empty is
/// returned.
llvm::Optional<std::pair<SourceLocation /*FromLoc*/, ASTUnit *>>
getImportedFromSourceLocation(const clang::SourceLocation &ToLoc) const;
private:
void lazyInitImporterSharedSt(TranslationUnitDecl *ToTU);
ASTImporter &getOrCreateASTImporter(ASTUnit *Unit);
ASTImporter &getOrCreateASTImporter(ASTContext &From);
template <typename T>
llvm::Expected<const T *> getCrossTUDefinitionImpl(const T *D,
StringRef CrossTUDir,
@ -186,7 +174,7 @@ private:
const T *findDefInDeclContext(const DeclContext *DC,
StringRef LookupName);
template <typename T>
llvm::Expected<const T *> importDefinitionImpl(const T *D, ASTUnit *Unit);
llvm::Expected<const T *> importDefinitionImpl(const T *D);
llvm::StringMap<std::unique_ptr<clang::ASTUnit>> FileASTUnitMap;
llvm::StringMap<clang::ASTUnit *> NameASTUnitMap;

27
clang/lib/AST/ASTImporter.cpp
View File

@ -12,9 +12,9 @@
//===----------------------------------------------------------------------===//
#include "clang/AST/ASTImporter.h"
#include "clang/AST/ASTImporterSharedState.h"
#include "clang/AST/ASTContext.h"
#include "clang/AST/ASTDiagnostic.h"
#include "clang/AST/ASTImporterSharedState.h"
#include "clang/AST/ASTStructuralEquivalence.h"
#include "clang/AST/Attr.h"
#include "clang/AST/Decl.h"
@ -52,14 +52,13 @@
#include "clang/Basic/SourceLocation.h"
#include "clang/Basic/SourceManager.h"
#include "clang/Basic/Specifiers.h"
#include "clang/Frontend/ASTUnit.h"
#include "llvm/ADT/APSInt.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/None.h"
#include "llvm/ADT/Optional.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/ScopeExit.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/ErrorHandling.h"
@ -7717,22 +7716,9 @@ ASTImporter::ASTImporter(ASTContext &ToContext, FileManager &ToFileManager,
ASTContext &FromContext, FileManager &FromFileManager,
bool MinimalImport,
std::shared_ptr<ASTImporterSharedState> SharedState)
: ASTImporter(ToContext, ToFileManager, FromContext, FromFileManager,
nullptr, MinimalImport, SharedState){}
ASTImporter::ASTImporter(ASTContext &ToContext, FileManager &ToFileManager,
ASTUnit &FromUnit, bool MinimalImport,
std::shared_ptr<ASTImporterSharedState> SharedState)
: ASTImporter(ToContext, ToFileManager, FromUnit.getASTContext(),
FromUnit.getFileManager(), &FromUnit, MinimalImport,
SharedState){}
ASTImporter::ASTImporter(ASTContext &ToContext, FileManager &ToFileManager,
ASTContext &FromContext, FileManager &FromFileManager,
ASTUnit *FromUnit, bool MinimalImport,
std::shared_ptr<ASTImporterSharedState> SharedState)
: SharedState(SharedState), ToContext(ToContext), FromContext(FromContext),
ToFileManager(ToFileManager), FromFileManager(FromFileManager),
FromUnit(FromUnit), Minimal(MinimalImport) {
Minimal(MinimalImport) {
// Create a default state without the lookup table: LLDB case.
if (!SharedState) {
@ -8435,13 +8421,6 @@ Expected<FileID> ASTImporter::Import(FileID FromID, bool IsBuiltin) {
assert(ToID.isValid() && "Unexpected invalid fileID was created.");
ImportedFileIDs[FromID] = ToID;
if (FromUnit) {
assert(SharedState->getImportedFileIDs().find(ToID) ==
SharedState->getImportedFileIDs().end() &&
"FileID already imported!");
SharedState->getImportedFileIDs()[ToID] = std::make_pair(FromID, FromUnit);
}
return ToID;
}

50
clang/lib/CrossTU/CrossTranslationUnit.cpp
View File

@ -295,7 +295,7 @@ llvm::Expected<const T *> CrossTranslationUnitContext::getCrossTUDefinitionImpl(
TranslationUnitDecl *TU = Unit->getASTContext().getTranslationUnitDecl();
if (const T *ResultDecl = findDefInDeclContext<T>(TU, LookupName))
return importDefinition(ResultDecl, Unit);
return importDefinition(ResultDecl);
return llvm::make_error<IndexError>(index_error_code::failed_import);
}
@ -411,13 +411,10 @@ llvm::Expected<ASTUnit *> CrossTranslationUnitContext::loadExternalAST(
template <typename T>
llvm::Expected<const T *>
CrossTranslationUnitContext::importDefinitionImpl(const T *D, ASTUnit *Unit) {
CrossTranslationUnitContext::importDefinitionImpl(const T *D) {
assert(hasBodyOrInit(D) && "Decls to be imported should have body or init.");
assert(&D->getASTContext() == &Unit->getASTContext() &&
"ASTContext of Decl and the unit should match.");
ASTImporter &Importer = getOrCreateASTImporter(Unit);
ASTImporter &Importer = getOrCreateASTImporter(D->getASTContext());
auto ToDeclOrError = Importer.Import(D);
if (!ToDeclOrError) {
handleAllErrors(ToDeclOrError.takeError(),
@ -444,15 +441,13 @@ CrossTranslationUnitContext::importDefinitionImpl(const T *D, ASTUnit *Unit) {
}
llvm::Expected<const FunctionDecl *>
CrossTranslationUnitContext::importDefinition(const FunctionDecl *FD,
ASTUnit *Unit) {
return importDefinitionImpl(FD, Unit);
CrossTranslationUnitContext::importDefinition(const FunctionDecl *FD) {
return importDefinitionImpl(FD);
}
llvm::Expected<const VarDecl *>
CrossTranslationUnitContext::importDefinition(const VarDecl *VD,
ASTUnit *Unit) {
return importDefinitionImpl(VD, Unit);
CrossTranslationUnitContext::importDefinition(const VarDecl *VD) {
return importDefinitionImpl(VD);
}
void CrossTranslationUnitContext::lazyInitImporterSharedSt(
@ -462,40 +457,17 @@ void CrossTranslationUnitContext::lazyInitImporterSharedSt(
}
ASTImporter &
CrossTranslationUnitContext::getOrCreateASTImporter(ASTUnit *Unit) {
ASTContext &From = Unit->getASTContext();
CrossTranslationUnitContext::getOrCreateASTImporter(ASTContext &From) {
auto I = ASTUnitImporterMap.find(From.getTranslationUnitDecl());
if (I != ASTUnitImporterMap.end())
return *I->second;
lazyInitImporterSharedSt(Context.getTranslationUnitDecl());
ASTImporter *NewImporter =
new ASTImporter(Context, Context.getSourceManager().getFileManager(),
*Unit, false, ImporterSharedSt);
ASTImporter *NewImporter = new ASTImporter(
Context, Context.getSourceManager().getFileManager(), From,
From.getSourceManager().getFileManager(), false, ImporterSharedSt);
ASTUnitImporterMap[From.getTranslationUnitDecl()].reset(NewImporter);
return *NewImporter;
}
llvm::Optional<std::pair<SourceLocation, ASTUnit *>>
CrossTranslationUnitContext::getImportedFromSourceLocation(
const clang::SourceLocation &ToLoc) const {
if (!ImporterSharedSt)
return {};
const SourceManager &SM = Context.getSourceManager();
auto DecToLoc = SM.getDecomposedLoc(ToLoc);
auto I = ImporterSharedSt->getImportedFileIDs().find(DecToLoc.first);
if (I == ImporterSharedSt->getImportedFileIDs().end())
return {};
FileID FromID = I->second.first;
clang::ASTUnit *Unit = I->second.second;
SourceLocation FromLoc =
Unit->getSourceManager().getComposedLoc(FromID, DecToLoc.second);
return std::make_pair(FromLoc, Unit);
}
} // namespace cross_tu
} // namespace clang

39
clang/unittests/CrossTU/CrossTranslationUnitTest.cpp
View File

@ -28,18 +28,13 @@ public:
: CTU(CI), Success(Success) {}
void HandleTranslationUnit(ASTContext &Ctx) {
auto FindFInTU = [](const TranslationUnitDecl *TU) {
const FunctionDecl *FD = nullptr;
for (const Decl *D : TU->decls()) {
FD = dyn_cast<FunctionDecl>(D);
if (FD && FD->getName() == "f")
break;
}
return FD;
};
const TranslationUnitDecl *TU = Ctx.getTranslationUnitDecl();
const FunctionDecl *FD = FindFInTU(TU);
const FunctionDecl *FD = nullptr;
for (const Decl *D : TU->decls()) {
FD = dyn_cast<FunctionDecl>(D);
if (FD && FD->getName() == "f")
break;
}
assert(FD && FD->getName() == "f");
bool OrigFDHasBody = FD->hasBody();
@ -83,28 +78,6 @@ public:
if (NewFDorError) {
const FunctionDecl *NewFD = *NewFDorError;
*Success = NewFD && NewFD->hasBody() && !OrigFDHasBody;
if (NewFD) {
// Check GetImportedFromSourceLocation.
llvm::Optional<std::pair<SourceLocation, ASTUnit *>> SLocResult =
CTU.getImportedFromSourceLocation(NewFD->getLocation());
EXPECT_TRUE(SLocResult);
if (SLocResult) {
SourceLocation OrigSLoc = (*SLocResult).first;
ASTUnit *OrigUnit = (*SLocResult).second;
// OrigUnit is created internally by CTU (is not the
// ASTWithDefinition).
TranslationUnitDecl *OrigTU =
OrigUnit->getASTContext().getTranslationUnitDecl();
const FunctionDecl *FDWithDefinition = FindFInTU(OrigTU);
EXPECT_TRUE(FDWithDefinition);
if (FDWithDefinition) {
EXPECT_EQ(FDWithDefinition->getName(), "f");
EXPECT_TRUE(FDWithDefinition->isThisDeclarationADefinition());
EXPECT_EQ(OrigSLoc, FDWithDefinition->getLocation());
}
}
}
}
}