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