clang  8.0.0
CrossTranslationUnit.cpp
Go to the documentation of this file.
1 //===--- CrossTranslationUnit.cpp - -----------------------------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the CrossTranslationUnit interface.
11 //
12 //===----------------------------------------------------------------------===//
14 #include "clang/AST/ASTImporter.h"
15 #include "clang/AST/Decl.h"
16 #include "clang/Basic/TargetInfo.h"
18 #include "clang/Frontend/ASTUnit.h"
22 #include "llvm/ADT/Triple.h"
23 #include "llvm/ADT/Statistic.h"
24 #include "llvm/Support/ErrorHandling.h"
25 #include "llvm/Support/ManagedStatic.h"
26 #include "llvm/Support/Path.h"
27 #include "llvm/Support/raw_ostream.h"
28 #include <fstream>
29 #include <sstream>
30 
31 namespace clang {
32 namespace cross_tu {
33 
34 namespace {
35 
36 #define DEBUG_TYPE "CrossTranslationUnit"
37 STATISTIC(NumGetCTUCalled, "The # of getCTUDefinition function called");
38 STATISTIC(
39  NumNotInOtherTU,
40  "The # of getCTUDefinition called but the function is not in any other TU");
41 STATISTIC(NumGetCTUSuccess,
42  "The # of getCTUDefinition successfully returned the "
43  "requested function's body");
44 STATISTIC(NumTripleMismatch, "The # of triple mismatches");
45 STATISTIC(NumLangMismatch, "The # of language mismatches");
46 
47 // Same as Triple's equality operator, but we check a field only if that is
48 // known in both instances.
49 bool hasEqualKnownFields(const llvm::Triple &Lhs, const llvm::Triple &Rhs) {
50  using llvm::Triple;
51  if (Lhs.getArch() != Triple::UnknownArch &&
52  Rhs.getArch() != Triple::UnknownArch && Lhs.getArch() != Rhs.getArch())
53  return false;
54  if (Lhs.getSubArch() != Triple::NoSubArch &&
55  Rhs.getSubArch() != Triple::NoSubArch &&
56  Lhs.getSubArch() != Rhs.getSubArch())
57  return false;
58  if (Lhs.getVendor() != Triple::UnknownVendor &&
59  Rhs.getVendor() != Triple::UnknownVendor &&
60  Lhs.getVendor() != Rhs.getVendor())
61  return false;
62  if (!Lhs.isOSUnknown() && !Rhs.isOSUnknown() &&
63  Lhs.getOS() != Rhs.getOS())
64  return false;
65  if (Lhs.getEnvironment() != Triple::UnknownEnvironment &&
66  Rhs.getEnvironment() != Triple::UnknownEnvironment &&
67  Lhs.getEnvironment() != Rhs.getEnvironment())
68  return false;
69  if (Lhs.getObjectFormat() != Triple::UnknownObjectFormat &&
70  Rhs.getObjectFormat() != Triple::UnknownObjectFormat &&
71  Lhs.getObjectFormat() != Rhs.getObjectFormat())
72  return false;
73  return true;
74 }
75 
76 // FIXME: This class is will be removed after the transition to llvm::Error.
77 class IndexErrorCategory : public std::error_category {
78 public:
79  const char *name() const noexcept override { return "clang.index"; }
80 
81  std::string message(int Condition) const override {
82  switch (static_cast<index_error_code>(Condition)) {
84  return "An unknown error has occurred.";
86  return "The index file is missing.";
88  return "Invalid index file format.";
90  return "Multiple definitions in the index file.";
92  return "Missing definition from the index file.";
94  return "Failed to import the definition.";
96  return "Failed to load external AST source.";
98  return "Failed to generate USR.";
100  return "Triple mismatch";
102  return "Language mismatch";
103  }
104  llvm_unreachable("Unrecognized index_error_code.");
105  }
106 };
107 
108 static llvm::ManagedStatic<IndexErrorCategory> Category;
109 } // end anonymous namespace
110 
111 char IndexError::ID;
112 
113 void IndexError::log(raw_ostream &OS) const {
114  OS << Category->message(static_cast<int>(Code)) << '\n';
115 }
116 
117 std::error_code IndexError::convertToErrorCode() const {
118  return std::error_code(static_cast<int>(Code), *Category);
119 }
120 
122 parseCrossTUIndex(StringRef IndexPath, StringRef CrossTUDir) {
123  std::ifstream ExternalMapFile(IndexPath);
124  if (!ExternalMapFile)
125  return llvm::make_error<IndexError>(index_error_code::missing_index_file,
126  IndexPath.str());
127 
128  llvm::StringMap<std::string> Result;
129  std::string Line;
130  unsigned LineNo = 1;
131  while (std::getline(ExternalMapFile, Line)) {
132  const size_t Pos = Line.find(" ");
133  if (Pos > 0 && Pos != std::string::npos) {
134  StringRef LineRef{Line};
135  StringRef LookupName = LineRef.substr(0, Pos);
136  if (Result.count(LookupName))
137  return llvm::make_error<IndexError>(
138  index_error_code::multiple_definitions, IndexPath.str(), LineNo);
139  StringRef FileName = LineRef.substr(Pos + 1);
140  SmallString<256> FilePath = CrossTUDir;
141  llvm::sys::path::append(FilePath, FileName);
142  Result[LookupName] = FilePath.str().str();
143  } else
144  return llvm::make_error<IndexError>(
145  index_error_code::invalid_index_format, IndexPath.str(), LineNo);
146  LineNo++;
147  }
148  return Result;
149 }
150 
151 std::string
152 createCrossTUIndexString(const llvm::StringMap<std::string> &Index) {
153  std::ostringstream Result;
154  for (const auto &E : Index)
155  Result << E.getKey().str() << " " << E.getValue() << '\n';
156  return Result.str();
157 }
158 
160  : CI(CI), Context(CI.getASTContext()) {}
161 
163 
165  SmallString<128> DeclUSR;
166  bool Ret = index::generateUSRForDecl(ND, DeclUSR); (void)Ret;
167  assert(!Ret && "Unable to generate USR");
168  return DeclUSR.str();
169 }
170 
171 /// Recursively visits the function decls of a DeclContext, and looks up a
172 /// function based on USRs.
173 const FunctionDecl *
174 CrossTranslationUnitContext::findFunctionInDeclContext(const DeclContext *DC,
175  StringRef LookupFnName) {
176  assert(DC && "Declaration Context must not be null");
177  for (const Decl *D : DC->decls()) {
178  const auto *SubDC = dyn_cast<DeclContext>(D);
179  if (SubDC)
180  if (const auto *FD = findFunctionInDeclContext(SubDC, LookupFnName))
181  return FD;
182 
183  const auto *ND = dyn_cast<FunctionDecl>(D);
184  const FunctionDecl *ResultDecl;
185  if (!ND || !ND->hasBody(ResultDecl))
186  continue;
187  if (getLookupName(ResultDecl) != LookupFnName)
188  continue;
189  return ResultDecl;
190  }
191  return nullptr;
192 }
193 
196  StringRef CrossTUDir,
197  StringRef IndexName,
198  bool DisplayCTUProgress) {
199  assert(FD && "FD is missing, bad call to this function!");
200  assert(!FD->hasBody() && "FD has a definition in current translation unit!");
201  ++NumGetCTUCalled;
202  const std::string LookupFnName = getLookupName(FD);
203  if (LookupFnName.empty())
204  return llvm::make_error<IndexError>(
206  llvm::Expected<ASTUnit *> ASTUnitOrError =
207  loadExternalAST(LookupFnName, CrossTUDir, IndexName, DisplayCTUProgress);
208  if (!ASTUnitOrError)
209  return ASTUnitOrError.takeError();
210  ASTUnit *Unit = *ASTUnitOrError;
211  assert(&Unit->getFileManager() ==
213 
214  const llvm::Triple &TripleTo = Context.getTargetInfo().getTriple();
215  const llvm::Triple &TripleFrom =
217  // The imported AST had been generated for a different target.
218  // Some parts of the triple in the loaded ASTContext can be unknown while the
219  // very same parts in the target ASTContext are known. Thus we check for the
220  // known parts only.
221  if (!hasEqualKnownFields(TripleTo, TripleFrom)) {
222  // TODO: Pass the SourceLocation of the CallExpression for more precise
223  // diagnostics.
224  ++NumTripleMismatch;
225  return llvm::make_error<IndexError>(index_error_code::triple_mismatch,
226  Unit->getMainFileName(), TripleTo.str(),
227  TripleFrom.str());
228  }
229 
230  const auto &LangTo = Context.getLangOpts();
231  const auto &LangFrom = Unit->getASTContext().getLangOpts();
232  // FIXME: Currenty we do not support CTU across C++ and C and across
233  // different dialects of C++.
234  if (LangTo.CPlusPlus != LangFrom.CPlusPlus) {
235  ++NumLangMismatch;
236  return llvm::make_error<IndexError>(index_error_code::lang_mismatch);
237  }
238 
240  if (const FunctionDecl *ResultDecl =
241  findFunctionInDeclContext(TU, LookupFnName))
242  return importDefinition(ResultDecl);
243  return llvm::make_error<IndexError>(index_error_code::failed_import);
244 }
245 
247  switch (IE.getCode()) {
249  Context.getDiagnostics().Report(diag::err_ctu_error_opening)
250  << IE.getFileName();
251  break;
253  Context.getDiagnostics().Report(diag::err_extdefmap_parsing)
254  << IE.getFileName() << IE.getLineNum();
255  break;
257  Context.getDiagnostics().Report(diag::err_multiple_def_index)
258  << IE.getLineNum();
259  break;
261  Context.getDiagnostics().Report(diag::warn_ctu_incompat_triple)
262  << IE.getFileName() << IE.getTripleToName() << IE.getTripleFromName();
263  break;
264  default:
265  break;
266  }
267 }
268 
270  StringRef LookupName, StringRef CrossTUDir, StringRef IndexName,
271  bool DisplayCTUProgress) {
272  // FIXME: The current implementation only supports loading functions with
273  // a lookup name from a single translation unit. If multiple
274  // translation units contains functions with the same lookup name an
275  // error will be returned.
276  ASTUnit *Unit = nullptr;
277  auto FnUnitCacheEntry = FunctionASTUnitMap.find(LookupName);
278  if (FnUnitCacheEntry == FunctionASTUnitMap.end()) {
279  if (FunctionFileMap.empty()) {
280  SmallString<256> IndexFile = CrossTUDir;
281  if (llvm::sys::path::is_absolute(IndexName))
282  IndexFile = IndexName;
283  else
284  llvm::sys::path::append(IndexFile, IndexName);
286  parseCrossTUIndex(IndexFile, CrossTUDir);
287  if (IndexOrErr)
288  FunctionFileMap = *IndexOrErr;
289  else
290  return IndexOrErr.takeError();
291  }
292 
293  auto It = FunctionFileMap.find(LookupName);
294  if (It == FunctionFileMap.end()) {
295  ++NumNotInOtherTU;
296  return llvm::make_error<IndexError>(index_error_code::missing_definition);
297  }
298  StringRef ASTFileName = It->second;
299  auto ASTCacheEntry = FileASTUnitMap.find(ASTFileName);
300  if (ASTCacheEntry == FileASTUnitMap.end()) {
302  TextDiagnosticPrinter *DiagClient =
303  new TextDiagnosticPrinter(llvm::errs(), &*DiagOpts);
306  new DiagnosticsEngine(DiagID, &*DiagOpts, DiagClient));
307 
308  std::unique_ptr<ASTUnit> LoadedUnit(ASTUnit::LoadFromASTFile(
309  ASTFileName, CI.getPCHContainerOperations()->getRawReader(),
311  Unit = LoadedUnit.get();
312  FileASTUnitMap[ASTFileName] = std::move(LoadedUnit);
313  if (DisplayCTUProgress) {
314  llvm::errs() << "CTU loaded AST file: "
315  << ASTFileName << "\n";
316  }
317  } else {
318  Unit = ASTCacheEntry->second.get();
319  }
320  FunctionASTUnitMap[LookupName] = Unit;
321  } else {
322  Unit = FnUnitCacheEntry->second;
323  }
324  if (!Unit)
325  return llvm::make_error<IndexError>(
327  return Unit;
328 }
329 
332  assert(FD->hasBody() && "Functions to be imported should have body.");
333 
334  ASTImporter &Importer = getOrCreateASTImporter(FD->getASTContext());
335  auto *ToDecl =
336  cast_or_null<FunctionDecl>(Importer.Import(const_cast<FunctionDecl *>(FD)));
337  if (!ToDecl)
338  return llvm::make_error<IndexError>(index_error_code::failed_import);
339  assert(ToDecl->hasBody());
340  assert(FD->hasBody() && "Functions already imported should have body.");
341  ++NumGetCTUSuccess;
342  return ToDecl;
343 }
344 
345 void CrossTranslationUnitContext::lazyInitLookupTable(
346  TranslationUnitDecl *ToTU) {
347  if (!LookupTable)
348  LookupTable = llvm::make_unique<ASTImporterLookupTable>(*ToTU);
349 }
350 
351 ASTImporter &
352 CrossTranslationUnitContext::getOrCreateASTImporter(ASTContext &From) {
353  auto I = ASTUnitImporterMap.find(From.getTranslationUnitDecl());
354  if (I != ASTUnitImporterMap.end())
355  return *I->second;
356  lazyInitLookupTable(Context.getTranslationUnitDecl());
357  ASTImporter *NewImporter = new ASTImporter(
358  Context, Context.getSourceManager().getFileManager(), From,
359  From.getSourceManager().getFileManager(), false, LookupTable.get());
360  ASTUnitImporterMap[From.getTranslationUnitDecl()].reset(NewImporter);
361  return *NewImporter;
362 }
363 
364 } // namespace cross_tu
365 } // namespace clang
Represents a function declaration or definition.
Definition: Decl.h:1738
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
Definition: TargetInfo.h:953
Load everything, including Sema.
Definition: ASTUnit.h:671
std::shared_ptr< PCHContainerOperations > getPCHContainerOperations() const
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:87
const FileManager & getFileManager() const
Definition: ASTUnit.h:471
llvm::Expected< ASTUnit * > loadExternalAST(StringRef LookupName, StringRef CrossTUDir, StringRef IndexName, bool DisplayCTUProgress=false)
This function loads a function definition from an external AST file.
void log(raw_ostream &OS) const override
DiagnosticsEngine & getDiagnostics() const
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1295
const TargetInfo & getTargetInfo() const
Definition: ASTContext.h:690
static std::unique_ptr< ASTUnit > LoadFromASTFile(const std::string &Filename, const PCHContainerReader &PCHContainerRdr, WhatToLoad ToLoad, IntrusiveRefCntPtr< DiagnosticsEngine > Diags, const FileSystemOptions &FileSystemOpts, bool UseDebugInfo=false, bool OnlyLocalDecls=false, ArrayRef< RemappedFile > RemappedFiles=None, bool CaptureDiagnostics=false, bool AllowPCHWithCompilerErrors=false, bool UserFilesAreVolatile=false)
Create a ASTUnit from an AST file.
Definition: ASTUnit.cpp:733
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
Definition: DeclBase.h:1997
FileManager & getFileManager() const
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:155
Utility class for loading a ASTContext from an AST file.
Definition: ASTUnit.h:87
int Category
Definition: Format.cpp:1632
StringRef getMainFileName() const
Definition: ASTUnit.cpp:1439
Concrete class used by the front-end to report problems and issues.
Definition: Diagnostic.h:149
STATISTIC(NumObjCCallEdges, "Number of Objective-C method call edges")
const AnnotatedLine * Line
std::string createCrossTUIndexString(const llvm::StringMap< std::string > &Index)
bool hasBody(const FunctionDecl *&Definition) const
Returns true if the function has a body.
Definition: Decl.cpp:2695
llvm::Expected< llvm::StringMap< std::string > > parseCrossTUIndex(StringRef IndexPath, StringRef CrossTUDir)
This function parses an index file that determines which translation unit contains which definition...
FileSystemOptions & getFileSystemOpts()
CompilerInstance - Helper class for managing a single instance of the Clang compiler.
Options for controlling the compiler diagnostics engine.
ASTContext & getASTContext() const LLVM_READONLY
Definition: DeclBase.cpp:376
Dataflow Directional Tag Classes.
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition: DeclBase.h:1262
Used for handling and querying diagnostic IDs.
index_error_code getCode() const
Imports selected nodes from one AST context into another context, merging AST nodes where appropriate...
Definition: ASTImporter.h:83
llvm::Expected< const FunctionDecl * > importDefinition(const FunctionDecl *FD)
This function merges a definition from a separate AST Unit into the current one which was created by ...
const ASTContext & getASTContext() const
Definition: ASTUnit.h:434
SourceManager & getSourceManager()
Definition: ASTContext.h:662
llvm::Expected< const FunctionDecl * > getCrossTUDefinition(const FunctionDecl *FD, StringRef CrossTUDir, StringRef IndexName, bool DisplayCTUProgress=false)
This function loads a function definition from an external AST file and merge it into the original AS...
std::error_code convertToErrorCode() const override
TranslationUnitDecl * getTranslationUnitDecl() const
Definition: ASTContext.h:1009
Defines the clang::TargetInfo interface.
static std::string getLookupName(const NamedDecl *ND)
Get a name to identify a function.
void emitCrossTUDiagnostics(const IndexError &IE)
Emit diagnostics for the user for potential configuration errors.
The top declaration context.
Definition: Decl.h:108
bool generateUSRForDecl(const Decl *D, SmallVectorImpl< char > &Buf)
Generate a USR for a Decl, including the USR prefix.
This represents a decl that may have a name.
Definition: Decl.h:249
std::string getTripleToName() const
const LangOptions & getLangOpts() const
Definition: ASTContext.h:707
std::string getTripleFromName() const