Home | History | Annotate | Download | only in Frontend 
      1 //===--- CompilerInstance.cpp ---------------------------------------------===//
      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 #include "clang/Frontend/CompilerInstance.h"
     11 #include "clang/Sema/Sema.h"
     12 #include "clang/AST/ASTConsumer.h"
     13 #include "clang/AST/ASTContext.h"
     14 #include "clang/AST/Decl.h"
     15 #include "clang/Basic/Diagnostic.h"
     16 #include "clang/Basic/FileManager.h"
     17 #include "clang/Basic/SourceManager.h"
     18 #include "clang/Basic/TargetInfo.h"
     19 #include "clang/Basic/Version.h"
     20 #include "clang/Lex/HeaderSearch.h"
     21 #include "clang/Lex/Preprocessor.h"
     22 #include "clang/Lex/PTHManager.h"
     23 #include "clang/Frontend/ChainedDiagnosticConsumer.h"
     24 #include "clang/Frontend/FrontendAction.h"
     25 #include "clang/Frontend/FrontendActions.h"
     26 #include "clang/Frontend/FrontendDiagnostic.h"
     27 #include "clang/Frontend/LogDiagnosticPrinter.h"
     28 #include "clang/Frontend/SerializedDiagnosticPrinter.h"
     29 #include "clang/Frontend/TextDiagnosticPrinter.h"
     30 #include "clang/Frontend/VerifyDiagnosticConsumer.h"
     31 #include "clang/Frontend/Utils.h"
     32 #include "clang/Serialization/ASTReader.h"
     33 #include "clang/Sema/CodeCompleteConsumer.h"
     34 #include "llvm/Support/FileSystem.h"
     35 #include "llvm/Support/MemoryBuffer.h"
     36 #include "llvm/Support/raw_ostream.h"
     37 #include "llvm/ADT/Statistic.h"
     38 #include "llvm/Support/Timer.h"
     39 #include "llvm/Support/Host.h"
     40 #include "llvm/Support/LockFileManager.h"
     41 #include "llvm/Support/Path.h"
     42 #include "llvm/Support/Program.h"
     43 #include "llvm/Support/Signals.h"
     44 #include "llvm/Support/system_error.h"
     45 #include "llvm/Support/CrashRecoveryContext.h"
     46 #include "llvm/Config/config.h"
     47 
     48 using namespace clang;
     49 
     50 CompilerInstance::CompilerInstance()
     51   : Invocation(new CompilerInvocation()), ModuleManager(0) {
     52 }
     53 
     54 CompilerInstance::~CompilerInstance() {
     55 }
     56 
     57 void CompilerInstance::setInvocation(CompilerInvocation *Value) {
     58   Invocation = Value;
     59 }
     60 
     61 void CompilerInstance::setDiagnostics(DiagnosticsEngine *Value) {
     62   Diagnostics = Value;
     63 }
     64 
     65 void CompilerInstance::setTarget(TargetInfo *Value) {
     66   Target = Value;
     67 }
     68 
     69 void CompilerInstance::setFileManager(FileManager *Value) {
     70   FileMgr = Value;
     71 }
     72 
     73 void CompilerInstance::setSourceManager(SourceManager *Value) {
     74   SourceMgr = Value;
     75 }
     76 
     77 void CompilerInstance::setPreprocessor(Preprocessor *Value) { PP = Value; }
     78 
     79 void CompilerInstance::setASTContext(ASTContext *Value) { Context = Value; }
     80 
     81 void CompilerInstance::setSema(Sema *S) {
     82   TheSema.reset(S);
     83 }
     84 
     85 void CompilerInstance::setASTConsumer(ASTConsumer *Value) {
     86   Consumer.reset(Value);
     87 }
     88 
     89 void CompilerInstance::setCodeCompletionConsumer(CodeCompleteConsumer *Value) {
     90   CompletionConsumer.reset(Value);
     91   getFrontendOpts().SkipFunctionBodies = Value != 0;
     92 }
     93 
     94 // Diagnostics
     95 static void SetUpBuildDumpLog(const DiagnosticOptions &DiagOpts,
     96                               unsigned argc, const char* const *argv,
     97                               DiagnosticsEngine &Diags) {
     98   std::string ErrorInfo;
     99   OwningPtr<raw_ostream> OS(
    100     new llvm::raw_fd_ostream(DiagOpts.DumpBuildInformation.c_str(), ErrorInfo));
    101   if (!ErrorInfo.empty()) {
    102     Diags.Report(diag::err_fe_unable_to_open_logfile)
    103                  << DiagOpts.DumpBuildInformation << ErrorInfo;
    104     return;
    105   }
    106 
    107   (*OS) << "clang -cc1 command line arguments: ";
    108   for (unsigned i = 0; i != argc; ++i)
    109     (*OS) << argv[i] << ' ';
    110   (*OS) << '\n';
    111 
    112   // Chain in a diagnostic client which will log the diagnostics.
    113   DiagnosticConsumer *Logger =
    114     new TextDiagnosticPrinter(*OS.take(), DiagOpts, /*OwnsOutputStream=*/true);
    115   Diags.setClient(new ChainedDiagnosticConsumer(Diags.takeClient(), Logger));
    116 }
    117 
    118 static void SetUpDiagnosticLog(const DiagnosticOptions &DiagOpts,
    119                                const CodeGenOptions *CodeGenOpts,
    120                                DiagnosticsEngine &Diags) {
    121   std::string ErrorInfo;
    122   bool OwnsStream = false;
    123   raw_ostream *OS = &llvm::errs();
    124   if (DiagOpts.DiagnosticLogFile != "-") {
    125     // Create the output stream.
    126     llvm::raw_fd_ostream *FileOS(
    127       new llvm::raw_fd_ostream(DiagOpts.DiagnosticLogFile.c_str(),
    128                                ErrorInfo, llvm::raw_fd_ostream::F_Append));
    129     if (!ErrorInfo.empty()) {
    130       Diags.Report(diag::warn_fe_cc_log_diagnostics_failure)
    131         << DiagOpts.DumpBuildInformation << ErrorInfo;
    132     } else {
    133       FileOS->SetUnbuffered();
    134       FileOS->SetUseAtomicWrites(true);
    135       OS = FileOS;
    136       OwnsStream = true;
    137     }
    138   }
    139 
    140   // Chain in the diagnostic client which will log the diagnostics.
    141   LogDiagnosticPrinter *Logger = new LogDiagnosticPrinter(*OS, DiagOpts,
    142                                                           OwnsStream);
    143   if (CodeGenOpts)
    144     Logger->setDwarfDebugFlags(CodeGenOpts->DwarfDebugFlags);
    145   Diags.setClient(new ChainedDiagnosticConsumer(Diags.takeClient(), Logger));
    146 }
    147 
    148 static void SetupSerializedDiagnostics(const DiagnosticOptions &DiagOpts,
    149                                        DiagnosticsEngine &Diags,
    150                                        StringRef OutputFile) {
    151   std::string ErrorInfo;
    152   OwningPtr<llvm::raw_fd_ostream> OS;
    153   OS.reset(new llvm::raw_fd_ostream(OutputFile.str().c_str(), ErrorInfo,
    154                                     llvm::raw_fd_ostream::F_Binary));
    155 
    156   if (!ErrorInfo.empty()) {
    157     Diags.Report(diag::warn_fe_serialized_diag_failure)
    158       << OutputFile << ErrorInfo;
    159     return;
    160   }
    161 
    162   DiagnosticConsumer *SerializedConsumer =
    163     clang::serialized_diags::create(OS.take(), DiagOpts);
    164 
    165 
    166   Diags.setClient(new ChainedDiagnosticConsumer(Diags.takeClient(),
    167                                                 SerializedConsumer));
    168 }
    169 
    170 void CompilerInstance::createDiagnostics(int Argc, const char* const *Argv,
    171                                          DiagnosticConsumer *Client,
    172                                          bool ShouldOwnClient,
    173                                          bool ShouldCloneClient) {
    174   Diagnostics = createDiagnostics(getDiagnosticOpts(), Argc, Argv, Client,
    175                                   ShouldOwnClient, ShouldCloneClient,
    176                                   &getCodeGenOpts());
    177 }
    178 
    179 IntrusiveRefCntPtr<DiagnosticsEngine>
    180 CompilerInstance::createDiagnostics(const DiagnosticOptions &Opts,
    181                                     int Argc, const char* const *Argv,
    182                                     DiagnosticConsumer *Client,
    183                                     bool ShouldOwnClient,
    184                                     bool ShouldCloneClient,
    185                                     const CodeGenOptions *CodeGenOpts) {
    186   IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
    187   IntrusiveRefCntPtr<DiagnosticsEngine>
    188       Diags(new DiagnosticsEngine(DiagID));
    189 
    190   // Create the diagnostic client for reporting errors or for
    191   // implementing -verify.
    192   if (Client) {
    193     if (ShouldCloneClient)
    194       Diags->setClient(Client->clone(*Diags), ShouldOwnClient);
    195     else
    196       Diags->setClient(Client, ShouldOwnClient);
    197   } else
    198     Diags->setClient(new TextDiagnosticPrinter(llvm::errs(), Opts));
    199 
    200   // Chain in -verify checker, if requested.
    201   if (Opts.VerifyDiagnostics)
    202     Diags->setClient(new VerifyDiagnosticConsumer(*Diags));
    203 
    204   // Chain in -diagnostic-log-file dumper, if requested.
    205   if (!Opts.DiagnosticLogFile.empty())
    206     SetUpDiagnosticLog(Opts, CodeGenOpts, *Diags);
    207 
    208   if (!Opts.DumpBuildInformation.empty())
    209     SetUpBuildDumpLog(Opts, Argc, Argv, *Diags);
    210 
    211   if (!Opts.DiagnosticSerializationFile.empty())
    212     SetupSerializedDiagnostics(Opts, *Diags,
    213                                Opts.DiagnosticSerializationFile);
    214 
    215   // Configure our handling of diagnostics.
    216   ProcessWarningOptions(*Diags, Opts);
    217 
    218   return Diags;
    219 }
    220 
    221 // File Manager
    222 
    223 void CompilerInstance::createFileManager() {
    224   FileMgr = new FileManager(getFileSystemOpts());
    225 }
    226 
    227 // Source Manager
    228 
    229 void CompilerInstance::createSourceManager(FileManager &FileMgr) {
    230   SourceMgr = new SourceManager(getDiagnostics(), FileMgr);
    231 }
    232 
    233 // Preprocessor
    234 
    235 void CompilerInstance::createPreprocessor() {
    236   const PreprocessorOptions &PPOpts = getPreprocessorOpts();
    237 
    238   // Create a PTH manager if we are using some form of a token cache.
    239   PTHManager *PTHMgr = 0;
    240   if (!PPOpts.TokenCache.empty())
    241     PTHMgr = PTHManager::Create(PPOpts.TokenCache, getDiagnostics());
    242 
    243   // Create the Preprocessor.
    244   HeaderSearch *HeaderInfo = new HeaderSearch(getFileManager(),
    245                                               getDiagnostics(),
    246                                               getLangOpts(),
    247                                               &getTarget());
    248   PP = new Preprocessor(getDiagnostics(), getLangOpts(), &getTarget(),
    249                         getSourceManager(), *HeaderInfo, *this, PTHMgr,
    250                         /*OwnsHeaderSearch=*/true);
    251 
    252   // Note that this is different then passing PTHMgr to Preprocessor's ctor.
    253   // That argument is used as the IdentifierInfoLookup argument to
    254   // IdentifierTable's ctor.
    255   if (PTHMgr) {
    256     PTHMgr->setPreprocessor(&*PP);
    257     PP->setPTHManager(PTHMgr);
    258   }
    259 
    260   if (PPOpts.DetailedRecord)
    261     PP->createPreprocessingRecord(PPOpts.DetailedRecordConditionalDirectives);
    262 
    263   InitializePreprocessor(*PP, PPOpts, getHeaderSearchOpts(), getFrontendOpts());
    264 
    265   // Set up the module path, including the hash for the
    266   // module-creation options.
    267   SmallString<256> SpecificModuleCache(
    268                            getHeaderSearchOpts().ModuleCachePath);
    269   if (!getHeaderSearchOpts().DisableModuleHash)
    270     llvm::sys::path::append(SpecificModuleCache,
    271                             getInvocation().getModuleHash());
    272   PP->getHeaderSearchInfo().setModuleCachePath(SpecificModuleCache);
    273 
    274   // Handle generating dependencies, if requested.
    275   const DependencyOutputOptions &DepOpts = getDependencyOutputOpts();
    276   if (!DepOpts.OutputFile.empty())
    277     AttachDependencyFileGen(*PP, DepOpts);
    278   if (!DepOpts.DOTOutputFile.empty())
    279     AttachDependencyGraphGen(*PP, DepOpts.DOTOutputFile,
    280                              getHeaderSearchOpts().Sysroot);
    281 
    282 
    283   // Handle generating header include information, if requested.
    284   if (DepOpts.ShowHeaderIncludes)
    285     AttachHeaderIncludeGen(*PP);
    286   if (!DepOpts.HeaderIncludeOutputFile.empty()) {
    287     StringRef OutputPath = DepOpts.HeaderIncludeOutputFile;
    288     if (OutputPath == "-")
    289       OutputPath = "";
    290     AttachHeaderIncludeGen(*PP, /*ShowAllHeaders=*/true, OutputPath,
    291                            /*ShowDepth=*/false);
    292   }
    293 }
    294 
    295 // ASTContext
    296 
    297 void CompilerInstance::createASTContext() {
    298   Preprocessor &PP = getPreprocessor();
    299   Context = new ASTContext(getLangOpts(), PP.getSourceManager(),
    300                            &getTarget(), PP.getIdentifierTable(),
    301                            PP.getSelectorTable(), PP.getBuiltinInfo(),
    302                            /*size_reserve=*/ 0);
    303 }
    304 
    305 // ExternalASTSource
    306 
    307 void CompilerInstance::createPCHExternalASTSource(StringRef Path,
    308                                                   bool DisablePCHValidation,
    309                                                   bool DisableStatCache,
    310                                                 bool AllowPCHWithCompilerErrors,
    311                                                  void *DeserializationListener){
    312   OwningPtr<ExternalASTSource> Source;
    313   bool Preamble = getPreprocessorOpts().PrecompiledPreambleBytes.first != 0;
    314   Source.reset(createPCHExternalASTSource(Path, getHeaderSearchOpts().Sysroot,
    315                                           DisablePCHValidation,
    316                                           DisableStatCache,
    317                                           AllowPCHWithCompilerErrors,
    318                                           getPreprocessor(), getASTContext(),
    319                                           DeserializationListener,
    320                                           Preamble));
    321   ModuleManager = static_cast<ASTReader*>(Source.get());
    322   getASTContext().setExternalSource(Source);
    323 }
    324 
    325 ExternalASTSource *
    326 CompilerInstance::createPCHExternalASTSource(StringRef Path,
    327                                              const std::string &Sysroot,
    328                                              bool DisablePCHValidation,
    329                                              bool DisableStatCache,
    330                                              bool AllowPCHWithCompilerErrors,
    331                                              Preprocessor &PP,
    332                                              ASTContext &Context,
    333                                              void *DeserializationListener,
    334                                              bool Preamble) {
    335   OwningPtr<ASTReader> Reader;
    336   Reader.reset(new ASTReader(PP, Context,
    337                              Sysroot.empty() ? "" : Sysroot.c_str(),
    338                              DisablePCHValidation, DisableStatCache,
    339                              AllowPCHWithCompilerErrors));
    340 
    341   Reader->setDeserializationListener(
    342             static_cast<ASTDeserializationListener *>(DeserializationListener));
    343   switch (Reader->ReadAST(Path,
    344                           Preamble ? serialization::MK_Preamble
    345                                    : serialization::MK_PCH)) {
    346   case ASTReader::Success:
    347     // Set the predefines buffer as suggested by the PCH reader. Typically, the
    348     // predefines buffer will be empty.
    349     PP.setPredefines(Reader->getSuggestedPredefines());
    350     return Reader.take();
    351 
    352   case ASTReader::Failure:
    353     // Unrecoverable failure: don't even try to process the input file.
    354     break;
    355 
    356   case ASTReader::IgnorePCH:
    357     // No suitable PCH file could be found. Return an error.
    358     break;
    359   }
    360 
    361   return 0;
    362 }
    363 
    364 // Code Completion
    365 
    366 static bool EnableCodeCompletion(Preprocessor &PP,
    367                                  const std::string &Filename,
    368                                  unsigned Line,
    369                                  unsigned Column) {
    370   // Tell the source manager to chop off the given file at a specific
    371   // line and column.
    372   const FileEntry *Entry = PP.getFileManager().getFile(Filename);
    373   if (!Entry) {
    374     PP.getDiagnostics().Report(diag::err_fe_invalid_code_complete_file)
    375       << Filename;
    376     return true;
    377   }
    378 
    379   // Truncate the named file at the given line/column.
    380   PP.SetCodeCompletionPoint(Entry, Line, Column);
    381   return false;
    382 }
    383 
    384 void CompilerInstance::createCodeCompletionConsumer() {
    385   const ParsedSourceLocation &Loc = getFrontendOpts().CodeCompletionAt;
    386   if (!CompletionConsumer) {
    387     setCodeCompletionConsumer(
    388       createCodeCompletionConsumer(getPreprocessor(),
    389                                    Loc.FileName, Loc.Line, Loc.Column,
    390                                    getFrontendOpts().CodeCompleteOpts,
    391                                    llvm::outs()));
    392     if (!CompletionConsumer)
    393       return;
    394   } else if (EnableCodeCompletion(getPreprocessor(), Loc.FileName,
    395                                   Loc.Line, Loc.Column)) {
    396     setCodeCompletionConsumer(0);
    397     return;
    398   }
    399 
    400   if (CompletionConsumer->isOutputBinary() &&
    401       llvm::sys::Program::ChangeStdoutToBinary()) {
    402     getPreprocessor().getDiagnostics().Report(diag::err_fe_stdout_binary);
    403     setCodeCompletionConsumer(0);
    404   }
    405 }
    406 
    407 void CompilerInstance::createFrontendTimer() {
    408   FrontendTimer.reset(new llvm::Timer("Clang front-end timer"));
    409 }
    410 
    411 CodeCompleteConsumer *
    412 CompilerInstance::createCodeCompletionConsumer(Preprocessor &PP,
    413                                                const std::string &Filename,
    414                                                unsigned Line,
    415                                                unsigned Column,
    416                                                const CodeCompleteOptions &Opts,
    417                                                raw_ostream &OS) {
    418   if (EnableCodeCompletion(PP, Filename, Line, Column))
    419     return 0;
    420 
    421   // Set up the creation routine for code-completion.
    422   return new PrintingCodeCompleteConsumer(Opts, OS);
    423 }
    424 
    425 void CompilerInstance::createSema(TranslationUnitKind TUKind,
    426                                   CodeCompleteConsumer *CompletionConsumer) {
    427   TheSema.reset(new Sema(getPreprocessor(), getASTContext(), getASTConsumer(),
    428                          TUKind, CompletionConsumer));
    429 }
    430 
    431 // Output Files
    432 
    433 void CompilerInstance::addOutputFile(const OutputFile &OutFile) {
    434   assert(OutFile.OS && "Attempt to add empty stream to output list!");
    435   OutputFiles.push_back(OutFile);
    436 }
    437 
    438 void CompilerInstance::clearOutputFiles(bool EraseFiles) {
    439   for (std::list<OutputFile>::iterator
    440          it = OutputFiles.begin(), ie = OutputFiles.end(); it != ie; ++it) {
    441     delete it->OS;
    442     if (!it->TempFilename.empty()) {
    443       if (EraseFiles) {
    444         bool existed;
    445         llvm::sys::fs::remove(it->TempFilename, existed);
    446       } else {
    447         SmallString<128> NewOutFile(it->Filename);
    448 
    449         // If '-working-directory' was passed, the output filename should be
    450         // relative to that.
    451         FileMgr->FixupRelativePath(NewOutFile);
    452         if (llvm::error_code ec = llvm::sys::fs::rename(it->TempFilename,
    453                                                         NewOutFile.str())) {
    454           getDiagnostics().Report(diag::err_unable_to_rename_temp)
    455             << it->TempFilename << it->Filename << ec.message();
    456 
    457           bool existed;
    458           llvm::sys::fs::remove(it->TempFilename, existed);
    459         }
    460       }
    461     } else if (!it->Filename.empty() && EraseFiles)
    462       llvm::sys::Path(it->Filename).eraseFromDisk();
    463 
    464   }
    465   OutputFiles.clear();
    466 }
    467 
    468 llvm::raw_fd_ostream *
    469 CompilerInstance::createDefaultOutputFile(bool Binary,
    470                                           StringRef InFile,
    471                                           StringRef Extension) {
    472   return createOutputFile(getFrontendOpts().OutputFile, Binary,
    473                           /*RemoveFileOnSignal=*/true, InFile, Extension,
    474                           /*UseTemporary=*/true);
    475 }
    476 
    477 llvm::raw_fd_ostream *
    478 CompilerInstance::createOutputFile(StringRef OutputPath,
    479                                    bool Binary, bool RemoveFileOnSignal,
    480                                    StringRef InFile,
    481                                    StringRef Extension,
    482                                    bool UseTemporary,
    483                                    bool CreateMissingDirectories) {
    484   std::string Error, OutputPathName, TempPathName;
    485   llvm::raw_fd_ostream *OS = createOutputFile(OutputPath, Error, Binary,
    486                                               RemoveFileOnSignal,
    487                                               InFile, Extension,
    488                                               UseTemporary,
    489                                               CreateMissingDirectories,
    490                                               &OutputPathName,
    491                                               &TempPathName);
    492   if (!OS) {
    493     getDiagnostics().Report(diag::err_fe_unable_to_open_output)
    494       << OutputPath << Error;
    495     return 0;
    496   }
    497 
    498   // Add the output file -- but don't try to remove "-", since this means we are
    499   // using stdin.
    500   addOutputFile(OutputFile((OutputPathName != "-") ? OutputPathName : "",
    501                 TempPathName, OS));
    502 
    503   return OS;
    504 }
    505 
    506 llvm::raw_fd_ostream *
    507 CompilerInstance::createOutputFile(StringRef OutputPath,
    508                                    std::string &Error,
    509                                    bool Binary,
    510                                    bool RemoveFileOnSignal,
    511                                    StringRef InFile,
    512                                    StringRef Extension,
    513                                    bool UseTemporary,
    514                                    bool CreateMissingDirectories,
    515                                    std::string *ResultPathName,
    516                                    std::string *TempPathName) {
    517   assert((!CreateMissingDirectories || UseTemporary) &&
    518          "CreateMissingDirectories is only allowed when using temporary files");
    519 
    520   std::string OutFile, TempFile;
    521   if (!OutputPath.empty()) {
    522     OutFile = OutputPath;
    523   } else if (InFile == "-") {
    524     OutFile = "-";
    525   } else if (!Extension.empty()) {
    526     llvm::sys::Path Path(InFile);
    527     Path.eraseSuffix();
    528     Path.appendSuffix(Extension);
    529     OutFile = Path.str();
    530   } else {
    531     OutFile = "-";
    532   }
    533 
    534   OwningPtr<llvm::raw_fd_ostream> OS;
    535   std::string OSFile;
    536 
    537   if (UseTemporary && OutFile != "-") {
    538     // Only create the temporary if the parent directory exists (or create
    539     // missing directories is true) and we can actually write to OutPath,
    540     // otherwise we want to fail early.
    541     SmallString<256> AbsPath(OutputPath);
    542     llvm::sys::fs::make_absolute(AbsPath);
    543     llvm::sys::Path OutPath(AbsPath);
    544     bool ParentExists = false;
    545     if (llvm::sys::fs::exists(llvm::sys::path::parent_path(AbsPath.str()),
    546                               ParentExists))
    547       ParentExists = false;
    548     bool Exists;
    549     if ((CreateMissingDirectories || ParentExists) &&
    550         ((llvm::sys::fs::exists(AbsPath.str(), Exists) || !Exists) ||
    551          (OutPath.isRegularFile() && OutPath.canWrite()))) {
    552       // Create a temporary file.
    553       SmallString<128> TempPath;
    554       TempPath = OutFile;
    555       TempPath += "-%%%%%%%%";
    556       int fd;
    557       if (llvm::sys::fs::unique_file(TempPath.str(), fd, TempPath,
    558                                      /*makeAbsolute=*/false, 0664)
    559           == llvm::errc::success) {
    560         OS.reset(new llvm::raw_fd_ostream(fd, /*shouldClose=*/true));
    561         OSFile = TempFile = TempPath.str();
    562       }
    563     }
    564   }
    565 
    566   if (!OS) {
    567     OSFile = OutFile;
    568     OS.reset(
    569       new llvm::raw_fd_ostream(OSFile.c_str(), Error,
    570                                (Binary ? llvm::raw_fd_ostream::F_Binary : 0)));
    571     if (!Error.empty())
    572       return 0;
    573   }
    574 
    575   // Make sure the out stream file gets removed if we crash.
    576   if (RemoveFileOnSignal)
    577     llvm::sys::RemoveFileOnSignal(llvm::sys::Path(OSFile));
    578 
    579   if (ResultPathName)
    580     *ResultPathName = OutFile;
    581   if (TempPathName)
    582     *TempPathName = TempFile;
    583 
    584   return OS.take();
    585 }
    586 
    587 // Initialization Utilities
    588 
    589 bool CompilerInstance::InitializeSourceManager(StringRef InputFile,
    590                                                SrcMgr::CharacteristicKind Kind){
    591   return InitializeSourceManager(InputFile, Kind, getDiagnostics(),
    592                                  getFileManager(), getSourceManager(),
    593                                  getFrontendOpts());
    594 }
    595 
    596 bool CompilerInstance::InitializeSourceManager(StringRef InputFile,
    597                                                SrcMgr::CharacteristicKind Kind,
    598                                                DiagnosticsEngine &Diags,
    599                                                FileManager &FileMgr,
    600                                                SourceManager &SourceMgr,
    601                                                const FrontendOptions &Opts) {
    602   // Figure out where to get and map in the main file.
    603   if (InputFile != "-") {
    604     const FileEntry *File = FileMgr.getFile(InputFile);
    605     if (!File) {
    606       Diags.Report(diag::err_fe_error_reading) << InputFile;
    607       return false;
    608     }
    609     SourceMgr.createMainFileID(File, Kind);
    610   } else {
    611     OwningPtr<llvm::MemoryBuffer> SB;
    612     if (llvm::MemoryBuffer::getSTDIN(SB)) {
    613       // FIXME: Give ec.message() in this diag.
    614       Diags.Report(diag::err_fe_error_reading_stdin);
    615       return false;
    616     }
    617     const FileEntry *File = FileMgr.getVirtualFile(SB->getBufferIdentifier(),
    618                                                    SB->getBufferSize(), 0);
    619     SourceMgr.createMainFileID(File, Kind);
    620     SourceMgr.overrideFileContents(File, SB.take());
    621   }
    622 
    623   assert(!SourceMgr.getMainFileID().isInvalid() &&
    624          "Couldn't establish MainFileID!");
    625   return true;
    626 }
    627 
    628 // High-Level Operations
    629 
    630 bool CompilerInstance::ExecuteAction(FrontendAction &Act) {
    631   assert(hasDiagnostics() && "Diagnostics engine is not initialized!");
    632   assert(!getFrontendOpts().ShowHelp && "Client must handle '-help'!");
    633   assert(!getFrontendOpts().ShowVersion && "Client must handle '-version'!");
    634 
    635   // FIXME: Take this as an argument, once all the APIs we used have moved to
    636   // taking it as an input instead of hard-coding llvm::errs.
    637   raw_ostream &OS = llvm::errs();
    638 
    639   // Create the target instance.
    640   setTarget(TargetInfo::CreateTargetInfo(getDiagnostics(), getTargetOpts()));
    641   if (!hasTarget())
    642     return false;
    643 
    644   // Inform the target of the language options.
    645   //
    646   // FIXME: We shouldn't need to do this, the target should be immutable once
    647   // created. This complexity should be lifted elsewhere.
    648   getTarget().setForcedLangOptions(getLangOpts());
    649 
    650   // rewriter project will change target built-in bool type from its default.
    651   if (getFrontendOpts().ProgramAction == frontend::RewriteObjC)
    652     getTarget().noSignedCharForObjCBool();
    653 
    654   // Validate/process some options.
    655   if (getHeaderSearchOpts().Verbose)
    656     OS << "clang -cc1 version " CLANG_VERSION_STRING
    657        << " based upon " << PACKAGE_STRING
    658        << " default target " << llvm::sys::getDefaultTargetTriple() << "\n";
    659 
    660   if (getFrontendOpts().ShowTimers)
    661     createFrontendTimer();
    662 
    663   if (getFrontendOpts().ShowStats)
    664     llvm::EnableStatistics();
    665 
    666   for (unsigned i = 0, e = getFrontendOpts().Inputs.size(); i != e; ++i) {
    667     // Reset the ID tables if we are reusing the SourceManager.
    668     if (hasSourceManager())
    669       getSourceManager().clearIDTables();
    670 
    671     if (Act.BeginSourceFile(*this, getFrontendOpts().Inputs[i])) {
    672       Act.Execute();
    673       Act.EndSourceFile();
    674     }
    675   }
    676 
    677   // Notify the diagnostic client that all files were processed.
    678   getDiagnostics().getClient()->finish();
    679 
    680   if (getDiagnosticOpts().ShowCarets) {
    681     // We can have multiple diagnostics sharing one diagnostic client.
    682     // Get the total number of warnings/errors from the client.
    683     unsigned NumWarnings = getDiagnostics().getClient()->getNumWarnings();
    684     unsigned NumErrors = getDiagnostics().getClient()->getNumErrors();
    685 
    686     if (NumWarnings)
    687       OS << NumWarnings << " warning" << (NumWarnings == 1 ? "" : "s");
    688     if (NumWarnings && NumErrors)
    689       OS << " and ";
    690     if (NumErrors)
    691       OS << NumErrors << " error" << (NumErrors == 1 ? "" : "s");
    692     if (NumWarnings || NumErrors)
    693       OS << " generated.\n";
    694   }
    695 
    696   if (getFrontendOpts().ShowStats && hasFileManager()) {
    697     getFileManager().PrintStats();
    698     OS << "\n";
    699   }
    700 
    701   return !getDiagnostics().getClient()->getNumErrors();
    702 }
    703 
    704 /// \brief Determine the appropriate source input kind based on language
    705 /// options.
    706 static InputKind getSourceInputKindFromOptions(const LangOptions &LangOpts) {
    707   if (LangOpts.OpenCL)
    708     return IK_OpenCL;
    709   if (LangOpts.CUDA)
    710     return IK_CUDA;
    711   if (LangOpts.ObjC1)
    712     return LangOpts.CPlusPlus? IK_ObjCXX : IK_ObjC;
    713   return LangOpts.CPlusPlus? IK_CXX : IK_C;
    714 }
    715 
    716 namespace {
    717   struct CompileModuleMapData {
    718     CompilerInstance &Instance;
    719     GenerateModuleAction &CreateModuleAction;
    720   };
    721 }
    722 
    723 /// \brief Helper function that executes the module-generating action under
    724 /// a crash recovery context.
    725 static void doCompileMapModule(void *UserData) {
    726   CompileModuleMapData &Data
    727     = *reinterpret_cast<CompileModuleMapData *>(UserData);
    728   Data.Instance.ExecuteAction(Data.CreateModuleAction);
    729 }
    730 
    731 /// \brief Compile a module file for the given module, using the options
    732 /// provided by the importing compiler instance.
    733 static void compileModule(CompilerInstance &ImportingInstance,
    734                           Module *Module,
    735                           StringRef ModuleFileName) {
    736   llvm::LockFileManager Locked(ModuleFileName);
    737   switch (Locked) {
    738   case llvm::LockFileManager::LFS_Error:
    739     return;
    740 
    741   case llvm::LockFileManager::LFS_Owned:
    742     // We're responsible for building the module ourselves. Do so below.
    743     break;
    744 
    745   case llvm::LockFileManager::LFS_Shared:
    746     // Someone else is responsible for building the module. Wait for them to
    747     // finish.
    748     Locked.waitForUnlock();
    749     break;
    750   }
    751 
    752   ModuleMap &ModMap
    753     = ImportingInstance.getPreprocessor().getHeaderSearchInfo().getModuleMap();
    754 
    755   // Construct a compiler invocation for creating this module.
    756   IntrusiveRefCntPtr<CompilerInvocation> Invocation
    757     (new CompilerInvocation(ImportingInstance.getInvocation()));
    758 
    759   PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts();
    760 
    761   // For any options that aren't intended to affect how a module is built,
    762   // reset them to their default values.
    763   Invocation->getLangOpts()->resetNonModularOptions();
    764   PPOpts.resetNonModularOptions();
    765 
    766   // Note the name of the module we're building.
    767   Invocation->getLangOpts()->CurrentModule = Module->getTopLevelModuleName();
    768 
    769   // Note that this module is part of the module build path, so that we
    770   // can detect cycles in the module graph.
    771   PPOpts.ModuleBuildPath.push_back(Module->getTopLevelModuleName());
    772 
    773   // If there is a module map file, build the module using the module map.
    774   // Set up the inputs/outputs so that we build the module from its umbrella
    775   // header.
    776   FrontendOptions &FrontendOpts = Invocation->getFrontendOpts();
    777   FrontendOpts.OutputFile = ModuleFileName.str();
    778   FrontendOpts.DisableFree = false;
    779   FrontendOpts.Inputs.clear();
    780   InputKind IK = getSourceInputKindFromOptions(*Invocation->getLangOpts());
    781 
    782   // Get or create the module map that we'll use to build this module.
    783   SmallString<128> TempModuleMapFileName;
    784   if (const FileEntry *ModuleMapFile
    785                                   = ModMap.getContainingModuleMapFile(Module)) {
    786     // Use the module map where this module resides.
    787     FrontendOpts.Inputs.push_back(FrontendInputFile(ModuleMapFile->getName(),
    788                                                     IK));
    789   } else {
    790     // Create a temporary module map file.
    791     TempModuleMapFileName = Module->Name;
    792     TempModuleMapFileName += "-%%%%%%%%.map";
    793     int FD;
    794     if (llvm::sys::fs::unique_file(TempModuleMapFileName.str(), FD,
    795                                    TempModuleMapFileName,
    796                                    /*makeAbsolute=*/true)
    797           != llvm::errc::success) {
    798       ImportingInstance.getDiagnostics().Report(diag::err_module_map_temp_file)
    799         << TempModuleMapFileName;
    800       return;
    801     }
    802     // Print the module map to this file.
    803     llvm::raw_fd_ostream OS(FD, /*shouldClose=*/true);
    804     Module->print(OS);
    805     FrontendOpts.Inputs.push_back(
    806       FrontendInputFile(TempModuleMapFileName.str().str(), IK));
    807   }
    808 
    809   // Don't free the remapped file buffers; they are owned by our caller.
    810   PPOpts.RetainRemappedFileBuffers = true;
    811 
    812   Invocation->getDiagnosticOpts().VerifyDiagnostics = 0;
    813   assert(ImportingInstance.getInvocation().getModuleHash() ==
    814          Invocation->getModuleHash() && "Module hash mismatch!");
    815 
    816   // Construct a compiler instance that will be used to actually create the
    817   // module.
    818   CompilerInstance Instance;
    819   Instance.setInvocation(&*Invocation);
    820   Instance.createDiagnostics(/*argc=*/0, /*argv=*/0,
    821                              &ImportingInstance.getDiagnosticClient(),
    822                              /*ShouldOwnClient=*/true,
    823                              /*ShouldCloneClient=*/true);
    824 
    825   // Construct a module-generating action.
    826   GenerateModuleAction CreateModuleAction;
    827 
    828   // Execute the action to actually build the module in-place. Use a separate
    829   // thread so that we get a stack large enough.
    830   const unsigned ThreadStackSize = 8 << 20;
    831   llvm::CrashRecoveryContext CRC;
    832   CompileModuleMapData Data = { Instance, CreateModuleAction };
    833   CRC.RunSafelyOnThread(&doCompileMapModule, &Data, ThreadStackSize);
    834 
    835   // Delete the temporary module map file.
    836   // FIXME: Even though we're executing under crash protection, it would still
    837   // be nice to do this with RemoveFileOnSignal when we can. However, that
    838   // doesn't make sense for all clients, so clean this up manually.
    839   if (!TempModuleMapFileName.empty())
    840     llvm::sys::Path(TempModuleMapFileName).eraseFromDisk();
    841 }
    842 
    843 Module *CompilerInstance::loadModule(SourceLocation ImportLoc,
    844                                      ModuleIdPath Path,
    845                                      Module::NameVisibilityKind Visibility,
    846                                      bool IsInclusionDirective) {
    847   // If we've already handled this import, just return the cached result.
    848   // This one-element cache is important to eliminate redundant diagnostics
    849   // when both the preprocessor and parser see the same import declaration.
    850   if (!ImportLoc.isInvalid() && LastModuleImportLoc == ImportLoc) {
    851     // Make the named module visible.
    852     if (LastModuleImportResult)
    853       ModuleManager->makeModuleVisible(LastModuleImportResult, Visibility);
    854     return LastModuleImportResult;
    855   }
    856 
    857   // Determine what file we're searching from.
    858   StringRef ModuleName = Path[0].first->getName();
    859   SourceLocation ModuleNameLoc = Path[0].second;
    860 
    861   clang::Module *Module = 0;
    862 
    863   // If we don't already have information on this module, load the module now.
    864   llvm::DenseMap<const IdentifierInfo *, clang::Module *>::iterator Known
    865     = KnownModules.find(Path[0].first);
    866   if (Known != KnownModules.end()) {
    867     // Retrieve the cached top-level module.
    868     Module = Known->second;
    869   } else if (ModuleName == getLangOpts().CurrentModule) {
    870     // This is the module we're building.
    871     Module = PP->getHeaderSearchInfo().getModuleMap().findModule(ModuleName);
    872     Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
    873   } else {
    874     // Search for a module with the given name.
    875     Module = PP->getHeaderSearchInfo().lookupModule(ModuleName);
    876     std::string ModuleFileName;
    877     if (Module)
    878       ModuleFileName = PP->getHeaderSearchInfo().getModuleFileName(Module);
    879     else
    880       ModuleFileName = PP->getHeaderSearchInfo().getModuleFileName(ModuleName);
    881 
    882     if (ModuleFileName.empty()) {
    883       getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_found)
    884         << ModuleName
    885         << SourceRange(ImportLoc, ModuleNameLoc);
    886       LastModuleImportLoc = ImportLoc;
    887       LastModuleImportResult = 0;
    888       return 0;
    889     }
    890 
    891     const FileEntry *ModuleFile
    892       = getFileManager().getFile(ModuleFileName, /*OpenFile=*/false,
    893                                  /*CacheFailure=*/false);
    894     bool BuildingModule = false;
    895     if (!ModuleFile && Module) {
    896       // The module is not cached, but we have a module map from which we can
    897       // build the module.
    898 
    899       // Check whether there is a cycle in the module graph.
    900       SmallVectorImpl<std::string> &ModuleBuildPath
    901         = getPreprocessorOpts().ModuleBuildPath;
    902       SmallVectorImpl<std::string>::iterator Pos
    903         = std::find(ModuleBuildPath.begin(), ModuleBuildPath.end(), ModuleName);
    904       if (Pos != ModuleBuildPath.end()) {
    905         SmallString<256> CyclePath;
    906         for (; Pos != ModuleBuildPath.end(); ++Pos) {
    907           CyclePath += *Pos;
    908           CyclePath += " -> ";
    909         }
    910         CyclePath += ModuleName;
    911 
    912         getDiagnostics().Report(ModuleNameLoc, diag::err_module_cycle)
    913           << ModuleName << CyclePath;
    914         return 0;
    915       }
    916 
    917       getDiagnostics().Report(ModuleNameLoc, diag::warn_module_build)
    918         << ModuleName;
    919       BuildingModule = true;
    920       compileModule(*this, Module, ModuleFileName);
    921       ModuleFile = FileMgr->getFile(ModuleFileName);
    922     }
    923 
    924     if (!ModuleFile) {
    925       getDiagnostics().Report(ModuleNameLoc,
    926                               BuildingModule? diag::err_module_not_built
    927                                             : diag::err_module_not_found)
    928         << ModuleName
    929         << SourceRange(ImportLoc, ModuleNameLoc);
    930       return 0;
    931     }
    932 
    933     // If we don't already have an ASTReader, create one now.
    934     if (!ModuleManager) {
    935       if (!hasASTContext())
    936         createASTContext();
    937 
    938       std::string Sysroot = getHeaderSearchOpts().Sysroot;
    939       const PreprocessorOptions &PPOpts = getPreprocessorOpts();
    940       ModuleManager = new ASTReader(getPreprocessor(), *Context,
    941                                     Sysroot.empty() ? "" : Sysroot.c_str(),
    942                                     PPOpts.DisablePCHValidation,
    943                                     PPOpts.DisableStatCache);
    944       if (hasASTConsumer()) {
    945         ModuleManager->setDeserializationListener(
    946           getASTConsumer().GetASTDeserializationListener());
    947         getASTContext().setASTMutationListener(
    948           getASTConsumer().GetASTMutationListener());
    949       }
    950       OwningPtr<ExternalASTSource> Source;
    951       Source.reset(ModuleManager);
    952       getASTContext().setExternalSource(Source);
    953       if (hasSema())
    954         ModuleManager->InitializeSema(getSema());
    955       if (hasASTConsumer())
    956         ModuleManager->StartTranslationUnit(&getASTConsumer());
    957     }
    958 
    959     // Try to load the module we found.
    960     switch (ModuleManager->ReadAST(ModuleFile->getName(),
    961                                    serialization::MK_Module)) {
    962     case ASTReader::Success:
    963       break;
    964 
    965     case ASTReader::IgnorePCH:
    966       // FIXME: The ASTReader will already have complained, but can we showhorn
    967       // that diagnostic information into a more useful form?
    968       KnownModules[Path[0].first] = 0;
    969       return 0;
    970 
    971     case ASTReader::Failure:
    972       // Already complained, but note now that we failed.
    973       KnownModules[Path[0].first] = 0;
    974       return 0;
    975     }
    976 
    977     if (!Module) {
    978       // If we loaded the module directly, without finding a module map first,
    979       // we'll have loaded the module's information from the module itself.
    980       Module = PP->getHeaderSearchInfo().getModuleMap()
    981                  .findModule((Path[0].first->getName()));
    982     }
    983 
    984     // Cache the result of this top-level module lookup for later.
    985     Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
    986   }
    987 
    988   // If we never found the module, fail.
    989   if (!Module)
    990     return 0;
    991 
    992   // Verify that the rest of the module path actually corresponds to
    993   // a submodule.
    994   if (Path.size() > 1) {
    995     for (unsigned I = 1, N = Path.size(); I != N; ++I) {
    996       StringRef Name = Path[I].first->getName();
    997       clang::Module *Sub = Module->findSubmodule(Name);
    998 
    999       if (!Sub) {
   1000         // Attempt to perform typo correction to find a module name that works.
   1001         llvm::SmallVector<StringRef, 2> Best;
   1002         unsigned BestEditDistance = (std::numeric_limits<unsigned>::max)();
   1003 
   1004         for (clang::Module::submodule_iterator J = Module->submodule_begin(),
   1005                                             JEnd = Module->submodule_end();
   1006              J != JEnd; ++J) {
   1007           unsigned ED = Name.edit_distance((*J)->Name,
   1008                                            /*AllowReplacements=*/true,
   1009                                            BestEditDistance);
   1010           if (ED <= BestEditDistance) {
   1011             if (ED < BestEditDistance) {
   1012               Best.clear();
   1013               BestEditDistance = ED;
   1014             }
   1015 
   1016             Best.push_back((*J)->Name);
   1017           }
   1018         }
   1019 
   1020         // If there was a clear winner, user it.
   1021         if (Best.size() == 1) {
   1022           getDiagnostics().Report(Path[I].second,
   1023                                   diag::err_no_submodule_suggest)
   1024             << Path[I].first << Module->getFullModuleName() << Best[0]
   1025             << SourceRange(Path[0].second, Path[I-1].second)
   1026             << FixItHint::CreateReplacement(SourceRange(Path[I].second),
   1027                                             Best[0]);
   1028 
   1029           Sub = Module->findSubmodule(Best[0]);
   1030         }
   1031       }
   1032 
   1033       if (!Sub) {
   1034         // No submodule by this name. Complain, and don't look for further
   1035         // submodules.
   1036         getDiagnostics().Report(Path[I].second, diag::err_no_submodule)
   1037           << Path[I].first << Module->getFullModuleName()
   1038           << SourceRange(Path[0].second, Path[I-1].second);
   1039         break;
   1040       }
   1041 
   1042       Module = Sub;
   1043     }
   1044   }
   1045 
   1046   // Make the named module visible, if it's not already part of the module
   1047   // we are parsing.
   1048   if (ModuleName != getLangOpts().CurrentModule) {
   1049     if (!Module->IsFromModuleFile) {
   1050       // We have an umbrella header or directory that doesn't actually include
   1051       // all of the headers within the directory it covers. Complain about
   1052       // this missing submodule and recover by forgetting that we ever saw
   1053       // this submodule.
   1054       // FIXME: Should we detect this at module load time? It seems fairly
   1055       // expensive (and rare).
   1056       getDiagnostics().Report(ImportLoc, diag::warn_missing_submodule)
   1057         << Module->getFullModuleName()
   1058         << SourceRange(Path.front().second, Path.back().second);
   1059 
   1060       return 0;
   1061     }
   1062 
   1063     // Check whether this module is available.
   1064     StringRef Feature;
   1065     if (!Module->isAvailable(getLangOpts(), getTarget(), Feature)) {
   1066       getDiagnostics().Report(ImportLoc, diag::err_module_unavailable)
   1067         << Module->getFullModuleName()
   1068         << Feature
   1069         << SourceRange(Path.front().second, Path.back().second);
   1070       LastModuleImportLoc = ImportLoc;
   1071       LastModuleImportResult = 0;
   1072       return 0;
   1073     }
   1074 
   1075     ModuleManager->makeModuleVisible(Module, Visibility);
   1076   }
   1077 
   1078   // If this module import was due to an inclusion directive, create an
   1079   // implicit import declaration to capture it in the AST.
   1080   if (IsInclusionDirective && hasASTContext()) {
   1081     TranslationUnitDecl *TU = getASTContext().getTranslationUnitDecl();
   1082     TU->addDecl(ImportDecl::CreateImplicit(getASTContext(), TU,
   1083                                            ImportLoc, Module,
   1084                                            Path.back().second));
   1085   }
   1086 
   1087   LastModuleImportLoc = ImportLoc;
   1088   LastModuleImportResult = Module;
   1089   return Module;
   1090 }
   1091