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().ShowMacrosInCodeCompletion,
    391                              getFrontendOpts().ShowCodePatternsInCodeCompletion,
    392                            getFrontendOpts().ShowGlobalSymbolsInCodeCompletion,
    393                                    llvm::outs()));
    394     if (!CompletionConsumer)
    395       return;
    396   } else if (EnableCodeCompletion(getPreprocessor(), Loc.FileName,
    397                                   Loc.Line, Loc.Column)) {
    398     setCodeCompletionConsumer(0);
    399     return;
    400   }
    401 
    402   if (CompletionConsumer->isOutputBinary() &&
    403       llvm::sys::Program::ChangeStdoutToBinary()) {
    404     getPreprocessor().getDiagnostics().Report(diag::err_fe_stdout_binary);
    405     setCodeCompletionConsumer(0);
    406   }
    407 }
    408 
    409 void CompilerInstance::createFrontendTimer() {
    410   FrontendTimer.reset(new llvm::Timer("Clang front-end timer"));
    411 }
    412 
    413 CodeCompleteConsumer *
    414 CompilerInstance::createCodeCompletionConsumer(Preprocessor &PP,
    415                                                const std::string &Filename,
    416                                                unsigned Line,
    417                                                unsigned Column,
    418                                                bool ShowMacros,
    419                                                bool ShowCodePatterns,
    420                                                bool ShowGlobals,
    421                                                raw_ostream &OS) {
    422   if (EnableCodeCompletion(PP, Filename, Line, Column))
    423     return 0;
    424 
    425   // Set up the creation routine for code-completion.
    426   return new PrintingCodeCompleteConsumer(ShowMacros, ShowCodePatterns,
    427                                           ShowGlobals, OS);
    428 }
    429 
    430 void CompilerInstance::createSema(TranslationUnitKind TUKind,
    431                                   CodeCompleteConsumer *CompletionConsumer) {
    432   TheSema.reset(new Sema(getPreprocessor(), getASTContext(), getASTConsumer(),
    433                          TUKind, CompletionConsumer));
    434 }
    435 
    436 // Output Files
    437 
    438 void CompilerInstance::addOutputFile(const OutputFile &OutFile) {
    439   assert(OutFile.OS && "Attempt to add empty stream to output list!");
    440   OutputFiles.push_back(OutFile);
    441 }
    442 
    443 void CompilerInstance::clearOutputFiles(bool EraseFiles) {
    444   for (std::list<OutputFile>::iterator
    445          it = OutputFiles.begin(), ie = OutputFiles.end(); it != ie; ++it) {
    446     delete it->OS;
    447     if (!it->TempFilename.empty()) {
    448       if (EraseFiles) {
    449         bool existed;
    450         llvm::sys::fs::remove(it->TempFilename, existed);
    451       } else {
    452         SmallString<128> NewOutFile(it->Filename);
    453 
    454         // If '-working-directory' was passed, the output filename should be
    455         // relative to that.
    456         FileMgr->FixupRelativePath(NewOutFile);
    457         if (llvm::error_code ec = llvm::sys::fs::rename(it->TempFilename,
    458                                                         NewOutFile.str())) {
    459           getDiagnostics().Report(diag::err_fe_unable_to_rename_temp)
    460             << it->TempFilename << it->Filename << ec.message();
    461 
    462           bool existed;
    463           llvm::sys::fs::remove(it->TempFilename, existed);
    464         }
    465       }
    466     } else if (!it->Filename.empty() && EraseFiles)
    467       llvm::sys::Path(it->Filename).eraseFromDisk();
    468 
    469   }
    470   OutputFiles.clear();
    471 }
    472 
    473 llvm::raw_fd_ostream *
    474 CompilerInstance::createDefaultOutputFile(bool Binary,
    475                                           StringRef InFile,
    476                                           StringRef Extension) {
    477   return createOutputFile(getFrontendOpts().OutputFile, Binary,
    478                           /*RemoveFileOnSignal=*/true, InFile, Extension,
    479                           /*UseTemporary=*/true);
    480 }
    481 
    482 llvm::raw_fd_ostream *
    483 CompilerInstance::createOutputFile(StringRef OutputPath,
    484                                    bool Binary, bool RemoveFileOnSignal,
    485                                    StringRef InFile,
    486                                    StringRef Extension,
    487                                    bool UseTemporary,
    488                                    bool CreateMissingDirectories) {
    489   std::string Error, OutputPathName, TempPathName;
    490   llvm::raw_fd_ostream *OS = createOutputFile(OutputPath, Error, Binary,
    491                                               RemoveFileOnSignal,
    492                                               InFile, Extension,
    493                                               UseTemporary,
    494                                               CreateMissingDirectories,
    495                                               &OutputPathName,
    496                                               &TempPathName);
    497   if (!OS) {
    498     getDiagnostics().Report(diag::err_fe_unable_to_open_output)
    499       << OutputPath << Error;
    500     return 0;
    501   }
    502 
    503   // Add the output file -- but don't try to remove "-", since this means we are
    504   // using stdin.
    505   addOutputFile(OutputFile((OutputPathName != "-") ? OutputPathName : "",
    506                 TempPathName, OS));
    507 
    508   return OS;
    509 }
    510 
    511 llvm::raw_fd_ostream *
    512 CompilerInstance::createOutputFile(StringRef OutputPath,
    513                                    std::string &Error,
    514                                    bool Binary,
    515                                    bool RemoveFileOnSignal,
    516                                    StringRef InFile,
    517                                    StringRef Extension,
    518                                    bool UseTemporary,
    519                                    bool CreateMissingDirectories,
    520                                    std::string *ResultPathName,
    521                                    std::string *TempPathName) {
    522   assert((!CreateMissingDirectories || UseTemporary) &&
    523          "CreateMissingDirectories is only allowed when using temporary files");
    524 
    525   std::string OutFile, TempFile;
    526   if (!OutputPath.empty()) {
    527     OutFile = OutputPath;
    528   } else if (InFile == "-") {
    529     OutFile = "-";
    530   } else if (!Extension.empty()) {
    531     llvm::sys::Path Path(InFile);
    532     Path.eraseSuffix();
    533     Path.appendSuffix(Extension);
    534     OutFile = Path.str();
    535   } else {
    536     OutFile = "-";
    537   }
    538 
    539   OwningPtr<llvm::raw_fd_ostream> OS;
    540   std::string OSFile;
    541 
    542   if (UseTemporary && OutFile != "-") {
    543     // Only create the temporary if the parent directory exists (or create
    544     // missing directories is true) and we can actually write to OutPath,
    545     // otherwise we want to fail early.
    546     SmallString<256> AbsPath(OutputPath);
    547     llvm::sys::fs::make_absolute(AbsPath);
    548     llvm::sys::Path OutPath(AbsPath);
    549     bool ParentExists = false;
    550     if (llvm::sys::fs::exists(llvm::sys::path::parent_path(AbsPath.str()),
    551                               ParentExists))
    552       ParentExists = false;
    553     bool Exists;
    554     if ((CreateMissingDirectories || ParentExists) &&
    555         ((llvm::sys::fs::exists(AbsPath.str(), Exists) || !Exists) ||
    556          (OutPath.isRegularFile() && OutPath.canWrite()))) {
    557       // Create a temporary file.
    558       SmallString<128> TempPath;
    559       TempPath = OutFile;
    560       TempPath += "-%%%%%%%%";
    561       int fd;
    562       if (llvm::sys::fs::unique_file(TempPath.str(), fd, TempPath,
    563                                /*makeAbsolute=*/false) == llvm::errc::success) {
    564         OS.reset(new llvm::raw_fd_ostream(fd, /*shouldClose=*/true));
    565         OSFile = TempFile = TempPath.str();
    566       }
    567     }
    568   }
    569 
    570   if (!OS) {
    571     OSFile = OutFile;
    572     OS.reset(
    573       new llvm::raw_fd_ostream(OSFile.c_str(), Error,
    574                                (Binary ? llvm::raw_fd_ostream::F_Binary : 0)));
    575     if (!Error.empty())
    576       return 0;
    577   }
    578 
    579   // Make sure the out stream file gets removed if we crash.
    580   if (RemoveFileOnSignal)
    581     llvm::sys::RemoveFileOnSignal(llvm::sys::Path(OSFile));
    582 
    583   if (ResultPathName)
    584     *ResultPathName = OutFile;
    585   if (TempPathName)
    586     *TempPathName = TempFile;
    587 
    588   return OS.take();
    589 }
    590 
    591 // Initialization Utilities
    592 
    593 bool CompilerInstance::InitializeSourceManager(StringRef InputFile,
    594                                                SrcMgr::CharacteristicKind Kind){
    595   return InitializeSourceManager(InputFile, Kind, getDiagnostics(),
    596                                  getFileManager(), getSourceManager(),
    597                                  getFrontendOpts());
    598 }
    599 
    600 bool CompilerInstance::InitializeSourceManager(StringRef InputFile,
    601                                                SrcMgr::CharacteristicKind Kind,
    602                                                DiagnosticsEngine &Diags,
    603                                                FileManager &FileMgr,
    604                                                SourceManager &SourceMgr,
    605                                                const FrontendOptions &Opts) {
    606   // Figure out where to get and map in the main file.
    607   if (InputFile != "-") {
    608     const FileEntry *File = FileMgr.getFile(InputFile);
    609     if (!File) {
    610       Diags.Report(diag::err_fe_error_reading) << InputFile;
    611       return false;
    612     }
    613     SourceMgr.createMainFileID(File, Kind);
    614   } else {
    615     OwningPtr<llvm::MemoryBuffer> SB;
    616     if (llvm::MemoryBuffer::getSTDIN(SB)) {
    617       // FIXME: Give ec.message() in this diag.
    618       Diags.Report(diag::err_fe_error_reading_stdin);
    619       return false;
    620     }
    621     const FileEntry *File = FileMgr.getVirtualFile(SB->getBufferIdentifier(),
    622                                                    SB->getBufferSize(), 0);
    623     SourceMgr.createMainFileID(File, Kind);
    624     SourceMgr.overrideFileContents(File, SB.take());
    625   }
    626 
    627   assert(!SourceMgr.getMainFileID().isInvalid() &&
    628          "Couldn't establish MainFileID!");
    629   return true;
    630 }
    631 
    632 // High-Level Operations
    633 
    634 bool CompilerInstance::ExecuteAction(FrontendAction &Act) {
    635   assert(hasDiagnostics() && "Diagnostics engine is not initialized!");
    636   assert(!getFrontendOpts().ShowHelp && "Client must handle '-help'!");
    637   assert(!getFrontendOpts().ShowVersion && "Client must handle '-version'!");
    638 
    639   // FIXME: Take this as an argument, once all the APIs we used have moved to
    640   // taking it as an input instead of hard-coding llvm::errs.
    641   raw_ostream &OS = llvm::errs();
    642 
    643   // Create the target instance.
    644   setTarget(TargetInfo::CreateTargetInfo(getDiagnostics(), getTargetOpts()));
    645   if (!hasTarget())
    646     return false;
    647 
    648   // Inform the target of the language options.
    649   //
    650   // FIXME: We shouldn't need to do this, the target should be immutable once
    651   // created. This complexity should be lifted elsewhere.
    652   getTarget().setForcedLangOptions(getLangOpts());
    653 
    654   // rewriter project will change target built-in bool type from its default.
    655   if (getFrontendOpts().ProgramAction == frontend::RewriteObjC)
    656     getTarget().noSignedCharForObjCBool();
    657 
    658   // Validate/process some options.
    659   if (getHeaderSearchOpts().Verbose)
    660     OS << "clang -cc1 version " CLANG_VERSION_STRING
    661        << " based upon " << PACKAGE_STRING
    662        << " default target " << llvm::sys::getDefaultTargetTriple() << "\n";
    663 
    664   if (getFrontendOpts().ShowTimers)
    665     createFrontendTimer();
    666 
    667   if (getFrontendOpts().ShowStats)
    668     llvm::EnableStatistics();
    669 
    670   for (unsigned i = 0, e = getFrontendOpts().Inputs.size(); i != e; ++i) {
    671     // Reset the ID tables if we are reusing the SourceManager.
    672     if (hasSourceManager())
    673       getSourceManager().clearIDTables();
    674 
    675     if (Act.BeginSourceFile(*this, getFrontendOpts().Inputs[i])) {
    676       Act.Execute();
    677       Act.EndSourceFile();
    678     }
    679   }
    680 
    681   // Notify the diagnostic client that all files were processed.
    682   getDiagnostics().getClient()->finish();
    683 
    684   if (getDiagnosticOpts().ShowCarets) {
    685     // We can have multiple diagnostics sharing one diagnostic client.
    686     // Get the total number of warnings/errors from the client.
    687     unsigned NumWarnings = getDiagnostics().getClient()->getNumWarnings();
    688     unsigned NumErrors = getDiagnostics().getClient()->getNumErrors();
    689 
    690     if (NumWarnings)
    691       OS << NumWarnings << " warning" << (NumWarnings == 1 ? "" : "s");
    692     if (NumWarnings && NumErrors)
    693       OS << " and ";
    694     if (NumErrors)
    695       OS << NumErrors << " error" << (NumErrors == 1 ? "" : "s");
    696     if (NumWarnings || NumErrors)
    697       OS << " generated.\n";
    698   }
    699 
    700   if (getFrontendOpts().ShowStats && hasFileManager()) {
    701     getFileManager().PrintStats();
    702     OS << "\n";
    703   }
    704 
    705   return !getDiagnostics().getClient()->getNumErrors();
    706 }
    707 
    708 /// \brief Determine the appropriate source input kind based on language
    709 /// options.
    710 static InputKind getSourceInputKindFromOptions(const LangOptions &LangOpts) {
    711   if (LangOpts.OpenCL)
    712     return IK_OpenCL;
    713   if (LangOpts.CUDA)
    714     return IK_CUDA;
    715   if (LangOpts.ObjC1)
    716     return LangOpts.CPlusPlus? IK_ObjCXX : IK_ObjC;
    717   return LangOpts.CPlusPlus? IK_CXX : IK_C;
    718 }
    719 
    720 namespace {
    721   struct CompileModuleMapData {
    722     CompilerInstance &Instance;
    723     GenerateModuleAction &CreateModuleAction;
    724   };
    725 }
    726 
    727 /// \brief Helper function that executes the module-generating action under
    728 /// a crash recovery context.
    729 static void doCompileMapModule(void *UserData) {
    730   CompileModuleMapData &Data
    731     = *reinterpret_cast<CompileModuleMapData *>(UserData);
    732   Data.Instance.ExecuteAction(Data.CreateModuleAction);
    733 }
    734 
    735 /// \brief Compile a module file for the given module, using the options
    736 /// provided by the importing compiler instance.
    737 static void compileModule(CompilerInstance &ImportingInstance,
    738                           Module *Module,
    739                           StringRef ModuleFileName) {
    740   llvm::LockFileManager Locked(ModuleFileName);
    741   switch (Locked) {
    742   case llvm::LockFileManager::LFS_Error:
    743     return;
    744 
    745   case llvm::LockFileManager::LFS_Owned:
    746     // We're responsible for building the module ourselves. Do so below.
    747     break;
    748 
    749   case llvm::LockFileManager::LFS_Shared:
    750     // Someone else is responsible for building the module. Wait for them to
    751     // finish.
    752     Locked.waitForUnlock();
    753     break;
    754   }
    755 
    756   ModuleMap &ModMap
    757     = ImportingInstance.getPreprocessor().getHeaderSearchInfo().getModuleMap();
    758 
    759   // Construct a compiler invocation for creating this module.
    760   IntrusiveRefCntPtr<CompilerInvocation> Invocation
    761     (new CompilerInvocation(ImportingInstance.getInvocation()));
    762 
    763   PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts();
    764 
    765   // For any options that aren't intended to affect how a module is built,
    766   // reset them to their default values.
    767   Invocation->getLangOpts()->resetNonModularOptions();
    768   PPOpts.resetNonModularOptions();
    769 
    770   // Note the name of the module we're building.
    771   Invocation->getLangOpts()->CurrentModule = Module->getTopLevelModuleName();
    772 
    773   // Note that this module is part of the module build path, so that we
    774   // can detect cycles in the module graph.
    775   PPOpts.ModuleBuildPath.push_back(Module->getTopLevelModuleName());
    776 
    777   // If there is a module map file, build the module using the module map.
    778   // Set up the inputs/outputs so that we build the module from its umbrella
    779   // header.
    780   FrontendOptions &FrontendOpts = Invocation->getFrontendOpts();
    781   FrontendOpts.OutputFile = ModuleFileName.str();
    782   FrontendOpts.DisableFree = false;
    783   FrontendOpts.Inputs.clear();
    784   InputKind IK = getSourceInputKindFromOptions(*Invocation->getLangOpts());
    785 
    786   // Get or create the module map that we'll use to build this module.
    787   SmallString<128> TempModuleMapFileName;
    788   if (const FileEntry *ModuleMapFile
    789                                   = ModMap.getContainingModuleMapFile(Module)) {
    790     // Use the module map where this module resides.
    791     FrontendOpts.Inputs.push_back(FrontendInputFile(ModuleMapFile->getName(),
    792                                                     IK));
    793   } else {
    794     // Create a temporary module map file.
    795     TempModuleMapFileName = Module->Name;
    796     TempModuleMapFileName += "-%%%%%%%%.map";
    797     int FD;
    798     if (llvm::sys::fs::unique_file(TempModuleMapFileName.str(), FD,
    799                                    TempModuleMapFileName,
    800                                    /*makeAbsolute=*/true)
    801           != llvm::errc::success) {
    802       ImportingInstance.getDiagnostics().Report(diag::err_module_map_temp_file)
    803         << TempModuleMapFileName;
    804       return;
    805     }
    806     // Print the module map to this file.
    807     llvm::raw_fd_ostream OS(FD, /*shouldClose=*/true);
    808     Module->print(OS);
    809     FrontendOpts.Inputs.push_back(
    810       FrontendInputFile(TempModuleMapFileName.str().str(), IK));
    811   }
    812 
    813   // Don't free the remapped file buffers; they are owned by our caller.
    814   PPOpts.RetainRemappedFileBuffers = true;
    815 
    816   Invocation->getDiagnosticOpts().VerifyDiagnostics = 0;
    817   assert(ImportingInstance.getInvocation().getModuleHash() ==
    818          Invocation->getModuleHash() && "Module hash mismatch!");
    819 
    820   // Construct a compiler instance that will be used to actually create the
    821   // module.
    822   CompilerInstance Instance;
    823   Instance.setInvocation(&*Invocation);
    824   Instance.createDiagnostics(/*argc=*/0, /*argv=*/0,
    825                              &ImportingInstance.getDiagnosticClient(),
    826                              /*ShouldOwnClient=*/true,
    827                              /*ShouldCloneClient=*/true);
    828 
    829   // Construct a module-generating action.
    830   GenerateModuleAction CreateModuleAction;
    831 
    832   // Execute the action to actually build the module in-place. Use a separate
    833   // thread so that we get a stack large enough.
    834   const unsigned ThreadStackSize = 8 << 20;
    835   llvm::CrashRecoveryContext CRC;
    836   CompileModuleMapData Data = { Instance, CreateModuleAction };
    837   CRC.RunSafelyOnThread(&doCompileMapModule, &Data, ThreadStackSize);
    838 
    839   // Delete the temporary module map file.
    840   // FIXME: Even though we're executing under crash protection, it would still
    841   // be nice to do this with RemoveFileOnSignal when we can. However, that
    842   // doesn't make sense for all clients, so clean this up manually.
    843   if (!TempModuleMapFileName.empty())
    844     llvm::sys::Path(TempModuleMapFileName).eraseFromDisk();
    845 }
    846 
    847 Module *CompilerInstance::loadModule(SourceLocation ImportLoc,
    848                                      ModuleIdPath Path,
    849                                      Module::NameVisibilityKind Visibility,
    850                                      bool IsInclusionDirective) {
    851   // If we've already handled this import, just return the cached result.
    852   // This one-element cache is important to eliminate redundant diagnostics
    853   // when both the preprocessor and parser see the same import declaration.
    854   if (!ImportLoc.isInvalid() && LastModuleImportLoc == ImportLoc) {
    855     // Make the named module visible.
    856     if (LastModuleImportResult)
    857       ModuleManager->makeModuleVisible(LastModuleImportResult, Visibility);
    858     return LastModuleImportResult;
    859   }
    860 
    861   // Determine what file we're searching from.
    862   SourceManager &SourceMgr = getSourceManager();
    863   SourceLocation ExpandedImportLoc = SourceMgr.getExpansionLoc(ImportLoc);
    864   const FileEntry *CurFile
    865     = SourceMgr.getFileEntryForID(SourceMgr.getFileID(ExpandedImportLoc));
    866   if (!CurFile)
    867     CurFile = SourceMgr.getFileEntryForID(SourceMgr.getMainFileID());
    868 
    869   StringRef ModuleName = Path[0].first->getName();
    870   SourceLocation ModuleNameLoc = Path[0].second;
    871 
    872   clang::Module *Module = 0;
    873 
    874   // If we don't already have information on this module, load the module now.
    875   llvm::DenseMap<const IdentifierInfo *, clang::Module *>::iterator Known
    876     = KnownModules.find(Path[0].first);
    877   if (Known != KnownModules.end()) {
    878     // Retrieve the cached top-level module.
    879     Module = Known->second;
    880   } else if (ModuleName == getLangOpts().CurrentModule) {
    881     // This is the module we're building.
    882     Module = PP->getHeaderSearchInfo().getModuleMap().findModule(ModuleName);
    883     Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
    884   } else {
    885     // Search for a module with the given name.
    886     Module = PP->getHeaderSearchInfo().lookupModule(ModuleName);
    887     std::string ModuleFileName;
    888     if (Module)
    889       ModuleFileName = PP->getHeaderSearchInfo().getModuleFileName(Module);
    890     else
    891       ModuleFileName = PP->getHeaderSearchInfo().getModuleFileName(ModuleName);
    892 
    893     if (ModuleFileName.empty()) {
    894       getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_found)
    895         << ModuleName
    896         << SourceRange(ImportLoc, ModuleNameLoc);
    897       LastModuleImportLoc = ImportLoc;
    898       LastModuleImportResult = 0;
    899       return 0;
    900     }
    901 
    902     const FileEntry *ModuleFile
    903       = getFileManager().getFile(ModuleFileName, /*OpenFile=*/false,
    904                                  /*CacheFailure=*/false);
    905     bool BuildingModule = false;
    906     if (!ModuleFile && Module) {
    907       // The module is not cached, but we have a module map from which we can
    908       // build the module.
    909 
    910       // Check whether there is a cycle in the module graph.
    911       SmallVectorImpl<std::string> &ModuleBuildPath
    912         = getPreprocessorOpts().ModuleBuildPath;
    913       SmallVectorImpl<std::string>::iterator Pos
    914         = std::find(ModuleBuildPath.begin(), ModuleBuildPath.end(), ModuleName);
    915       if (Pos != ModuleBuildPath.end()) {
    916         SmallString<256> CyclePath;
    917         for (; Pos != ModuleBuildPath.end(); ++Pos) {
    918           CyclePath += *Pos;
    919           CyclePath += " -> ";
    920         }
    921         CyclePath += ModuleName;
    922 
    923         getDiagnostics().Report(ModuleNameLoc, diag::err_module_cycle)
    924           << ModuleName << CyclePath;
    925         return 0;
    926       }
    927 
    928       getDiagnostics().Report(ModuleNameLoc, diag::warn_module_build)
    929         << ModuleName;
    930       BuildingModule = true;
    931       compileModule(*this, Module, ModuleFileName);
    932       ModuleFile = FileMgr->getFile(ModuleFileName);
    933     }
    934 
    935     if (!ModuleFile) {
    936       getDiagnostics().Report(ModuleNameLoc,
    937                               BuildingModule? diag::err_module_not_built
    938                                             : diag::err_module_not_found)
    939         << ModuleName
    940         << SourceRange(ImportLoc, ModuleNameLoc);
    941       return 0;
    942     }
    943 
    944     // If we don't already have an ASTReader, create one now.
    945     if (!ModuleManager) {
    946       if (!hasASTContext())
    947         createASTContext();
    948 
    949       std::string Sysroot = getHeaderSearchOpts().Sysroot;
    950       const PreprocessorOptions &PPOpts = getPreprocessorOpts();
    951       ModuleManager = new ASTReader(getPreprocessor(), *Context,
    952                                     Sysroot.empty() ? "" : Sysroot.c_str(),
    953                                     PPOpts.DisablePCHValidation,
    954                                     PPOpts.DisableStatCache);
    955       if (hasASTConsumer()) {
    956         ModuleManager->setDeserializationListener(
    957           getASTConsumer().GetASTDeserializationListener());
    958         getASTContext().setASTMutationListener(
    959           getASTConsumer().GetASTMutationListener());
    960       }
    961       OwningPtr<ExternalASTSource> Source;
    962       Source.reset(ModuleManager);
    963       getASTContext().setExternalSource(Source);
    964       if (hasSema())
    965         ModuleManager->InitializeSema(getSema());
    966       if (hasASTConsumer())
    967         ModuleManager->StartTranslationUnit(&getASTConsumer());
    968     }
    969 
    970     // Try to load the module we found.
    971     switch (ModuleManager->ReadAST(ModuleFile->getName(),
    972                                    serialization::MK_Module)) {
    973     case ASTReader::Success:
    974       break;
    975 
    976     case ASTReader::IgnorePCH:
    977       // FIXME: The ASTReader will already have complained, but can we showhorn
    978       // that diagnostic information into a more useful form?
    979       KnownModules[Path[0].first] = 0;
    980       return 0;
    981 
    982     case ASTReader::Failure:
    983       // Already complained, but note now that we failed.
    984       KnownModules[Path[0].first] = 0;
    985       return 0;
    986     }
    987 
    988     if (!Module) {
    989       // If we loaded the module directly, without finding a module map first,
    990       // we'll have loaded the module's information from the module itself.
    991       Module = PP->getHeaderSearchInfo().getModuleMap()
    992                  .findModule((Path[0].first->getName()));
    993     }
    994 
    995     // Cache the result of this top-level module lookup for later.
    996     Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
    997   }
    998 
    999   // If we never found the module, fail.
   1000   if (!Module)
   1001     return 0;
   1002 
   1003   // Verify that the rest of the module path actually corresponds to
   1004   // a submodule.
   1005   if (Path.size() > 1) {
   1006     for (unsigned I = 1, N = Path.size(); I != N; ++I) {
   1007       StringRef Name = Path[I].first->getName();
   1008       clang::Module *Sub = Module->findSubmodule(Name);
   1009 
   1010       if (!Sub) {
   1011         // Attempt to perform typo correction to find a module name that works.
   1012         llvm::SmallVector<StringRef, 2> Best;
   1013         unsigned BestEditDistance = (std::numeric_limits<unsigned>::max)();
   1014 
   1015         for (clang::Module::submodule_iterator J = Module->submodule_begin(),
   1016                                             JEnd = Module->submodule_end();
   1017              J != JEnd; ++J) {
   1018           unsigned ED = Name.edit_distance((*J)->Name,
   1019                                            /*AllowReplacements=*/true,
   1020                                            BestEditDistance);
   1021           if (ED <= BestEditDistance) {
   1022             if (ED < BestEditDistance) {
   1023               Best.clear();
   1024               BestEditDistance = ED;
   1025             }
   1026 
   1027             Best.push_back((*J)->Name);
   1028           }
   1029         }
   1030 
   1031         // If there was a clear winner, user it.
   1032         if (Best.size() == 1) {
   1033           getDiagnostics().Report(Path[I].second,
   1034                                   diag::err_no_submodule_suggest)
   1035             << Path[I].first << Module->getFullModuleName() << Best[0]
   1036             << SourceRange(Path[0].second, Path[I-1].second)
   1037             << FixItHint::CreateReplacement(SourceRange(Path[I].second),
   1038                                             Best[0]);
   1039 
   1040           Sub = Module->findSubmodule(Best[0]);
   1041         }
   1042       }
   1043 
   1044       if (!Sub) {
   1045         // No submodule by this name. Complain, and don't look for further
   1046         // submodules.
   1047         getDiagnostics().Report(Path[I].second, diag::err_no_submodule)
   1048           << Path[I].first << Module->getFullModuleName()
   1049           << SourceRange(Path[0].second, Path[I-1].second);
   1050         break;
   1051       }
   1052 
   1053       Module = Sub;
   1054     }
   1055   }
   1056 
   1057   // Make the named module visible, if it's not already part of the module
   1058   // we are parsing.
   1059   if (ModuleName != getLangOpts().CurrentModule) {
   1060     if (!Module->IsFromModuleFile) {
   1061       // We have an umbrella header or directory that doesn't actually include
   1062       // all of the headers within the directory it covers. Complain about
   1063       // this missing submodule and recover by forgetting that we ever saw
   1064       // this submodule.
   1065       // FIXME: Should we detect this at module load time? It seems fairly
   1066       // expensive (and rare).
   1067       getDiagnostics().Report(ImportLoc, diag::warn_missing_submodule)
   1068         << Module->getFullModuleName()
   1069         << SourceRange(Path.front().second, Path.back().second);
   1070 
   1071       return 0;
   1072     }
   1073 
   1074     // Check whether this module is available.
   1075     StringRef Feature;
   1076     if (!Module->isAvailable(getLangOpts(), getTarget(), Feature)) {
   1077       getDiagnostics().Report(ImportLoc, diag::err_module_unavailable)
   1078         << Module->getFullModuleName()
   1079         << Feature
   1080         << SourceRange(Path.front().second, Path.back().second);
   1081       LastModuleImportLoc = ImportLoc;
   1082       LastModuleImportResult = 0;
   1083       return 0;
   1084     }
   1085 
   1086     ModuleManager->makeModuleVisible(Module, Visibility);
   1087   }
   1088 
   1089   // If this module import was due to an inclusion directive, create an
   1090   // implicit import declaration to capture it in the AST.
   1091   if (IsInclusionDirective && hasASTContext()) {
   1092     TranslationUnitDecl *TU = getASTContext().getTranslationUnitDecl();
   1093     TU->addDecl(ImportDecl::CreateImplicit(getASTContext(), TU,
   1094                                            ImportLoc, Module,
   1095                                            Path.back().second));
   1096   }
   1097 
   1098   LastModuleImportLoc = ImportLoc;
   1099   LastModuleImportResult = Module;
   1100   return Module;
   1101 }
   1102