ASTUnit.cpp revision 204643 
1//===--- ASTUnit.cpp - ASTUnit utility ------------------------------------===//
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// ASTUnit Implementation.
11//
12//===----------------------------------------------------------------------===//
13
14#include "clang/Frontend/ASTUnit.h"
15#include "clang/Frontend/PCHReader.h"
16#include "clang/AST/ASTContext.h"
17#include "clang/AST/ASTConsumer.h"
18#include "clang/AST/DeclVisitor.h"
19#include "clang/AST/StmtVisitor.h"
20#include "clang/Driver/Compilation.h"
21#include "clang/Driver/Driver.h"
22#include "clang/Driver/Job.h"
23#include "clang/Driver/Tool.h"
24#include "clang/Frontend/CompilerInstance.h"
25#include "clang/Frontend/FrontendActions.h"
26#include "clang/Frontend/FrontendDiagnostic.h"
27#include "clang/Frontend/FrontendOptions.h"
28#include "clang/Lex/HeaderSearch.h"
29#include "clang/Lex/Preprocessor.h"
30#include "clang/Basic/TargetOptions.h"
31#include "clang/Basic/TargetInfo.h"
32#include "clang/Basic/Diagnostic.h"
33#include "llvm/Support/MemoryBuffer.h"
34#include "llvm/System/Host.h"
35#include "llvm/System/Path.h"
36using namespace clang;
37
38ASTUnit::ASTUnit(bool _MainFileIsAST)
39  : MainFileIsAST(_MainFileIsAST) {
40}
41ASTUnit::~ASTUnit() {
42  for (unsigned I = 0, N = TemporaryFiles.size(); I != N; ++I)
43    TemporaryFiles[I].eraseFromDisk();
44}
45
46namespace {
47
48/// \brief Gathers information from PCHReader that will be used to initialize
49/// a Preprocessor.
50class PCHInfoCollector : public PCHReaderListener {
51  LangOptions &LangOpt;
52  HeaderSearch &HSI;
53  std::string &TargetTriple;
54  std::string &Predefines;
55  unsigned &Counter;
56
57  unsigned NumHeaderInfos;
58
59public:
60  PCHInfoCollector(LangOptions &LangOpt, HeaderSearch &HSI,
61                   std::string &TargetTriple, std::string &Predefines,
62                   unsigned &Counter)
63    : LangOpt(LangOpt), HSI(HSI), TargetTriple(TargetTriple),
64      Predefines(Predefines), Counter(Counter), NumHeaderInfos(0) {}
65
66  virtual bool ReadLanguageOptions(const LangOptions &LangOpts) {
67    LangOpt = LangOpts;
68    return false;
69  }
70
71  virtual bool ReadTargetTriple(llvm::StringRef Triple) {
72    TargetTriple = Triple;
73    return false;
74  }
75
76  virtual bool ReadPredefinesBuffer(llvm::StringRef PCHPredef,
77                                    FileID PCHBufferID,
78                                    llvm::StringRef OriginalFileName,
79                                    std::string &SuggestedPredefines) {
80    Predefines = PCHPredef;
81    return false;
82  }
83
84  virtual void ReadHeaderFileInfo(const HeaderFileInfo &HFI) {
85    HSI.setHeaderFileInfoForUID(HFI, NumHeaderInfos++);
86  }
87
88  virtual void ReadCounter(unsigned Value) {
89    Counter = Value;
90  }
91};
92
93class StoredDiagnosticClient : public DiagnosticClient {
94  llvm::SmallVectorImpl<StoredDiagnostic> &StoredDiags;
95
96public:
97  explicit StoredDiagnosticClient(
98                          llvm::SmallVectorImpl<StoredDiagnostic> &StoredDiags)
99    : StoredDiags(StoredDiags) { }
100
101  virtual void HandleDiagnostic(Diagnostic::Level Level,
102                                const DiagnosticInfo &Info);
103};
104
105/// \brief RAII object that optionally captures diagnostics, if
106/// there is no diagnostic client to capture them already.
107class CaptureDroppedDiagnostics {
108  Diagnostic &Diags;
109  StoredDiagnosticClient Client;
110  DiagnosticClient *PreviousClient;
111
112public:
113  CaptureDroppedDiagnostics(bool RequestCapture, Diagnostic &Diags,
114                           llvm::SmallVectorImpl<StoredDiagnostic> &StoredDiags)
115    : Diags(Diags), Client(StoredDiags), PreviousClient(Diags.getClient())
116  {
117    if (RequestCapture || Diags.getClient() == 0)
118      Diags.setClient(&Client);
119  }
120
121  ~CaptureDroppedDiagnostics() {
122    Diags.setClient(PreviousClient);
123  }
124};
125
126} // anonymous namespace
127
128void StoredDiagnosticClient::HandleDiagnostic(Diagnostic::Level Level,
129                                              const DiagnosticInfo &Info) {
130  StoredDiags.push_back(StoredDiagnostic(Level, Info));
131}
132
133const std::string &ASTUnit::getOriginalSourceFileName() {
134  return OriginalSourceFile;
135}
136
137const std::string &ASTUnit::getPCHFileName() {
138  assert(isMainFileAST() && "Not an ASTUnit from a PCH file!");
139  return static_cast<PCHReader *>(Ctx->getExternalSource())->getFileName();
140}
141
142ASTUnit *ASTUnit::LoadFromPCHFile(const std::string &Filename,
143                                  Diagnostic &Diags,
144                                  bool OnlyLocalDecls,
145                                  RemappedFile *RemappedFiles,
146                                  unsigned NumRemappedFiles,
147                                  bool CaptureDiagnostics) {
148  llvm::OwningPtr<ASTUnit> AST(new ASTUnit(true));
149  AST->OnlyLocalDecls = OnlyLocalDecls;
150  AST->HeaderInfo.reset(new HeaderSearch(AST->getFileManager()));
151
152  // If requested, capture diagnostics in the ASTUnit.
153  CaptureDroppedDiagnostics Capture(CaptureDiagnostics, Diags,
154                                    AST->Diagnostics);
155
156  for (unsigned I = 0; I != NumRemappedFiles; ++I) {
157    // Create the file entry for the file that we're mapping from.
158    const FileEntry *FromFile
159      = AST->getFileManager().getVirtualFile(RemappedFiles[I].first,
160                                    RemappedFiles[I].second->getBufferSize(),
161                                             0);
162    if (!FromFile) {
163      Diags.Report(diag::err_fe_remap_missing_from_file)
164        << RemappedFiles[I].first;
165      delete RemappedFiles[I].second;
166      continue;
167    }
168
169    // Override the contents of the "from" file with the contents of
170    // the "to" file.
171    AST->getSourceManager().overrideFileContents(FromFile,
172                                                 RemappedFiles[I].second);
173  }
174
175  // Gather Info for preprocessor construction later on.
176
177  LangOptions LangInfo;
178  HeaderSearch &HeaderInfo = *AST->HeaderInfo.get();
179  std::string TargetTriple;
180  std::string Predefines;
181  unsigned Counter;
182
183  llvm::OwningPtr<PCHReader> Reader;
184  llvm::OwningPtr<ExternalASTSource> Source;
185
186  Reader.reset(new PCHReader(AST->getSourceManager(), AST->getFileManager(),
187                             Diags));
188  Reader->setListener(new PCHInfoCollector(LangInfo, HeaderInfo, TargetTriple,
189                                           Predefines, Counter));
190
191  switch (Reader->ReadPCH(Filename)) {
192  case PCHReader::Success:
193    break;
194
195  case PCHReader::Failure:
196  case PCHReader::IgnorePCH:
197    Diags.Report(diag::err_fe_unable_to_load_pch);
198    return NULL;
199  }
200
201  AST->OriginalSourceFile = Reader->getOriginalSourceFile();
202
203  // PCH loaded successfully. Now create the preprocessor.
204
205  // Get information about the target being compiled for.
206  //
207  // FIXME: This is broken, we should store the TargetOptions in the PCH.
208  TargetOptions TargetOpts;
209  TargetOpts.ABI = "";
210  TargetOpts.CPU = "";
211  TargetOpts.Features.clear();
212  TargetOpts.Triple = TargetTriple;
213  AST->Target.reset(TargetInfo::CreateTargetInfo(Diags, TargetOpts));
214  AST->PP.reset(new Preprocessor(Diags, LangInfo, *AST->Target.get(),
215                                 AST->getSourceManager(), HeaderInfo));
216  Preprocessor &PP = *AST->PP.get();
217
218  PP.setPredefines(Reader->getSuggestedPredefines());
219  PP.setCounterValue(Counter);
220  Reader->setPreprocessor(PP);
221
222  // Create and initialize the ASTContext.
223
224  AST->Ctx.reset(new ASTContext(LangInfo,
225                                AST->getSourceManager(),
226                                *AST->Target.get(),
227                                PP.getIdentifierTable(),
228                                PP.getSelectorTable(),
229                                PP.getBuiltinInfo(),
230                                /* FreeMemory = */ false,
231                                /* size_reserve = */0));
232  ASTContext &Context = *AST->Ctx.get();
233
234  Reader->InitializeContext(Context);
235
236  // Attach the PCH reader to the AST context as an external AST
237  // source, so that declarations will be deserialized from the
238  // PCH file as needed.
239  Source.reset(Reader.take());
240  Context.setExternalSource(Source);
241
242  return AST.take();
243}
244
245namespace {
246
247class TopLevelDeclTrackerConsumer : public ASTConsumer {
248  ASTUnit &Unit;
249
250public:
251  TopLevelDeclTrackerConsumer(ASTUnit &_Unit) : Unit(_Unit) {}
252
253  void HandleTopLevelDecl(DeclGroupRef D) {
254    for (DeclGroupRef::iterator it = D.begin(), ie = D.end(); it != ie; ++it)
255      Unit.getTopLevelDecls().push_back(*it);
256  }
257};
258
259class TopLevelDeclTrackerAction : public ASTFrontendAction {
260public:
261  ASTUnit &Unit;
262
263  virtual ASTConsumer *CreateASTConsumer(CompilerInstance &CI,
264                                         llvm::StringRef InFile) {
265    return new TopLevelDeclTrackerConsumer(Unit);
266  }
267
268public:
269  TopLevelDeclTrackerAction(ASTUnit &_Unit) : Unit(_Unit) {}
270
271  virtual bool hasCodeCompletionSupport() const { return false; }
272};
273
274}
275
276ASTUnit *ASTUnit::LoadFromCompilerInvocation(CompilerInvocation *CI,
277                                             Diagnostic &Diags,
278                                             bool OnlyLocalDecls,
279                                             bool CaptureDiagnostics) {
280  // Create the compiler instance to use for building the AST.
281  CompilerInstance Clang;
282  llvm::OwningPtr<ASTUnit> AST;
283  llvm::OwningPtr<TopLevelDeclTrackerAction> Act;
284
285  Clang.setInvocation(CI);
286
287  Clang.setDiagnostics(&Diags);
288  Clang.setDiagnosticClient(Diags.getClient());
289
290  // Create the target instance.
291  Clang.setTarget(TargetInfo::CreateTargetInfo(Clang.getDiagnostics(),
292                                               Clang.getTargetOpts()));
293  if (!Clang.hasTarget()) {
294    Clang.takeSourceManager();
295    Clang.takeFileManager();
296    Clang.takeDiagnosticClient();
297    Clang.takeDiagnostics();
298    return 0;
299  }
300
301  // Inform the target of the language options.
302  //
303  // FIXME: We shouldn't need to do this, the target should be immutable once
304  // created. This complexity should be lifted elsewhere.
305  Clang.getTarget().setForcedLangOptions(Clang.getLangOpts());
306
307  assert(Clang.getFrontendOpts().Inputs.size() == 1 &&
308         "Invocation must have exactly one source file!");
309  assert(Clang.getFrontendOpts().Inputs[0].first != FrontendOptions::IK_AST &&
310         "FIXME: AST inputs not yet supported here!");
311
312  // Create the AST unit.
313  AST.reset(new ASTUnit(false));
314  AST->OnlyLocalDecls = OnlyLocalDecls;
315  AST->OriginalSourceFile = Clang.getFrontendOpts().Inputs[0].second;
316
317  // Capture any diagnostics that would otherwise be dropped.
318  CaptureDroppedDiagnostics Capture(CaptureDiagnostics,
319                                    Clang.getDiagnostics(),
320                                    AST->Diagnostics);
321
322  // Create a file manager object to provide access to and cache the filesystem.
323  Clang.setFileManager(&AST->getFileManager());
324
325  // Create the source manager.
326  Clang.setSourceManager(&AST->getSourceManager());
327
328  // Create the preprocessor.
329  Clang.createPreprocessor();
330
331  Act.reset(new TopLevelDeclTrackerAction(*AST));
332  if (!Act->BeginSourceFile(Clang, Clang.getFrontendOpts().Inputs[0].second,
333                           /*IsAST=*/false))
334    goto error;
335
336  Act->Execute();
337
338  // Steal the created target, context, and preprocessor, and take back the
339  // source and file managers.
340  AST->Ctx.reset(Clang.takeASTContext());
341  AST->PP.reset(Clang.takePreprocessor());
342  Clang.takeSourceManager();
343  Clang.takeFileManager();
344  AST->Target.reset(Clang.takeTarget());
345
346  Act->EndSourceFile();
347
348  Clang.takeDiagnosticClient();
349  Clang.takeDiagnostics();
350  Clang.takeInvocation();
351
352  AST->Invocation.reset(Clang.takeInvocation());
353  return AST.take();
354
355error:
356  Clang.takeSourceManager();
357  Clang.takeFileManager();
358  Clang.takeDiagnosticClient();
359  Clang.takeDiagnostics();
360  return 0;
361}
362
363ASTUnit *ASTUnit::LoadFromCommandLine(const char **ArgBegin,
364                                      const char **ArgEnd,
365                                      Diagnostic &Diags,
366                                      llvm::StringRef ResourceFilesPath,
367                                      bool OnlyLocalDecls,
368                                      RemappedFile *RemappedFiles,
369                                      unsigned NumRemappedFiles,
370                                      bool CaptureDiagnostics) {
371  llvm::SmallVector<const char *, 16> Args;
372  Args.push_back("<clang>"); // FIXME: Remove dummy argument.
373  Args.insert(Args.end(), ArgBegin, ArgEnd);
374
375  // FIXME: Find a cleaner way to force the driver into restricted modes. We
376  // also want to force it to use clang.
377  Args.push_back("-fsyntax-only");
378
379  // FIXME: We shouldn't have to pass in the path info.
380  driver::Driver TheDriver("clang", "/", llvm::sys::getHostTriple(),
381                           "a.out", false, Diags);
382
383  // Don't check that inputs exist, they have been remapped.
384  TheDriver.setCheckInputsExist(false);
385
386  llvm::OwningPtr<driver::Compilation> C(
387    TheDriver.BuildCompilation(Args.size(), Args.data()));
388
389  // We expect to get back exactly one command job, if we didn't something
390  // failed.
391  const driver::JobList &Jobs = C->getJobs();
392  if (Jobs.size() != 1 || !isa<driver::Command>(Jobs.begin())) {
393    llvm::SmallString<256> Msg;
394    llvm::raw_svector_ostream OS(Msg);
395    C->PrintJob(OS, C->getJobs(), "; ", true);
396    Diags.Report(diag::err_fe_expected_compiler_job) << OS.str();
397    return 0;
398  }
399
400  const driver::Command *Cmd = cast<driver::Command>(*Jobs.begin());
401  if (llvm::StringRef(Cmd->getCreator().getName()) != "clang") {
402    Diags.Report(diag::err_fe_expected_clang_command);
403    return 0;
404  }
405
406  const driver::ArgStringList &CCArgs = Cmd->getArguments();
407  llvm::OwningPtr<CompilerInvocation> CI(new CompilerInvocation);
408  CompilerInvocation::CreateFromArgs(*CI, (const char**) CCArgs.data(),
409                                     (const char**) CCArgs.data()+CCArgs.size(),
410                                     Diags);
411
412  // Override any files that need remapping
413  for (unsigned I = 0; I != NumRemappedFiles; ++I)
414    CI->getPreprocessorOpts().addRemappedFile(RemappedFiles[I].first,
415                                              RemappedFiles[I].second);
416
417  // Override the resources path.
418  CI->getHeaderSearchOpts().ResourceDir = ResourceFilesPath;
419
420  CI->getFrontendOpts().DisableFree = true;
421  return LoadFromCompilerInvocation(CI.take(), Diags, OnlyLocalDecls,
422                                    CaptureDiagnostics);
423}
424