lib/Frontend/ASTUnit.cpp

   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"
  36 using namespace clang;
  37
  38 ASTUnit::ASTUnit(bool _MainFileIsAST)
  39   : MainFileIsAST(_MainFileIsAST) {
  40 }
  41 ASTUnit::~ASTUnit() {
  42   for (unsigned I = 0, N = TemporaryFiles.size(); I != N; ++I)
  43     TemporaryFiles[I].eraseFromDisk();
  44 }
  45
  46 namespace {
  47
  48 /// \brief Gathers information from PCHReader that will be used to initialize
  49 /// a Preprocessor.
  50 class 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
  59 public:
  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
  93 class StoredDiagnosticClient : public DiagnosticClient {
  94   llvm::SmallVectorImpl<StoredDiagnostic> &StoredDiags;
  95
  96 public:
  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.
 107 class CaptureDroppedDiagnostics {
 108   Diagnostic &Diags;
 109   StoredDiagnosticClient Client;
 110   DiagnosticClient *PreviousClient;
 111
 112 public:
 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
 128 void StoredDiagnosticClient::HandleDiagnostic(Diagnostic::Level Level,
 129                                               const DiagnosticInfo &Info) {
 130   StoredDiags.push_back(StoredDiagnostic(Level, Info));
 131 }
 132
 133 const std::string &ASTUnit::getOriginalSourceFileName() {
 134   return OriginalSourceFile;
 135 }
 136
 137 const std::string &ASTUnit::getPCHFileName() {
 138   assert(isMainFileAST() && "Not an ASTUnit from a PCH file!");
 139   return static_cast<PCHReader *>(Ctx->getExternalSource())->getFileName();
 140 }
 141
 142 ASTUnit *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
 245 namespace {
 246
 247 class TopLevelDeclTrackerConsumer : public ASTConsumer {
 248   ASTUnit &Unit;
 249
 250 public:
 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
 259 class TopLevelDeclTrackerAction : public ASTFrontendAction {
 260 public:
 261   ASTUnit &Unit;
 262
 263   virtual ASTConsumer *CreateASTConsumer(CompilerInstance &CI,
 264                                          llvm::StringRef InFile) {
 265     return new TopLevelDeclTrackerConsumer(Unit);
 266   }
 267
 268 public:
 269   TopLevelDeclTrackerAction(ASTUnit &_Unit) : Unit(_Unit) {}
 270
 271   virtual bool hasCodeCompletionSupport() const { return false; }
 272 };
 273
 274 }
 275
 276 ASTUnit *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
 355 error:
 356   Clang.takeSourceManager();
 357   Clang.takeFileManager();
 358   Clang.takeDiagnosticClient();
 359   Clang.takeDiagnostics();
 360   return 0;
 361 }
 362
 363 ASTUnit *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 }