CompilerInstance.cpp revision 8e23806863721495f9e1f84aed614f7afba774a3 
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
58using namespace clang;
59
60CompilerInstance::CompilerInstance()
61  : Invocation(new CompilerInvocation()), ModuleManager(0) {
62}
63
64CompilerInstance::~CompilerInstance() {
65}
66
67void CompilerInstance::setInvocation(CompilerInvocation *Value) {
68  Invocation = Value;
69}
70
71void CompilerInstance::setDiagnostics(DiagnosticsEngine *Value) {
72  Diagnostics = Value;
73}
74
75void CompilerInstance::setTarget(TargetInfo *Value) {
76  Target = Value;
77}
78
79void CompilerInstance::setFileManager(FileManager *Value) {
80  FileMgr = Value;
81}
82
83void CompilerInstance::setSourceManager(SourceManager *Value) {
84  SourceMgr = Value;
85}
86
87void CompilerInstance::setPreprocessor(Preprocessor *Value) { PP = Value; }
88
89void CompilerInstance::setASTContext(ASTContext *Value) { Context = Value; }
90
91void CompilerInstance::setSema(Sema *S) {
92  TheSema.reset(S);
93}
94
95void CompilerInstance::setASTConsumer(ASTConsumer *Value) {
96  Consumer.reset(Value);
97}
98
99void CompilerInstance::setCodeCompletionConsumer(CodeCompleteConsumer *Value) {
100  CompletionConsumer.reset(Value);
101}
102
103// Diagnostics
104static 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
127static 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
157static 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
179void 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
188llvm::IntrusiveRefCntPtr<DiagnosticsEngine>
189CompilerInstance::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
232void CompilerInstance::createFileManager() {
233  FileMgr = new FileManager(getFileSystemOpts());
234}
235
236// Source Manager
237
238void CompilerInstance::createSourceManager(FileManager &FileMgr) {
239  SourceMgr = new SourceManager(getDiagnostics(), FileMgr);
240}
241
242// Preprocessor
243
244void 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
304void 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
314void 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
330ExternalASTSource *
331CompilerInstance::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
369static 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
387void 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
412void CompilerInstance::createFrontendTimer() {
413  FrontendTimer.reset(new llvm::Timer("Clang front-end timer"));
414}
415
416CodeCompleteConsumer *
417CompilerInstance::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
433void CompilerInstance::createSema(TranslationUnitKind TUKind,
434                                  CodeCompleteConsumer *CompletionConsumer) {
435  TheSema.reset(new Sema(getPreprocessor(), getASTContext(), getASTConsumer(),
436                         TUKind, CompletionConsumer));
437}
438
439// Output Files
440
441void CompilerInstance::addOutputFile(const OutputFile &OutFile) {
442  assert(OutFile.OS && "Attempt to add empty stream to output list!");
443  OutputFiles.push_back(OutFile);
444}
445
446void 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
476llvm::raw_fd_ostream *
477CompilerInstance::createDefaultOutputFile(bool Binary,
478                                          StringRef InFile,
479                                          StringRef Extension) {
480  return createOutputFile(getFrontendOpts().OutputFile, Binary,
481                          /*RemoveFileOnSignal=*/true, InFile, Extension);
482}
483
484llvm::raw_fd_ostream *
485CompilerInstance::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
511llvm::raw_fd_ostream *
512CompilerInstance::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
581bool CompilerInstance::InitializeSourceManager(StringRef InputFile) {
582  return InitializeSourceManager(InputFile, getDiagnostics(), getFileManager(),
583                                 getSourceManager(), getFrontendOpts());
584}
585
586bool 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
619bool 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.
690static 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
700namespace {
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.
709static void doCompileModule(void *UserData) {
710  CompileModuleData &Data = *reinterpret_cast<CompileModuleData *>(UserData);
711  Data.Instance.ExecuteAction(Data.CreateModuleAction);
712}
713
714namespace {
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
773llvm::Optional<std::pair<std::string, int> >
774LockFileManager::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
796bool 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
810LockFileManager::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
890LockFileManager::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
900LockFileManager::~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
910void 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.
966static 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
1035ModuleKey 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