CompilerInstance.cpp revision 392ed2b717d86ebdd202cb9bb58d18d8b3b4cd87 
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                                             getLangOpts().CurrentModule);
282
283  // Handle generating dependencies, if requested.
284  const DependencyOutputOptions &DepOpts = getDependencyOutputOpts();
285  if (!DepOpts.OutputFile.empty())
286    AttachDependencyFileGen(*PP, DepOpts);
287
288  // Handle generating header include information, if requested.
289  if (DepOpts.ShowHeaderIncludes)
290    AttachHeaderIncludeGen(*PP);
291  if (!DepOpts.HeaderIncludeOutputFile.empty()) {
292    StringRef OutputPath = DepOpts.HeaderIncludeOutputFile;
293    if (OutputPath == "-")
294      OutputPath = "";
295    AttachHeaderIncludeGen(*PP, /*ShowAllHeaders=*/true, OutputPath,
296                           /*ShowDepth=*/false);
297  }
298}
299
300// ASTContext
301
302void CompilerInstance::createASTContext() {
303  Preprocessor &PP = getPreprocessor();
304  Context = new ASTContext(getLangOpts(), PP.getSourceManager(),
305                           &getTarget(), PP.getIdentifierTable(),
306                           PP.getSelectorTable(), PP.getBuiltinInfo(),
307                           /*size_reserve=*/ 0);
308}
309
310// ExternalASTSource
311
312void CompilerInstance::createPCHExternalASTSource(StringRef Path,
313                                                  bool DisablePCHValidation,
314                                                  bool DisableStatCache,
315                                                 void *DeserializationListener){
316  llvm::OwningPtr<ExternalASTSource> Source;
317  bool Preamble = getPreprocessorOpts().PrecompiledPreambleBytes.first != 0;
318  Source.reset(createPCHExternalASTSource(Path, getHeaderSearchOpts().Sysroot,
319                                          DisablePCHValidation,
320                                          DisableStatCache,
321                                          getPreprocessor(), getASTContext(),
322                                          DeserializationListener,
323                                          Preamble));
324  ModuleManager = static_cast<ASTReader*>(Source.get());
325  getASTContext().setExternalSource(Source);
326}
327
328ExternalASTSource *
329CompilerInstance::createPCHExternalASTSource(StringRef Path,
330                                             const std::string &Sysroot,
331                                             bool DisablePCHValidation,
332                                             bool DisableStatCache,
333                                             Preprocessor &PP,
334                                             ASTContext &Context,
335                                             void *DeserializationListener,
336                                             bool Preamble) {
337  llvm::OwningPtr<ASTReader> Reader;
338  Reader.reset(new ASTReader(PP, Context,
339                             Sysroot.empty() ? "" : Sysroot.c_str(),
340                             DisablePCHValidation, DisableStatCache));
341
342  Reader->setDeserializationListener(
343            static_cast<ASTDeserializationListener *>(DeserializationListener));
344  switch (Reader->ReadAST(Path,
345                          Preamble ? serialization::MK_Preamble
346                                   : serialization::MK_PCH)) {
347  case ASTReader::Success:
348    // Set the predefines buffer as suggested by the PCH reader. Typically, the
349    // predefines buffer will be empty.
350    PP.setPredefines(Reader->getSuggestedPredefines());
351    return Reader.take();
352
353  case ASTReader::Failure:
354    // Unrecoverable failure: don't even try to process the input file.
355    break;
356
357  case ASTReader::IgnorePCH:
358    // No suitable PCH file could be found. Return an error.
359    break;
360  }
361
362  return 0;
363}
364
365// Code Completion
366
367static bool EnableCodeCompletion(Preprocessor &PP,
368                                 const std::string &Filename,
369                                 unsigned Line,
370                                 unsigned Column) {
371  // Tell the source manager to chop off the given file at a specific
372  // line and column.
373  const FileEntry *Entry = PP.getFileManager().getFile(Filename);
374  if (!Entry) {
375    PP.getDiagnostics().Report(diag::err_fe_invalid_code_complete_file)
376      << Filename;
377    return true;
378  }
379
380  // Truncate the named file at the given line/column.
381  PP.SetCodeCompletionPoint(Entry, Line, Column);
382  return false;
383}
384
385void CompilerInstance::createCodeCompletionConsumer() {
386  const ParsedSourceLocation &Loc = getFrontendOpts().CodeCompletionAt;
387  if (!CompletionConsumer) {
388    CompletionConsumer.reset(
389      createCodeCompletionConsumer(getPreprocessor(),
390                                   Loc.FileName, Loc.Line, Loc.Column,
391                                   getFrontendOpts().ShowMacrosInCodeCompletion,
392                             getFrontendOpts().ShowCodePatternsInCodeCompletion,
393                           getFrontendOpts().ShowGlobalSymbolsInCodeCompletion,
394                                   llvm::outs()));
395    if (!CompletionConsumer)
396      return;
397  } else if (EnableCodeCompletion(getPreprocessor(), Loc.FileName,
398                                  Loc.Line, Loc.Column)) {
399    CompletionConsumer.reset();
400    return;
401  }
402
403  if (CompletionConsumer->isOutputBinary() &&
404      llvm::sys::Program::ChangeStdoutToBinary()) {
405    getPreprocessor().getDiagnostics().Report(diag::err_fe_stdout_binary);
406    CompletionConsumer.reset();
407  }
408}
409
410void CompilerInstance::createFrontendTimer() {
411  FrontendTimer.reset(new llvm::Timer("Clang front-end timer"));
412}
413
414CodeCompleteConsumer *
415CompilerInstance::createCodeCompletionConsumer(Preprocessor &PP,
416                                               const std::string &Filename,
417                                               unsigned Line,
418                                               unsigned Column,
419                                               bool ShowMacros,
420                                               bool ShowCodePatterns,
421                                               bool ShowGlobals,
422                                               raw_ostream &OS) {
423  if (EnableCodeCompletion(PP, Filename, Line, Column))
424    return 0;
425
426  // Set up the creation routine for code-completion.
427  return new PrintingCodeCompleteConsumer(ShowMacros, ShowCodePatterns,
428                                          ShowGlobals, OS);
429}
430
431void CompilerInstance::createSema(TranslationUnitKind TUKind,
432                                  CodeCompleteConsumer *CompletionConsumer) {
433  TheSema.reset(new Sema(getPreprocessor(), getASTContext(), getASTConsumer(),
434                         TUKind, CompletionConsumer));
435}
436
437// Output Files
438
439void CompilerInstance::addOutputFile(const OutputFile &OutFile) {
440  assert(OutFile.OS && "Attempt to add empty stream to output list!");
441  OutputFiles.push_back(OutFile);
442}
443
444void CompilerInstance::clearOutputFiles(bool EraseFiles) {
445  for (std::list<OutputFile>::iterator
446         it = OutputFiles.begin(), ie = OutputFiles.end(); it != ie; ++it) {
447    delete it->OS;
448    if (!it->TempFilename.empty()) {
449      if (EraseFiles) {
450        bool existed;
451        llvm::sys::fs::remove(it->TempFilename, existed);
452      } else {
453        llvm::SmallString<128> NewOutFile(it->Filename);
454
455        // If '-working-directory' was passed, the output filename should be
456        // relative to that.
457        FileMgr->FixupRelativePath(NewOutFile);
458        if (llvm::error_code ec = llvm::sys::fs::rename(it->TempFilename,
459                                                        NewOutFile.str())) {
460          getDiagnostics().Report(diag::err_fe_unable_to_rename_temp)
461            << it->TempFilename << it->Filename << ec.message();
462
463          bool existed;
464          llvm::sys::fs::remove(it->TempFilename, existed);
465        }
466      }
467    } else if (!it->Filename.empty() && EraseFiles)
468      llvm::sys::Path(it->Filename).eraseFromDisk();
469
470  }
471  OutputFiles.clear();
472}
473
474llvm::raw_fd_ostream *
475CompilerInstance::createDefaultOutputFile(bool Binary,
476                                          StringRef InFile,
477                                          StringRef Extension) {
478  return createOutputFile(getFrontendOpts().OutputFile, Binary,
479                          /*RemoveFileOnSignal=*/true, InFile, Extension);
480}
481
482llvm::raw_fd_ostream *
483CompilerInstance::createOutputFile(StringRef OutputPath,
484                                   bool Binary, bool RemoveFileOnSignal,
485                                   StringRef InFile,
486                                   StringRef Extension,
487                                   bool UseTemporary) {
488  std::string Error, OutputPathName, TempPathName;
489  llvm::raw_fd_ostream *OS = createOutputFile(OutputPath, Error, Binary,
490                                              RemoveFileOnSignal,
491                                              InFile, Extension,
492                                              UseTemporary,
493                                              &OutputPathName,
494                                              &TempPathName);
495  if (!OS) {
496    getDiagnostics().Report(diag::err_fe_unable_to_open_output)
497      << OutputPath << Error;
498    return 0;
499  }
500
501  // Add the output file -- but don't try to remove "-", since this means we are
502  // using stdin.
503  addOutputFile(OutputFile((OutputPathName != "-") ? OutputPathName : "",
504                TempPathName, OS));
505
506  return OS;
507}
508
509llvm::raw_fd_ostream *
510CompilerInstance::createOutputFile(StringRef OutputPath,
511                                   std::string &Error,
512                                   bool Binary,
513                                   bool RemoveFileOnSignal,
514                                   StringRef InFile,
515                                   StringRef Extension,
516                                   bool UseTemporary,
517                                   std::string *ResultPathName,
518                                   std::string *TempPathName) {
519  std::string OutFile, TempFile;
520  if (!OutputPath.empty()) {
521    OutFile = OutputPath;
522  } else if (InFile == "-") {
523    OutFile = "-";
524  } else if (!Extension.empty()) {
525    llvm::sys::Path Path(InFile);
526    Path.eraseSuffix();
527    Path.appendSuffix(Extension);
528    OutFile = Path.str();
529  } else {
530    OutFile = "-";
531  }
532
533  llvm::OwningPtr<llvm::raw_fd_ostream> OS;
534  std::string OSFile;
535
536  if (UseTemporary && OutFile != "-") {
537    llvm::sys::Path OutPath(OutFile);
538    // Only create the temporary if we can actually write to OutPath, otherwise
539    // we want to fail early.
540    bool Exists;
541    if ((llvm::sys::fs::exists(OutPath.str(), Exists) || !Exists) ||
542        (OutPath.isRegularFile() && OutPath.canWrite())) {
543      // Create a temporary file.
544      llvm::SmallString<128> TempPath;
545      TempPath = OutFile;
546      TempPath += "-%%%%%%%%";
547      int fd;
548      if (llvm::sys::fs::unique_file(TempPath.str(), fd, TempPath,
549                               /*makeAbsolute=*/false) == llvm::errc::success) {
550        OS.reset(new llvm::raw_fd_ostream(fd, /*shouldClose=*/true));
551        OSFile = TempFile = TempPath.str();
552      }
553    }
554  }
555
556  if (!OS) {
557    OSFile = OutFile;
558    OS.reset(
559      new llvm::raw_fd_ostream(OSFile.c_str(), Error,
560                               (Binary ? llvm::raw_fd_ostream::F_Binary : 0)));
561    if (!Error.empty())
562      return 0;
563  }
564
565  // Make sure the out stream file gets removed if we crash.
566  if (RemoveFileOnSignal)
567    llvm::sys::RemoveFileOnSignal(llvm::sys::Path(OSFile));
568
569  if (ResultPathName)
570    *ResultPathName = OutFile;
571  if (TempPathName)
572    *TempPathName = TempFile;
573
574  return OS.take();
575}
576
577// Initialization Utilities
578
579bool CompilerInstance::InitializeSourceManager(StringRef InputFile) {
580  return InitializeSourceManager(InputFile, getDiagnostics(), getFileManager(),
581                                 getSourceManager(), getFrontendOpts());
582}
583
584bool CompilerInstance::InitializeSourceManager(StringRef InputFile,
585                                               DiagnosticsEngine &Diags,
586                                               FileManager &FileMgr,
587                                               SourceManager &SourceMgr,
588                                               const FrontendOptions &Opts) {
589  // Figure out where to get and map in the main file.
590  if (InputFile != "-") {
591    const FileEntry *File = FileMgr.getFile(InputFile);
592    if (!File) {
593      Diags.Report(diag::err_fe_error_reading) << InputFile;
594      return false;
595    }
596    SourceMgr.createMainFileID(File);
597  } else {
598    llvm::OwningPtr<llvm::MemoryBuffer> SB;
599    if (llvm::MemoryBuffer::getSTDIN(SB)) {
600      // FIXME: Give ec.message() in this diag.
601      Diags.Report(diag::err_fe_error_reading_stdin);
602      return false;
603    }
604    const FileEntry *File = FileMgr.getVirtualFile(SB->getBufferIdentifier(),
605                                                   SB->getBufferSize(), 0);
606    SourceMgr.createMainFileID(File);
607    SourceMgr.overrideFileContents(File, SB.take());
608  }
609
610  assert(!SourceMgr.getMainFileID().isInvalid() &&
611         "Couldn't establish MainFileID!");
612  return true;
613}
614
615// High-Level Operations
616
617bool CompilerInstance::ExecuteAction(FrontendAction &Act) {
618  assert(hasDiagnostics() && "Diagnostics engine is not initialized!");
619  assert(!getFrontendOpts().ShowHelp && "Client must handle '-help'!");
620  assert(!getFrontendOpts().ShowVersion && "Client must handle '-version'!");
621
622  // FIXME: Take this as an argument, once all the APIs we used have moved to
623  // taking it as an input instead of hard-coding llvm::errs.
624  raw_ostream &OS = llvm::errs();
625
626  // Create the target instance.
627  setTarget(TargetInfo::CreateTargetInfo(getDiagnostics(), getTargetOpts()));
628  if (!hasTarget())
629    return false;
630
631  // Inform the target of the language options.
632  //
633  // FIXME: We shouldn't need to do this, the target should be immutable once
634  // created. This complexity should be lifted elsewhere.
635  getTarget().setForcedLangOptions(getLangOpts());
636
637  // Validate/process some options.
638  if (getHeaderSearchOpts().Verbose)
639    OS << "clang -cc1 version " CLANG_VERSION_STRING
640       << " based upon " << PACKAGE_STRING
641       << " default target " << llvm::sys::getDefaultTargetTriple() << "\n";
642
643  if (getFrontendOpts().ShowTimers)
644    createFrontendTimer();
645
646  if (getFrontendOpts().ShowStats)
647    llvm::EnableStatistics();
648
649  for (unsigned i = 0, e = getFrontendOpts().Inputs.size(); i != e; ++i) {
650    const std::string &InFile = getFrontendOpts().Inputs[i].second;
651
652    // Reset the ID tables if we are reusing the SourceManager.
653    if (hasSourceManager())
654      getSourceManager().clearIDTables();
655
656    if (Act.BeginSourceFile(*this, InFile, getFrontendOpts().Inputs[i].first)) {
657      Act.Execute();
658      Act.EndSourceFile();
659    }
660  }
661
662  if (getDiagnosticOpts().ShowCarets) {
663    // We can have multiple diagnostics sharing one diagnostic client.
664    // Get the total number of warnings/errors from the client.
665    unsigned NumWarnings = getDiagnostics().getClient()->getNumWarnings();
666    unsigned NumErrors = getDiagnostics().getClient()->getNumErrors();
667
668    if (NumWarnings)
669      OS << NumWarnings << " warning" << (NumWarnings == 1 ? "" : "s");
670    if (NumWarnings && NumErrors)
671      OS << " and ";
672    if (NumErrors)
673      OS << NumErrors << " error" << (NumErrors == 1 ? "" : "s");
674    if (NumWarnings || NumErrors)
675      OS << " generated.\n";
676  }
677
678  if (getFrontendOpts().ShowStats && hasFileManager()) {
679    getFileManager().PrintStats();
680    OS << "\n";
681  }
682
683  return !getDiagnostics().getClient()->getNumErrors();
684}
685
686/// \brief Determine the appropriate source input kind based on language
687/// options.
688static InputKind getSourceInputKindFromOptions(const LangOptions &LangOpts) {
689  if (LangOpts.OpenCL)
690    return IK_OpenCL;
691  if (LangOpts.CUDA)
692    return IK_CUDA;
693  if (LangOpts.ObjC1)
694    return LangOpts.CPlusPlus? IK_ObjCXX : IK_ObjC;
695  return LangOpts.CPlusPlus? IK_CXX : IK_C;
696}
697
698namespace {
699  struct CompileModuleMapData {
700    CompilerInstance &Instance;
701    GenerateModuleAction &CreateModuleAction;
702  };
703}
704
705/// \brief Helper function that executes the module-generating action under
706/// a crash recovery context.
707static void doCompileMapModule(void *UserData) {
708  CompileModuleMapData &Data
709    = *reinterpret_cast<CompileModuleMapData *>(UserData);
710  Data.Instance.ExecuteAction(Data.CreateModuleAction);
711}
712
713namespace {
714  /// \brief Class that manages the creation of a lock file to aid
715  /// implicit coordination between different processes.
716  ///
717  /// The implicit coordination works by creating a ".lock" file alongside
718  /// the file that we're coordinating for, using the atomicity of the file
719  /// system to ensure that only a single process can create that ".lock" file.
720  /// When the lock file is removed, the owning process has finished the
721  /// operation.
722  class LockFileManager {
723  public:
724    /// \brief Describes the state of a lock file.
725    enum LockFileState {
726      /// \brief The lock file has been created and is owned by this instance
727      /// of the object.
728      LFS_Owned,
729      /// \brief The lock file already exists and is owned by some other
730      /// instance.
731      LFS_Shared,
732      /// \brief An error occurred while trying to create or find the lock
733      /// file.
734      LFS_Error
735    };
736
737  private:
738    llvm::SmallString<128> LockFileName;
739    llvm::SmallString<128> UniqueLockFileName;
740
741    llvm::Optional<std::pair<std::string, int> > Owner;
742    llvm::Optional<llvm::error_code> Error;
743
744    LockFileManager(const LockFileManager &);
745    LockFileManager &operator=(const LockFileManager &);
746
747    static llvm::Optional<std::pair<std::string, int> >
748    readLockFile(StringRef LockFileName);
749
750    static bool processStillExecuting(StringRef Hostname, int PID);
751
752  public:
753
754    LockFileManager(StringRef FileName);
755    ~LockFileManager();
756
757    /// \brief Determine the state of the lock file.
758    LockFileState getState() const;
759
760    operator LockFileState() const { return getState(); }
761
762    /// \brief For a shared lock, wait until the owner releases the lock.
763    void waitForUnlock();
764  };
765}
766
767/// \brief Attempt to read the lock file with the given name, if it exists.
768///
769/// \param LockFileName The name of the lock file to read.
770///
771/// \returns The process ID of the process that owns this lock file
772llvm::Optional<std::pair<std::string, int> >
773LockFileManager::readLockFile(StringRef LockFileName) {
774  // Check whether the lock file exists. If not, clearly there's nothing
775  // to read, so we just return.
776  bool Exists = false;
777  if (llvm::sys::fs::exists(LockFileName, Exists) || !Exists)
778    return llvm::Optional<std::pair<std::string, int> >();
779
780  // Read the owning host and PID out of the lock file. If it appears that the
781  // owning process is dead, the lock file is invalid.
782  int PID = 0;
783  std::string Hostname;
784  std::ifstream Input(LockFileName.str().c_str());
785  if (Input >> Hostname >> PID && PID > 0 &&
786      processStillExecuting(Hostname, PID))
787    return std::make_pair(Hostname, PID);
788
789  // Delete the lock file. It's invalid anyway.
790  bool Existed;
791  llvm::sys::fs::remove(LockFileName, Existed);
792  return llvm::Optional<std::pair<std::string, int> >();
793}
794
795bool LockFileManager::processStillExecuting(StringRef Hostname, int PID) {
796#if LLVM_ON_UNIX
797  char MyHostname[256];
798  MyHostname[255] = 0;
799  MyHostname[0] = 0;
800  gethostname(MyHostname, 255);
801  // Check whether the process is dead. If so, we're done.
802  if (MyHostname == Hostname && getsid(PID) == -1 && errno == ESRCH)
803    return false;
804#endif
805
806  return true;
807}
808
809LockFileManager::LockFileManager(StringRef FileName)
810{
811  LockFileName = FileName;
812  LockFileName += ".lock";
813
814  // If the lock file already exists, don't bother to try to create our own
815  // lock file; it won't work anyway. Just figure out who owns this lock file.
816  if ((Owner = readLockFile(LockFileName)))
817    return;
818
819  // Create a lock file that is unique to this instance.
820  UniqueLockFileName = LockFileName;
821  UniqueLockFileName += "-%%%%%%%%";
822  int UniqueLockFileID;
823  if (llvm::error_code EC
824        = llvm::sys::fs::unique_file(UniqueLockFileName.str(),
825                                     UniqueLockFileID,
826                                     UniqueLockFileName,
827                                     /*makeAbsolute=*/false)) {
828    Error = EC;
829    return;
830  }
831
832  // Write our process ID to our unique lock file.
833  {
834    llvm::raw_fd_ostream Out(UniqueLockFileID, /*shouldClose=*/true);
835
836#if LLVM_ON_UNIX
837    // FIXME: move getpid() call into LLVM
838    char hostname[256];
839    hostname[255] = 0;
840    hostname[0] = 0;
841    gethostname(hostname, 255);
842    Out << hostname << ' ' << getpid();
843#else
844    Out << "localhost 1";
845#endif
846    Out.close();
847
848    if (Out.has_error()) {
849      // We failed to write out PID, so make up an excuse, remove the
850      // unique lock file, and fail.
851      Error = llvm::make_error_code(llvm::errc::no_space_on_device);
852      bool Existed;
853      llvm::sys::fs::remove(UniqueLockFileName.c_str(), Existed);
854      return;
855    }
856  }
857
858  // Create a hard link from the lock file name. If this succeeds, we're done.
859  llvm::error_code EC
860    = llvm::sys::fs::create_hard_link(UniqueLockFileName.str(),
861                                      LockFileName.str());
862  if (EC == llvm::errc::success)
863    return;
864
865  // Creating the hard link failed.
866
867#ifdef LLVM_ON_UNIX
868  // The creation of the hard link may appear to fail, but if stat'ing the
869  // unique file returns a link count of 2, then we can still declare success.
870  struct stat StatBuf;
871  if (stat(UniqueLockFileName.c_str(), &StatBuf) == 0 &&
872      StatBuf.st_nlink == 2)
873    return;
874#endif
875
876  // Someone else managed to create the lock file first. Wipe out our unique
877  // lock file (it's useless now) and read the process ID from the lock file.
878  bool Existed;
879  llvm::sys::fs::remove(UniqueLockFileName.str(), Existed);
880  if ((Owner = readLockFile(LockFileName)))
881    return;
882
883  // There is a lock file that nobody owns; try to clean it up and report
884  // an error.
885  llvm::sys::fs::remove(LockFileName.str(), Existed);
886  Error = EC;
887}
888
889LockFileManager::LockFileState LockFileManager::getState() const {
890  if (Owner)
891    return LFS_Shared;
892
893  if (Error)
894    return LFS_Error;
895
896  return LFS_Owned;
897}
898
899LockFileManager::~LockFileManager() {
900  if (getState() != LFS_Owned)
901    return;
902
903  // Since we own the lock, remove the lock file and our own unique lock file.
904  bool Existed;
905  llvm::sys::fs::remove(LockFileName.str(), Existed);
906  llvm::sys::fs::remove(UniqueLockFileName.str(), Existed);
907}
908
909void LockFileManager::waitForUnlock() {
910  if (getState() != LFS_Shared)
911    return;
912
913#if LLVM_ON_WIN32
914  unsigned long Interval = 1;
915#else
916  struct timespec Interval;
917  Interval.tv_sec = 0;
918  Interval.tv_nsec = 1000000;
919#endif
920  // Don't wait more than an hour for the file to appear.
921  const unsigned MaxSeconds = 3600;
922  do {
923    // Sleep for the designated interval, to allow the owning process time to
924    // finish up and
925    // FIXME: Should we hook in to system APIs to get a notification when the
926    // lock file is deleted?
927#if LLVM_ON_WIN32
928    Sleep(Interval);
929#else
930    nanosleep(&Interval, NULL);
931#endif
932    // If the file no longer exists, we're done.
933    bool Exists = false;
934    if (!llvm::sys::fs::exists(LockFileName.str(), Exists) && !Exists)
935      return;
936
937    if (!processStillExecuting((*Owner).first, (*Owner).second))
938      return;
939
940    // Exponentially increase the time we wait for the lock to be removed.
941#if LLVM_ON_WIN32
942    Interval *= 2;
943#else
944    Interval.tv_sec *= 2;
945    Interval.tv_nsec *= 2;
946    if (Interval.tv_nsec >= 1000000000) {
947      ++Interval.tv_sec;
948      Interval.tv_nsec -= 1000000000;
949    }
950#endif
951  } while (
952#if LLVM_ON_WIN32
953           Interval < MaxSeconds * 1000
954#else
955           Interval.tv_sec < (time_t)MaxSeconds
956#endif
957           );
958
959  // Give up.
960}
961
962/// \brief Compile a module file for the given module, using the options
963/// provided by the importing compiler instance.
964static void compileModule(CompilerInstance &ImportingInstance,
965                          ModuleMap::Module *Module,
966                          StringRef ModuleFileName) {
967  LockFileManager Locked(ModuleFileName);
968  switch (Locked) {
969  case LockFileManager::LFS_Error:
970    return;
971
972  case LockFileManager::LFS_Owned:
973    // We're responsible for building the module ourselves. Do so below.
974    break;
975
976  case LockFileManager::LFS_Shared:
977    // Someone else is responsible for building the module. Wait for them to
978    // finish.
979    Locked.waitForUnlock();
980    break;
981  }
982
983  ModuleMap &ModMap
984    = ImportingInstance.getPreprocessor().getHeaderSearchInfo().getModuleMap();
985
986  // Construct a compiler invocation for creating this module.
987  llvm::IntrusiveRefCntPtr<CompilerInvocation> Invocation
988    (new CompilerInvocation(ImportingInstance.getInvocation()));
989
990  PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts();
991
992  // For any options that aren't intended to affect how a module is built,
993  // reset them to their default values.
994  Invocation->getLangOpts()->resetNonModularOptions();
995  PPOpts.resetNonModularOptions();
996
997  // Note the name of the module we're building.
998  Invocation->getLangOpts()->CurrentModule = Module->getTopLevelModuleName();
999
1000  // Note that this module is part of the module build path, so that we
1001  // can detect cycles in the module graph.
1002  PPOpts.ModuleBuildPath.push_back(Module->getTopLevelModuleName());
1003
1004  // If there is a module map file, build the module using the module map.
1005  // Set up the inputs/outputs so that we build the module from its umbrella
1006  // header.
1007  FrontendOptions &FrontendOpts = Invocation->getFrontendOpts();
1008  FrontendOpts.OutputFile = ModuleFileName.str();
1009  FrontendOpts.DisableFree = false;
1010  FrontendOpts.Inputs.clear();
1011  InputKind IK = getSourceInputKindFromOptions(*Invocation->getLangOpts());
1012
1013  // Get or create the module map that we'll use to build this module.
1014  llvm::SmallString<128> TempModuleMapFileName;
1015  if (const FileEntry *ModuleMapFile
1016                                  = ModMap.getContainingModuleMapFile(Module)) {
1017    // Use the module map where this module resides.
1018    FrontendOpts.Inputs.push_back(std::make_pair(IK, ModuleMapFile->getName()));
1019  } else {
1020    // Create a temporary module map file.
1021    TempModuleMapFileName = Module->Name;
1022    TempModuleMapFileName += "-%%%%%%%%.map";
1023    int FD;
1024    if (llvm::sys::fs::unique_file(TempModuleMapFileName.str(), FD,
1025                                   TempModuleMapFileName,
1026                                   /*makeAbsolute=*/false)
1027          != llvm::errc::success)
1028      return;
1029
1030    // Print the module map to this file.
1031    llvm::raw_fd_ostream OS(FD, /*shouldClose=*/true);
1032    Module->print(OS);
1033    FrontendOpts.Inputs.push_back(
1034      std::make_pair(IK, TempModuleMapFileName.str().str()));
1035  }
1036
1037  // Don't free the remapped file buffers; they are owned by our caller.
1038  PPOpts.RetainRemappedFileBuffers = true;
1039
1040  Invocation->getDiagnosticOpts().VerifyDiagnostics = 0;
1041  assert(ImportingInstance.getInvocation().getModuleHash() ==
1042         Invocation->getModuleHash() && "Module hash mismatch!");
1043
1044  // Construct a compiler instance that will be used to actually create the
1045  // module.
1046  CompilerInstance Instance;
1047  Instance.setInvocation(&*Invocation);
1048  Instance.createDiagnostics(/*argc=*/0, /*argv=*/0,
1049                             &ImportingInstance.getDiagnosticClient(),
1050                             /*ShouldOwnClient=*/true,
1051                             /*ShouldCloneClient=*/true);
1052
1053  // Construct a module-generating action.
1054  GenerateModuleAction CreateModuleAction;
1055
1056  // Execute the action to actually build the module in-place. Use a separate
1057  // thread so that we get a stack large enough.
1058  const unsigned ThreadStackSize = 8 << 20;
1059  llvm::CrashRecoveryContext CRC;
1060  CompileModuleMapData Data = { Instance, CreateModuleAction };
1061  CRC.RunSafelyOnThread(&doCompileMapModule, &Data, ThreadStackSize);
1062
1063  // Delete the temporary module map file.
1064  // FIXME: Even though we're executing under crash protection, it would still
1065  // be nice to do this with RemoveFileOnSignal when we can. However, that
1066  // doesn't make sense for all clients, so clean this up manually.
1067  if (!TempModuleMapFileName.empty())
1068    llvm::sys::Path(TempModuleMapFileName).eraseFromDisk();
1069}
1070
1071ModuleKey CompilerInstance::loadModule(SourceLocation ImportLoc,
1072                                       ModuleIdPath Path) {
1073  // If we've already handled this import, just return the cached result.
1074  // This one-element cache is important to eliminate redundant diagnostics
1075  // when both the preprocessor and parser see the same import declaration.
1076  if (!ImportLoc.isInvalid() && LastModuleImportLoc == ImportLoc)
1077    return LastModuleImportResult;
1078
1079  // Determine what file we're searching from.
1080  SourceManager &SourceMgr = getSourceManager();
1081  SourceLocation ExpandedImportLoc = SourceMgr.getExpansionLoc(ImportLoc);
1082  const FileEntry *CurFile
1083    = SourceMgr.getFileEntryForID(SourceMgr.getFileID(ExpandedImportLoc));
1084  if (!CurFile)
1085    CurFile = SourceMgr.getFileEntryForID(SourceMgr.getMainFileID());
1086
1087  StringRef ModuleName = Path[0].first->getName();
1088  SourceLocation ModuleNameLoc = Path[0].second;
1089
1090  ModuleMap::Module *Module = 0;
1091  const FileEntry *ModuleFile = 0;
1092
1093  // If we don't already have information on this module, load the module now.
1094  llvm::DenseMap<const IdentifierInfo *, ModuleMap::Module *>::iterator Known
1095    = KnownModules.find(Path[0].first);
1096  if (Known == KnownModules.end()) {
1097    // Search for a module with the given name.
1098    std::string ModuleFileName;
1099    ModuleFile
1100      = PP->getHeaderSearchInfo().lookupModule(ModuleName, Module,
1101                                               &ModuleFileName);
1102
1103    bool BuildingModule = false;
1104    if (!ModuleFile && Module) {
1105      // The module is not cached, but we have a module map from which we can
1106      // build the module.
1107
1108      // Check whether there is a cycle in the module graph.
1109      SmallVectorImpl<std::string> &ModuleBuildPath
1110        = getPreprocessorOpts().ModuleBuildPath;
1111      SmallVectorImpl<std::string>::iterator Pos
1112        = std::find(ModuleBuildPath.begin(), ModuleBuildPath.end(), ModuleName);
1113      if (Pos != ModuleBuildPath.end()) {
1114        llvm::SmallString<256> CyclePath;
1115        for (; Pos != ModuleBuildPath.end(); ++Pos) {
1116          CyclePath += *Pos;
1117          CyclePath += " -> ";
1118        }
1119        CyclePath += ModuleName;
1120
1121        getDiagnostics().Report(ModuleNameLoc, diag::err_module_cycle)
1122          << ModuleName << CyclePath;
1123        return 0;
1124      }
1125
1126      getDiagnostics().Report(ModuleNameLoc, diag::warn_module_build)
1127        << ModuleName;
1128      BuildingModule = true;
1129      compileModule(*this, Module, ModuleFileName);
1130      ModuleFile = FileMgr->getFile(ModuleFileName);
1131    }
1132
1133    if (!ModuleFile) {
1134      getDiagnostics().Report(ModuleNameLoc,
1135                              BuildingModule? diag::err_module_not_built
1136                                            : diag::err_module_not_found)
1137        << ModuleName
1138        << SourceRange(ImportLoc, ModuleNameLoc);
1139      return 0;
1140    }
1141
1142    // If we don't already have an ASTReader, create one now.
1143    if (!ModuleManager) {
1144      if (!hasASTContext())
1145        createASTContext();
1146
1147      std::string Sysroot = getHeaderSearchOpts().Sysroot;
1148      const PreprocessorOptions &PPOpts = getPreprocessorOpts();
1149      ModuleManager = new ASTReader(getPreprocessor(), *Context,
1150                                    Sysroot.empty() ? "" : Sysroot.c_str(),
1151                                    PPOpts.DisablePCHValidation,
1152                                    PPOpts.DisableStatCache);
1153      if (hasASTConsumer()) {
1154        ModuleManager->setDeserializationListener(
1155          getASTConsumer().GetASTDeserializationListener());
1156        getASTContext().setASTMutationListener(
1157          getASTConsumer().GetASTMutationListener());
1158      }
1159      llvm::OwningPtr<ExternalASTSource> Source;
1160      Source.reset(ModuleManager);
1161      getASTContext().setExternalSource(Source);
1162      if (hasSema())
1163        ModuleManager->InitializeSema(getSema());
1164      if (hasASTConsumer())
1165        ModuleManager->StartTranslationUnit(&getASTConsumer());
1166    }
1167
1168    // Try to load the module we found.
1169    switch (ModuleManager->ReadAST(ModuleFile->getName(),
1170                                   serialization::MK_Module)) {
1171    case ASTReader::Success:
1172      break;
1173
1174    case ASTReader::IgnorePCH:
1175      // FIXME: The ASTReader will already have complained, but can we showhorn
1176      // that diagnostic information into a more useful form?
1177      KnownModules[Path[0].first] = 0;
1178      return 0;
1179
1180    case ASTReader::Failure:
1181      // Already complained, but note now that we failed.
1182      KnownModules[Path[0].first] = 0;
1183      return 0;
1184    }
1185
1186    if (!Module) {
1187      // If we loaded the module directly, without finding a module map first,
1188      // we'll have loaded the module's information from the module itself.
1189      Module = PP->getHeaderSearchInfo().getModuleMap()
1190                 .findModule((Path[0].first->getName()));
1191    }
1192
1193    // Cache the result of this top-level module lookup for later.
1194    Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
1195  } else {
1196    // Retrieve the cached top-level module.
1197    Module = Known->second;
1198  }
1199
1200  // If we never found the module, fail.
1201  if (!Module)
1202    return 0;
1203
1204  // Verify that the rest of the module path actually corresponds to
1205  // a submodule.
1206  if (Path.size() > 1) {
1207    for (unsigned I = 1, N = Path.size(); I != N; ++I) {
1208      StringRef Name = Path[I].first->getName();
1209      llvm::StringMap<ModuleMap::Module *>::iterator Pos
1210        = Module->SubModules.find(Name);
1211
1212      if (Pos == Module->SubModules.end()) {
1213        // Attempt to perform typo correction to find a module name that works.
1214        llvm::SmallVector<StringRef, 2> Best;
1215        unsigned BestEditDistance = (std::numeric_limits<unsigned>::max)();
1216
1217        for (llvm::StringMap<ModuleMap::Module *>::iterator
1218                  I = Module->SubModules.begin(),
1219               IEnd = Module->SubModules.end();
1220             I != IEnd; ++I) {
1221          unsigned ED = Name.edit_distance(I->getValue()->Name,
1222                                           /*AllowReplacements=*/true,
1223                                           BestEditDistance);
1224          if (ED <= BestEditDistance) {
1225            if (ED < BestEditDistance)
1226              Best.clear();
1227            Best.push_back(I->getValue()->Name);
1228          }
1229        }
1230
1231        // If there was a clear winner, user it.
1232        if (Best.size() == 1) {
1233          getDiagnostics().Report(Path[I].second,
1234                                  diag::err_no_submodule_suggest)
1235            << Path[I].first << Module->getFullModuleName() << Best[0]
1236            << SourceRange(Path[0].second, Path[I-1].second)
1237            << FixItHint::CreateReplacement(SourceRange(Path[I].second),
1238                                            Best[0]);
1239          Pos = Module->SubModules.find(Best[0]);
1240        }
1241      }
1242
1243      if (Pos == Module->SubModules.end()) {
1244        // No submodule by this name. Complain, and don't look for further
1245        // submodules.
1246        getDiagnostics().Report(Path[I].second, diag::err_no_submodule)
1247          << Path[I].first << Module->getFullModuleName()
1248          << SourceRange(Path[0].second, Path[I-1].second);
1249        break;
1250      }
1251
1252      Module = Pos->getValue();
1253    }
1254  }
1255
1256  // FIXME: Tell the AST reader to make the named submodule visible.
1257
1258  LastModuleImportLoc = ImportLoc;
1259  LastModuleImportResult = Module;
1260  return Module;
1261}
1262
1263