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