CompilerInstance.cpp revision 651f13cea278ec967336033dd032faef0e9fc2ec 
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/AST/ASTConsumer.h"
12#include "clang/AST/ASTContext.h"
13#include "clang/AST/Decl.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/Frontend/ChainedDiagnosticConsumer.h"
20#include "clang/Frontend/FrontendAction.h"
21#include "clang/Frontend/FrontendActions.h"
22#include "clang/Frontend/FrontendDiagnostic.h"
23#include "clang/Frontend/LogDiagnosticPrinter.h"
24#include "clang/Frontend/SerializedDiagnosticPrinter.h"
25#include "clang/Frontend/TextDiagnosticPrinter.h"
26#include "clang/Frontend/Utils.h"
27#include "clang/Frontend/VerifyDiagnosticConsumer.h"
28#include "clang/Lex/HeaderSearch.h"
29#include "clang/Lex/PTHManager.h"
30#include "clang/Lex/Preprocessor.h"
31#include "clang/Sema/CodeCompleteConsumer.h"
32#include "clang/Sema/Sema.h"
33#include "clang/Serialization/ASTReader.h"
34#include "llvm/ADT/Statistic.h"
35#include "llvm/Config/config.h"
36#include "llvm/Support/CrashRecoveryContext.h"
37#include "llvm/Support/FileSystem.h"
38#include "llvm/Support/Host.h"
39#include "llvm/Support/LockFileManager.h"
40#include "llvm/Support/MemoryBuffer.h"
41#include "llvm/Support/Path.h"
42#include "llvm/Support/Program.h"
43#include "llvm/Support/Signals.h"
44#include "llvm/Support/Timer.h"
45#include "llvm/Support/raw_ostream.h"
46#include "llvm/Support/system_error.h"
47#include <sys/stat.h>
48#include <time.h>
49
50using namespace clang;
51
52CompilerInstance::CompilerInstance()
53  : Invocation(new CompilerInvocation()), ModuleManager(0),
54    BuildGlobalModuleIndex(false), ModuleBuildFailed(false) {
55}
56
57CompilerInstance::~CompilerInstance() {
58  assert(OutputFiles.empty() && "Still output files in flight?");
59}
60
61void CompilerInstance::setInvocation(CompilerInvocation *Value) {
62  Invocation = Value;
63}
64
65bool CompilerInstance::shouldBuildGlobalModuleIndex() const {
66  return (BuildGlobalModuleIndex ||
67          (ModuleManager && ModuleManager->isGlobalIndexUnavailable() &&
68           getFrontendOpts().GenerateGlobalModuleIndex)) &&
69         !ModuleBuildFailed;
70}
71
72void CompilerInstance::setDiagnostics(DiagnosticsEngine *Value) {
73  Diagnostics = Value;
74}
75
76void CompilerInstance::setTarget(TargetInfo *Value) {
77  Target = Value;
78}
79
80void CompilerInstance::setFileManager(FileManager *Value) {
81  FileMgr = Value;
82  if (Value)
83    VirtualFileSystem = Value->getVirtualFileSystem();
84  else
85    VirtualFileSystem.reset();
86}
87
88void CompilerInstance::setSourceManager(SourceManager *Value) {
89  SourceMgr = Value;
90}
91
92void CompilerInstance::setPreprocessor(Preprocessor *Value) { PP = Value; }
93
94void CompilerInstance::setASTContext(ASTContext *Value) { Context = Value; }
95
96void CompilerInstance::setSema(Sema *S) {
97  TheSema.reset(S);
98}
99
100void CompilerInstance::setASTConsumer(ASTConsumer *Value) {
101  Consumer.reset(Value);
102}
103
104void CompilerInstance::setCodeCompletionConsumer(CodeCompleteConsumer *Value) {
105  CompletionConsumer.reset(Value);
106}
107
108IntrusiveRefCntPtr<ASTReader> CompilerInstance::getModuleManager() const {
109  return ModuleManager;
110}
111void CompilerInstance::setModuleManager(IntrusiveRefCntPtr<ASTReader> Reader) {
112  ModuleManager = Reader;
113}
114
115// Diagnostics
116static void SetUpDiagnosticLog(DiagnosticOptions *DiagOpts,
117                               const CodeGenOptions *CodeGenOpts,
118                               DiagnosticsEngine &Diags) {
119  std::string ErrorInfo;
120  bool OwnsStream = false;
121  raw_ostream *OS = &llvm::errs();
122  if (DiagOpts->DiagnosticLogFile != "-") {
123    // Create the output stream.
124    llvm::raw_fd_ostream *FileOS(new llvm::raw_fd_ostream(
125        DiagOpts->DiagnosticLogFile.c_str(), ErrorInfo,
126        llvm::sys::fs::F_Append | llvm::sys::fs::F_Text));
127    if (!ErrorInfo.empty()) {
128      Diags.Report(diag::warn_fe_cc_log_diagnostics_failure)
129        << DiagOpts->DiagnosticLogFile << ErrorInfo;
130    } else {
131      FileOS->SetUnbuffered();
132      FileOS->SetUseAtomicWrites(true);
133      OS = FileOS;
134      OwnsStream = true;
135    }
136  }
137
138  // Chain in the diagnostic client which will log the diagnostics.
139  LogDiagnosticPrinter *Logger = new LogDiagnosticPrinter(*OS, DiagOpts,
140                                                          OwnsStream);
141  if (CodeGenOpts)
142    Logger->setDwarfDebugFlags(CodeGenOpts->DwarfDebugFlags);
143  Diags.setClient(new ChainedDiagnosticConsumer(Diags.takeClient(), Logger));
144}
145
146static void SetupSerializedDiagnostics(DiagnosticOptions *DiagOpts,
147                                       DiagnosticsEngine &Diags,
148                                       StringRef OutputFile) {
149  std::string ErrorInfo;
150  std::unique_ptr<llvm::raw_fd_ostream> OS;
151  OS.reset(new llvm::raw_fd_ostream(OutputFile.str().c_str(), ErrorInfo,
152                                    llvm::sys::fs::F_None));
153
154  if (!ErrorInfo.empty()) {
155    Diags.Report(diag::warn_fe_serialized_diag_failure)
156      << OutputFile << ErrorInfo;
157    return;
158  }
159
160  DiagnosticConsumer *SerializedConsumer =
161      clang::serialized_diags::create(OS.release(), DiagOpts);
162
163  Diags.setClient(new ChainedDiagnosticConsumer(Diags.takeClient(),
164                                                SerializedConsumer));
165}
166
167void CompilerInstance::createDiagnostics(DiagnosticConsumer *Client,
168                                         bool ShouldOwnClient) {
169  Diagnostics = createDiagnostics(&getDiagnosticOpts(), Client,
170                                  ShouldOwnClient, &getCodeGenOpts());
171}
172
173IntrusiveRefCntPtr<DiagnosticsEngine>
174CompilerInstance::createDiagnostics(DiagnosticOptions *Opts,
175                                    DiagnosticConsumer *Client,
176                                    bool ShouldOwnClient,
177                                    const CodeGenOptions *CodeGenOpts) {
178  IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
179  IntrusiveRefCntPtr<DiagnosticsEngine>
180      Diags(new DiagnosticsEngine(DiagID, Opts));
181
182  // Create the diagnostic client for reporting errors or for
183  // implementing -verify.
184  if (Client) {
185    Diags->setClient(Client, ShouldOwnClient);
186  } else
187    Diags->setClient(new TextDiagnosticPrinter(llvm::errs(), Opts));
188
189  // Chain in -verify checker, if requested.
190  if (Opts->VerifyDiagnostics)
191    Diags->setClient(new VerifyDiagnosticConsumer(*Diags));
192
193  // Chain in -diagnostic-log-file dumper, if requested.
194  if (!Opts->DiagnosticLogFile.empty())
195    SetUpDiagnosticLog(Opts, CodeGenOpts, *Diags);
196
197  if (!Opts->DiagnosticSerializationFile.empty())
198    SetupSerializedDiagnostics(Opts, *Diags,
199                               Opts->DiagnosticSerializationFile);
200
201  // Configure our handling of diagnostics.
202  ProcessWarningOptions(*Diags, *Opts);
203
204  return Diags;
205}
206
207// File Manager
208
209void CompilerInstance::createFileManager() {
210  if (!hasVirtualFileSystem()) {
211    // TODO: choose the virtual file system based on the CompilerInvocation.
212    setVirtualFileSystem(vfs::getRealFileSystem());
213  }
214  FileMgr = new FileManager(getFileSystemOpts(), VirtualFileSystem);
215}
216
217// Source Manager
218
219void CompilerInstance::createSourceManager(FileManager &FileMgr) {
220  SourceMgr = new SourceManager(getDiagnostics(), FileMgr);
221}
222
223// Preprocessor
224
225void CompilerInstance::createPreprocessor(TranslationUnitKind TUKind) {
226  const PreprocessorOptions &PPOpts = getPreprocessorOpts();
227
228  // Create a PTH manager if we are using some form of a token cache.
229  PTHManager *PTHMgr = 0;
230  if (!PPOpts.TokenCache.empty())
231    PTHMgr = PTHManager::Create(PPOpts.TokenCache, getDiagnostics());
232
233  // Create the Preprocessor.
234  HeaderSearch *HeaderInfo = new HeaderSearch(&getHeaderSearchOpts(),
235                                              getSourceManager(),
236                                              getDiagnostics(),
237                                              getLangOpts(),
238                                              &getTarget());
239  PP = new Preprocessor(&getPreprocessorOpts(),
240                        getDiagnostics(), getLangOpts(), &getTarget(),
241                        getSourceManager(), *HeaderInfo, *this, PTHMgr,
242                        /*OwnsHeaderSearch=*/true,
243                        /*DelayInitialization=*/false,
244                        /*IncrProcessing=*/false,
245                        TUKind);
246
247  // Note that this is different then passing PTHMgr to Preprocessor's ctor.
248  // That argument is used as the IdentifierInfoLookup argument to
249  // IdentifierTable's ctor.
250  if (PTHMgr) {
251    PTHMgr->setPreprocessor(&*PP);
252    PP->setPTHManager(PTHMgr);
253  }
254
255  if (PPOpts.DetailedRecord)
256    PP->createPreprocessingRecord();
257
258  InitializePreprocessor(*PP, PPOpts, getHeaderSearchOpts(), getFrontendOpts());
259
260  PP->setPreprocessedOutput(getPreprocessorOutputOpts().ShowCPP);
261
262  // Set up the module path, including the hash for the
263  // module-creation options.
264  SmallString<256> SpecificModuleCache(
265                           getHeaderSearchOpts().ModuleCachePath);
266  if (!getHeaderSearchOpts().DisableModuleHash)
267    llvm::sys::path::append(SpecificModuleCache,
268                            getInvocation().getModuleHash());
269  PP->getHeaderSearchInfo().setModuleCachePath(SpecificModuleCache);
270
271  // Handle generating dependencies, if requested.
272  const DependencyOutputOptions &DepOpts = getDependencyOutputOpts();
273  if (!DepOpts.OutputFile.empty())
274    TheDependencyFileGenerator.reset(
275        DependencyFileGenerator::CreateAndAttachToPreprocessor(*PP, DepOpts));
276  if (!DepOpts.DOTOutputFile.empty())
277    AttachDependencyGraphGen(*PP, DepOpts.DOTOutputFile,
278                             getHeaderSearchOpts().Sysroot);
279
280
281  // Handle generating header include information, if requested.
282  if (DepOpts.ShowHeaderIncludes)
283    AttachHeaderIncludeGen(*PP);
284  if (!DepOpts.HeaderIncludeOutputFile.empty()) {
285    StringRef OutputPath = DepOpts.HeaderIncludeOutputFile;
286    if (OutputPath == "-")
287      OutputPath = "";
288    AttachHeaderIncludeGen(*PP, /*ShowAllHeaders=*/true, OutputPath,
289                           /*ShowDepth=*/false);
290  }
291
292  if (DepOpts.PrintShowIncludes) {
293    AttachHeaderIncludeGen(*PP, /*ShowAllHeaders=*/false, /*OutputPath=*/"",
294                           /*ShowDepth=*/true, /*MSStyle=*/true);
295  }
296}
297
298// ASTContext
299
300void CompilerInstance::createASTContext() {
301  Preprocessor &PP = getPreprocessor();
302  Context = new ASTContext(getLangOpts(), PP.getSourceManager(),
303                           &getTarget(), PP.getIdentifierTable(),
304                           PP.getSelectorTable(), PP.getBuiltinInfo(),
305                           /*size_reserve=*/ 0);
306}
307
308// ExternalASTSource
309
310void CompilerInstance::createPCHExternalASTSource(StringRef Path,
311                                                  bool DisablePCHValidation,
312                                                bool AllowPCHWithCompilerErrors,
313                                                 void *DeserializationListener){
314  IntrusiveRefCntPtr<ExternalASTSource> Source;
315  bool Preamble = getPreprocessorOpts().PrecompiledPreambleBytes.first != 0;
316  Source = createPCHExternalASTSource(Path, getHeaderSearchOpts().Sysroot,
317                                          DisablePCHValidation,
318                                          AllowPCHWithCompilerErrors,
319                                          getPreprocessor(), getASTContext(),
320                                          DeserializationListener,
321                                          Preamble,
322                                       getFrontendOpts().UseGlobalModuleIndex);
323  ModuleManager = static_cast<ASTReader*>(Source.getPtr());
324  getASTContext().setExternalSource(Source);
325}
326
327ExternalASTSource *
328CompilerInstance::createPCHExternalASTSource(StringRef Path,
329                                             const std::string &Sysroot,
330                                             bool DisablePCHValidation,
331                                             bool AllowPCHWithCompilerErrors,
332                                             Preprocessor &PP,
333                                             ASTContext &Context,
334                                             void *DeserializationListener,
335                                             bool Preamble,
336                                             bool UseGlobalModuleIndex) {
337  HeaderSearchOptions &HSOpts = PP.getHeaderSearchInfo().getHeaderSearchOpts();
338
339  std::unique_ptr<ASTReader> Reader;
340  Reader.reset(new ASTReader(PP, Context,
341                             Sysroot.empty() ? "" : Sysroot.c_str(),
342                             DisablePCHValidation,
343                             AllowPCHWithCompilerErrors,
344                             /*AllowConfigurationMismatch*/false,
345                             HSOpts.ModulesValidateSystemHeaders,
346                             UseGlobalModuleIndex));
347
348  Reader->setDeserializationListener(
349            static_cast<ASTDeserializationListener *>(DeserializationListener));
350  switch (Reader->ReadAST(Path,
351                          Preamble ? serialization::MK_Preamble
352                                   : serialization::MK_PCH,
353                          SourceLocation(),
354                          ASTReader::ARR_None)) {
355  case ASTReader::Success:
356    // Set the predefines buffer as suggested by the PCH reader. Typically, the
357    // predefines buffer will be empty.
358    PP.setPredefines(Reader->getSuggestedPredefines());
359    return Reader.release();
360
361  case ASTReader::Failure:
362    // Unrecoverable failure: don't even try to process the input file.
363    break;
364
365  case ASTReader::Missing:
366  case ASTReader::OutOfDate:
367  case ASTReader::VersionMismatch:
368  case ASTReader::ConfigurationMismatch:
369  case ASTReader::HadErrors:
370    // No suitable PCH file could be found. Return an error.
371    break;
372  }
373
374  return 0;
375}
376
377// Code Completion
378
379static bool EnableCodeCompletion(Preprocessor &PP,
380                                 const std::string &Filename,
381                                 unsigned Line,
382                                 unsigned Column) {
383  // Tell the source manager to chop off the given file at a specific
384  // line and column.
385  const FileEntry *Entry = PP.getFileManager().getFile(Filename);
386  if (!Entry) {
387    PP.getDiagnostics().Report(diag::err_fe_invalid_code_complete_file)
388      << Filename;
389    return true;
390  }
391
392  // Truncate the named file at the given line/column.
393  PP.SetCodeCompletionPoint(Entry, Line, Column);
394  return false;
395}
396
397void CompilerInstance::createCodeCompletionConsumer() {
398  const ParsedSourceLocation &Loc = getFrontendOpts().CodeCompletionAt;
399  if (!CompletionConsumer) {
400    setCodeCompletionConsumer(
401      createCodeCompletionConsumer(getPreprocessor(),
402                                   Loc.FileName, Loc.Line, Loc.Column,
403                                   getFrontendOpts().CodeCompleteOpts,
404                                   llvm::outs()));
405    if (!CompletionConsumer)
406      return;
407  } else if (EnableCodeCompletion(getPreprocessor(), Loc.FileName,
408                                  Loc.Line, Loc.Column)) {
409    setCodeCompletionConsumer(0);
410    return;
411  }
412
413  if (CompletionConsumer->isOutputBinary() &&
414      llvm::sys::ChangeStdoutToBinary()) {
415    getPreprocessor().getDiagnostics().Report(diag::err_fe_stdout_binary);
416    setCodeCompletionConsumer(0);
417  }
418}
419
420void CompilerInstance::createFrontendTimer() {
421  FrontendTimer.reset(new llvm::Timer("Clang front-end timer"));
422}
423
424CodeCompleteConsumer *
425CompilerInstance::createCodeCompletionConsumer(Preprocessor &PP,
426                                               const std::string &Filename,
427                                               unsigned Line,
428                                               unsigned Column,
429                                               const CodeCompleteOptions &Opts,
430                                               raw_ostream &OS) {
431  if (EnableCodeCompletion(PP, Filename, Line, Column))
432    return 0;
433
434  // Set up the creation routine for code-completion.
435  return new PrintingCodeCompleteConsumer(Opts, OS);
436}
437
438void CompilerInstance::createSema(TranslationUnitKind TUKind,
439                                  CodeCompleteConsumer *CompletionConsumer) {
440  TheSema.reset(new Sema(getPreprocessor(), getASTContext(), getASTConsumer(),
441                         TUKind, CompletionConsumer));
442}
443
444// Output Files
445
446void CompilerInstance::addOutputFile(const OutputFile &OutFile) {
447  assert(OutFile.OS && "Attempt to add empty stream to output list!");
448  OutputFiles.push_back(OutFile);
449}
450
451void CompilerInstance::clearOutputFiles(bool EraseFiles) {
452  for (std::list<OutputFile>::iterator
453         it = OutputFiles.begin(), ie = OutputFiles.end(); it != ie; ++it) {
454    delete it->OS;
455    if (!it->TempFilename.empty()) {
456      if (EraseFiles) {
457        llvm::sys::fs::remove(it->TempFilename);
458      } else {
459        SmallString<128> NewOutFile(it->Filename);
460
461        // If '-working-directory' was passed, the output filename should be
462        // relative to that.
463        FileMgr->FixupRelativePath(NewOutFile);
464        if (llvm::error_code ec = llvm::sys::fs::rename(it->TempFilename,
465                                                        NewOutFile.str())) {
466          getDiagnostics().Report(diag::err_unable_to_rename_temp)
467            << it->TempFilename << it->Filename << ec.message();
468
469          llvm::sys::fs::remove(it->TempFilename);
470        }
471      }
472    } else if (!it->Filename.empty() && EraseFiles)
473      llvm::sys::fs::remove(it->Filename);
474
475  }
476  OutputFiles.clear();
477}
478
479llvm::raw_fd_ostream *
480CompilerInstance::createDefaultOutputFile(bool Binary,
481                                          StringRef InFile,
482                                          StringRef Extension) {
483  return createOutputFile(getFrontendOpts().OutputFile, Binary,
484                          /*RemoveFileOnSignal=*/true, InFile, Extension,
485                          /*UseTemporary=*/true);
486}
487
488llvm::raw_fd_ostream *
489CompilerInstance::createOutputFile(StringRef OutputPath,
490                                   bool Binary, bool RemoveFileOnSignal,
491                                   StringRef InFile,
492                                   StringRef Extension,
493                                   bool UseTemporary,
494                                   bool CreateMissingDirectories) {
495  std::string Error, OutputPathName, TempPathName;
496  llvm::raw_fd_ostream *OS = createOutputFile(OutputPath, Error, Binary,
497                                              RemoveFileOnSignal,
498                                              InFile, Extension,
499                                              UseTemporary,
500                                              CreateMissingDirectories,
501                                              &OutputPathName,
502                                              &TempPathName);
503  if (!OS) {
504    getDiagnostics().Report(diag::err_fe_unable_to_open_output)
505      << OutputPath << Error;
506    return 0;
507  }
508
509  // Add the output file -- but don't try to remove "-", since this means we are
510  // using stdin.
511  addOutputFile(OutputFile((OutputPathName != "-") ? OutputPathName : "",
512                TempPathName, OS));
513
514  return OS;
515}
516
517llvm::raw_fd_ostream *
518CompilerInstance::createOutputFile(StringRef OutputPath,
519                                   std::string &Error,
520                                   bool Binary,
521                                   bool RemoveFileOnSignal,
522                                   StringRef InFile,
523                                   StringRef Extension,
524                                   bool UseTemporary,
525                                   bool CreateMissingDirectories,
526                                   std::string *ResultPathName,
527                                   std::string *TempPathName) {
528  assert((!CreateMissingDirectories || UseTemporary) &&
529         "CreateMissingDirectories is only allowed when using temporary files");
530
531  std::string OutFile, TempFile;
532  if (!OutputPath.empty()) {
533    OutFile = OutputPath;
534  } else if (InFile == "-") {
535    OutFile = "-";
536  } else if (!Extension.empty()) {
537    SmallString<128> Path(InFile);
538    llvm::sys::path::replace_extension(Path, Extension);
539    OutFile = Path.str();
540  } else {
541    OutFile = "-";
542  }
543
544  std::unique_ptr<llvm::raw_fd_ostream> OS;
545  std::string OSFile;
546
547  if (UseTemporary) {
548    if (OutFile == "-")
549      UseTemporary = false;
550    else {
551      llvm::sys::fs::file_status Status;
552      llvm::sys::fs::status(OutputPath, Status);
553      if (llvm::sys::fs::exists(Status)) {
554        // Fail early if we can't write to the final destination.
555        if (!llvm::sys::fs::can_write(OutputPath))
556          return 0;
557
558        // Don't use a temporary if the output is a special file. This handles
559        // things like '-o /dev/null'
560        if (!llvm::sys::fs::is_regular_file(Status))
561          UseTemporary = false;
562      }
563    }
564  }
565
566  if (UseTemporary) {
567    // Create a temporary file.
568    SmallString<128> TempPath;
569    TempPath = OutFile;
570    TempPath += "-%%%%%%%%";
571    int fd;
572    llvm::error_code EC =
573        llvm::sys::fs::createUniqueFile(TempPath.str(), fd, TempPath);
574
575    if (CreateMissingDirectories &&
576        EC == llvm::errc::no_such_file_or_directory) {
577      StringRef Parent = llvm::sys::path::parent_path(OutputPath);
578      EC = llvm::sys::fs::create_directories(Parent);
579      if (!EC) {
580        EC = llvm::sys::fs::createUniqueFile(TempPath.str(), fd, TempPath);
581      }
582    }
583
584    if (!EC) {
585      OS.reset(new llvm::raw_fd_ostream(fd, /*shouldClose=*/true));
586      OSFile = TempFile = TempPath.str();
587    }
588    // If we failed to create the temporary, fallback to writing to the file
589    // directly. This handles the corner case where we cannot write to the
590    // directory, but can write to the file.
591  }
592
593  if (!OS) {
594    OSFile = OutFile;
595    OS.reset(new llvm::raw_fd_ostream(
596        OSFile.c_str(), Error,
597        (Binary ? llvm::sys::fs::F_None : llvm::sys::fs::F_Text)));
598    if (!Error.empty())
599      return 0;
600  }
601
602  // Make sure the out stream file gets removed if we crash.
603  if (RemoveFileOnSignal)
604    llvm::sys::RemoveFileOnSignal(OSFile);
605
606  if (ResultPathName)
607    *ResultPathName = OutFile;
608  if (TempPathName)
609    *TempPathName = TempFile;
610
611  return OS.release();
612}
613
614// Initialization Utilities
615
616bool CompilerInstance::InitializeSourceManager(const FrontendInputFile &Input){
617  return InitializeSourceManager(Input, getDiagnostics(),
618                                 getFileManager(), getSourceManager(),
619                                 getFrontendOpts());
620}
621
622bool CompilerInstance::InitializeSourceManager(const FrontendInputFile &Input,
623                                               DiagnosticsEngine &Diags,
624                                               FileManager &FileMgr,
625                                               SourceManager &SourceMgr,
626                                               const FrontendOptions &Opts) {
627  SrcMgr::CharacteristicKind
628    Kind = Input.isSystem() ? SrcMgr::C_System : SrcMgr::C_User;
629
630  if (Input.isBuffer()) {
631    SourceMgr.createMainFileIDForMemBuffer(Input.getBuffer(), Kind);
632    assert(!SourceMgr.getMainFileID().isInvalid() &&
633           "Couldn't establish MainFileID!");
634    return true;
635  }
636
637  StringRef InputFile = Input.getFile();
638
639  // Figure out where to get and map in the main file.
640  if (InputFile != "-") {
641    const FileEntry *File = FileMgr.getFile(InputFile, /*OpenFile=*/true);
642    if (!File) {
643      Diags.Report(diag::err_fe_error_reading) << InputFile;
644      return false;
645    }
646
647    // The natural SourceManager infrastructure can't currently handle named
648    // pipes, but we would at least like to accept them for the main
649    // file. Detect them here, read them with the volatile flag so FileMgr will
650    // pick up the correct size, and simply override their contents as we do for
651    // STDIN.
652    if (File->isNamedPipe()) {
653      std::string ErrorStr;
654      if (llvm::MemoryBuffer *MB =
655              FileMgr.getBufferForFile(File, &ErrorStr, /*isVolatile=*/true)) {
656        // Create a new virtual file that will have the correct size.
657        File = FileMgr.getVirtualFile(InputFile, MB->getBufferSize(), 0);
658        SourceMgr.overrideFileContents(File, MB);
659      } else {
660        Diags.Report(diag::err_cannot_open_file) << InputFile << ErrorStr;
661        return false;
662      }
663    }
664
665    SourceMgr.createMainFileID(File, Kind);
666  } else {
667    std::unique_ptr<llvm::MemoryBuffer> SB;
668    if (llvm::error_code ec = llvm::MemoryBuffer::getSTDIN(SB)) {
669      Diags.Report(diag::err_fe_error_reading_stdin) << ec.message();
670      return false;
671    }
672    const FileEntry *File = FileMgr.getVirtualFile(SB->getBufferIdentifier(),
673                                                   SB->getBufferSize(), 0);
674    SourceMgr.createMainFileID(File, Kind);
675    SourceMgr.overrideFileContents(File, SB.release());
676  }
677
678  assert(!SourceMgr.getMainFileID().isInvalid() &&
679         "Couldn't establish MainFileID!");
680  return true;
681}
682
683// High-Level Operations
684
685bool CompilerInstance::ExecuteAction(FrontendAction &Act) {
686  assert(hasDiagnostics() && "Diagnostics engine is not initialized!");
687  assert(!getFrontendOpts().ShowHelp && "Client must handle '-help'!");
688  assert(!getFrontendOpts().ShowVersion && "Client must handle '-version'!");
689
690  // FIXME: Take this as an argument, once all the APIs we used have moved to
691  // taking it as an input instead of hard-coding llvm::errs.
692  raw_ostream &OS = llvm::errs();
693
694  // Create the target instance.
695  setTarget(TargetInfo::CreateTargetInfo(getDiagnostics(), &getTargetOpts()));
696  if (!hasTarget())
697    return false;
698
699  // Inform the target of the language options.
700  //
701  // FIXME: We shouldn't need to do this, the target should be immutable once
702  // created. This complexity should be lifted elsewhere.
703  getTarget().setForcedLangOptions(getLangOpts());
704
705  // rewriter project will change target built-in bool type from its default.
706  if (getFrontendOpts().ProgramAction == frontend::RewriteObjC)
707    getTarget().noSignedCharForObjCBool();
708
709  // Validate/process some options.
710  if (getHeaderSearchOpts().Verbose)
711    OS << "clang -cc1 version " CLANG_VERSION_STRING
712       << " based upon " << PACKAGE_STRING
713       << " default target " << llvm::sys::getDefaultTargetTriple() << "\n";
714
715  if (getFrontendOpts().ShowTimers)
716    createFrontendTimer();
717
718  if (getFrontendOpts().ShowStats)
719    llvm::EnableStatistics();
720
721  for (unsigned i = 0, e = getFrontendOpts().Inputs.size(); i != e; ++i) {
722    // Reset the ID tables if we are reusing the SourceManager.
723    if (hasSourceManager())
724      getSourceManager().clearIDTables();
725
726    if (Act.BeginSourceFile(*this, getFrontendOpts().Inputs[i])) {
727      Act.Execute();
728      Act.EndSourceFile();
729    }
730  }
731
732  // Notify the diagnostic client that all files were processed.
733  getDiagnostics().getClient()->finish();
734
735  if (getDiagnosticOpts().ShowCarets) {
736    // We can have multiple diagnostics sharing one diagnostic client.
737    // Get the total number of warnings/errors from the client.
738    unsigned NumWarnings = getDiagnostics().getClient()->getNumWarnings();
739    unsigned NumErrors = getDiagnostics().getClient()->getNumErrors();
740
741    if (NumWarnings)
742      OS << NumWarnings << " warning" << (NumWarnings == 1 ? "" : "s");
743    if (NumWarnings && NumErrors)
744      OS << " and ";
745    if (NumErrors)
746      OS << NumErrors << " error" << (NumErrors == 1 ? "" : "s");
747    if (NumWarnings || NumErrors)
748      OS << " generated.\n";
749  }
750
751  if (getFrontendOpts().ShowStats && hasFileManager()) {
752    getFileManager().PrintStats();
753    OS << "\n";
754  }
755
756  return !getDiagnostics().getClient()->getNumErrors();
757}
758
759/// \brief Determine the appropriate source input kind based on language
760/// options.
761static InputKind getSourceInputKindFromOptions(const LangOptions &LangOpts) {
762  if (LangOpts.OpenCL)
763    return IK_OpenCL;
764  if (LangOpts.CUDA)
765    return IK_CUDA;
766  if (LangOpts.ObjC1)
767    return LangOpts.CPlusPlus? IK_ObjCXX : IK_ObjC;
768  return LangOpts.CPlusPlus? IK_CXX : IK_C;
769}
770
771/// \brief Compile a module file for the given module, using the options
772/// provided by the importing compiler instance.
773static void compileModule(CompilerInstance &ImportingInstance,
774                          SourceLocation ImportLoc,
775                          Module *Module,
776                          StringRef ModuleFileName) {
777  // FIXME: have LockFileManager return an error_code so that we can
778  // avoid the mkdir when the directory already exists.
779  StringRef Dir = llvm::sys::path::parent_path(ModuleFileName);
780  llvm::sys::fs::create_directories(Dir);
781
782  llvm::LockFileManager Locked(ModuleFileName);
783  switch (Locked) {
784  case llvm::LockFileManager::LFS_Error:
785    return;
786
787  case llvm::LockFileManager::LFS_Owned:
788    // We're responsible for building the module ourselves. Do so below.
789    break;
790
791  case llvm::LockFileManager::LFS_Shared:
792    // Someone else is responsible for building the module. Wait for them to
793    // finish.
794    Locked.waitForUnlock();
795    return;
796  }
797
798  ModuleMap &ModMap
799    = ImportingInstance.getPreprocessor().getHeaderSearchInfo().getModuleMap();
800
801  // Construct a compiler invocation for creating this module.
802  IntrusiveRefCntPtr<CompilerInvocation> Invocation
803    (new CompilerInvocation(ImportingInstance.getInvocation()));
804
805  PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts();
806
807  // For any options that aren't intended to affect how a module is built,
808  // reset them to their default values.
809  Invocation->getLangOpts()->resetNonModularOptions();
810  PPOpts.resetNonModularOptions();
811
812  // Remove any macro definitions that are explicitly ignored by the module.
813  // They aren't supposed to affect how the module is built anyway.
814  const HeaderSearchOptions &HSOpts = Invocation->getHeaderSearchOpts();
815  PPOpts.Macros.erase(
816      std::remove_if(PPOpts.Macros.begin(), PPOpts.Macros.end(),
817                     [&HSOpts](const std::pair<std::string, bool> &def) {
818        StringRef MacroDef = def.first;
819        return HSOpts.ModulesIgnoreMacros.count(MacroDef.split('=').first) > 0;
820      }),
821      PPOpts.Macros.end());
822
823  // Note the name of the module we're building.
824  Invocation->getLangOpts()->CurrentModule = Module->getTopLevelModuleName();
825
826  // Make sure that the failed-module structure has been allocated in
827  // the importing instance, and propagate the pointer to the newly-created
828  // instance.
829  PreprocessorOptions &ImportingPPOpts
830    = ImportingInstance.getInvocation().getPreprocessorOpts();
831  if (!ImportingPPOpts.FailedModules)
832    ImportingPPOpts.FailedModules = new PreprocessorOptions::FailedModulesSet;
833  PPOpts.FailedModules = ImportingPPOpts.FailedModules;
834
835  // If there is a module map file, build the module using the module map.
836  // Set up the inputs/outputs so that we build the module from its umbrella
837  // header.
838  FrontendOptions &FrontendOpts = Invocation->getFrontendOpts();
839  FrontendOpts.OutputFile = ModuleFileName.str();
840  FrontendOpts.DisableFree = false;
841  FrontendOpts.GenerateGlobalModuleIndex = false;
842  FrontendOpts.Inputs.clear();
843  InputKind IK = getSourceInputKindFromOptions(*Invocation->getLangOpts());
844
845  // Don't free the remapped file buffers; they are owned by our caller.
846  PPOpts.RetainRemappedFileBuffers = true;
847
848  Invocation->getDiagnosticOpts().VerifyDiagnostics = 0;
849  assert(ImportingInstance.getInvocation().getModuleHash() ==
850         Invocation->getModuleHash() && "Module hash mismatch!");
851
852  // Construct a compiler instance that will be used to actually create the
853  // module.
854  CompilerInstance Instance;
855  Instance.setInvocation(&*Invocation);
856
857  Instance.createDiagnostics(new ForwardingDiagnosticConsumer(
858                                   ImportingInstance.getDiagnosticClient()),
859                             /*ShouldOwnClient=*/true);
860
861  Instance.setVirtualFileSystem(&ImportingInstance.getVirtualFileSystem());
862
863  // Note that this module is part of the module build stack, so that we
864  // can detect cycles in the module graph.
865  Instance.setFileManager(&ImportingInstance.getFileManager());
866  Instance.createSourceManager(Instance.getFileManager());
867  SourceManager &SourceMgr = Instance.getSourceManager();
868  SourceMgr.setModuleBuildStack(
869    ImportingInstance.getSourceManager().getModuleBuildStack());
870  SourceMgr.pushModuleBuildStack(Module->getTopLevelModuleName(),
871    FullSourceLoc(ImportLoc, ImportingInstance.getSourceManager()));
872
873  // Get or create the module map that we'll use to build this module.
874  std::string InferredModuleMapContent;
875  if (const FileEntry *ModuleMapFile =
876          ModMap.getContainingModuleMapFile(Module)) {
877    // Use the module map where this module resides.
878    FrontendOpts.Inputs.push_back(
879        FrontendInputFile(ModuleMapFile->getName(), IK));
880  } else {
881    llvm::raw_string_ostream OS(InferredModuleMapContent);
882    Module->print(OS);
883    OS.flush();
884    FrontendOpts.Inputs.push_back(
885        FrontendInputFile("__inferred_module.map", IK));
886
887    const llvm::MemoryBuffer *ModuleMapBuffer =
888        llvm::MemoryBuffer::getMemBuffer(InferredModuleMapContent);
889    ModuleMapFile = Instance.getFileManager().getVirtualFile(
890        "__inferred_module.map", InferredModuleMapContent.size(), 0);
891    SourceMgr.overrideFileContents(ModuleMapFile, ModuleMapBuffer);
892  }
893
894  // Construct a module-generating action.
895  GenerateModuleAction CreateModuleAction(Module->IsSystem);
896
897  // Execute the action to actually build the module in-place. Use a separate
898  // thread so that we get a stack large enough.
899  const unsigned ThreadStackSize = 8 << 20;
900  llvm::CrashRecoveryContext CRC;
901  CRC.RunSafelyOnThread([&]() { Instance.ExecuteAction(CreateModuleAction); },
902                        ThreadStackSize);
903
904  // Delete the temporary module map file.
905  // FIXME: Even though we're executing under crash protection, it would still
906  // be nice to do this with RemoveFileOnSignal when we can. However, that
907  // doesn't make sense for all clients, so clean this up manually.
908  Instance.clearOutputFiles(/*EraseFiles=*/true);
909
910  // We've rebuilt a module. If we're allowed to generate or update the global
911  // module index, record that fact in the importing compiler instance.
912  if (ImportingInstance.getFrontendOpts().GenerateGlobalModuleIndex) {
913    ImportingInstance.setBuildGlobalModuleIndex(true);
914  }
915}
916
917/// \brief Diagnose differences between the current definition of the given
918/// configuration macro and the definition provided on the command line.
919static void checkConfigMacro(Preprocessor &PP, StringRef ConfigMacro,
920                             Module *Mod, SourceLocation ImportLoc) {
921  IdentifierInfo *Id = PP.getIdentifierInfo(ConfigMacro);
922  SourceManager &SourceMgr = PP.getSourceManager();
923
924  // If this identifier has never had a macro definition, then it could
925  // not have changed.
926  if (!Id->hadMacroDefinition())
927    return;
928
929  // If this identifier does not currently have a macro definition,
930  // check whether it had one on the command line.
931  if (!Id->hasMacroDefinition()) {
932    MacroDirective::DefInfo LatestDef =
933        PP.getMacroDirectiveHistory(Id)->getDefinition();
934    for (MacroDirective::DefInfo Def = LatestDef; Def;
935           Def = Def.getPreviousDefinition()) {
936      FileID FID = SourceMgr.getFileID(Def.getLocation());
937      if (FID.isInvalid())
938        continue;
939
940      // We only care about the predefines buffer.
941      if (FID != PP.getPredefinesFileID())
942        continue;
943
944      // This macro was defined on the command line, then #undef'd later.
945      // Complain.
946      PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
947        << true << ConfigMacro << Mod->getFullModuleName();
948      if (LatestDef.isUndefined())
949        PP.Diag(LatestDef.getUndefLocation(), diag::note_module_def_undef_here)
950          << true;
951      return;
952    }
953
954    // Okay: no definition in the predefines buffer.
955    return;
956  }
957
958  // This identifier has a macro definition. Check whether we had a definition
959  // on the command line.
960  MacroDirective::DefInfo LatestDef =
961      PP.getMacroDirectiveHistory(Id)->getDefinition();
962  MacroDirective::DefInfo PredefinedDef;
963  for (MacroDirective::DefInfo Def = LatestDef; Def;
964         Def = Def.getPreviousDefinition()) {
965    FileID FID = SourceMgr.getFileID(Def.getLocation());
966    if (FID.isInvalid())
967      continue;
968
969    // We only care about the predefines buffer.
970    if (FID != PP.getPredefinesFileID())
971      continue;
972
973    PredefinedDef = Def;
974    break;
975  }
976
977  // If there was no definition for this macro in the predefines buffer,
978  // complain.
979  if (!PredefinedDef ||
980      (!PredefinedDef.getLocation().isValid() &&
981       PredefinedDef.getUndefLocation().isValid())) {
982    PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
983      << false << ConfigMacro << Mod->getFullModuleName();
984    PP.Diag(LatestDef.getLocation(), diag::note_module_def_undef_here)
985      << false;
986    return;
987  }
988
989  // If the current macro definition is the same as the predefined macro
990  // definition, it's okay.
991  if (LatestDef.getMacroInfo() == PredefinedDef.getMacroInfo() ||
992      LatestDef.getMacroInfo()->isIdenticalTo(*PredefinedDef.getMacroInfo(),PP,
993                                              /*Syntactically=*/true))
994    return;
995
996  // The macro definitions differ.
997  PP.Diag(ImportLoc, diag::warn_module_config_macro_undef)
998    << false << ConfigMacro << Mod->getFullModuleName();
999  PP.Diag(LatestDef.getLocation(), diag::note_module_def_undef_here)
1000    << false;
1001}
1002
1003/// \brief Write a new timestamp file with the given path.
1004static void writeTimestampFile(StringRef TimestampFile) {
1005  std::string ErrorInfo;
1006  llvm::raw_fd_ostream Out(TimestampFile.str().c_str(), ErrorInfo,
1007                           llvm::sys::fs::F_None);
1008}
1009
1010/// \brief Prune the module cache of modules that haven't been accessed in
1011/// a long time.
1012static void pruneModuleCache(const HeaderSearchOptions &HSOpts) {
1013  struct stat StatBuf;
1014  llvm::SmallString<128> TimestampFile;
1015  TimestampFile = HSOpts.ModuleCachePath;
1016  llvm::sys::path::append(TimestampFile, "modules.timestamp");
1017
1018  // Try to stat() the timestamp file.
1019  if (::stat(TimestampFile.c_str(), &StatBuf)) {
1020    // If the timestamp file wasn't there, create one now.
1021    if (errno == ENOENT) {
1022      writeTimestampFile(TimestampFile);
1023    }
1024    return;
1025  }
1026
1027  // Check whether the time stamp is older than our pruning interval.
1028  // If not, do nothing.
1029  time_t TimeStampModTime = StatBuf.st_mtime;
1030  time_t CurrentTime = time(0);
1031  if (CurrentTime - TimeStampModTime <= time_t(HSOpts.ModuleCachePruneInterval))
1032    return;
1033
1034  // Write a new timestamp file so that nobody else attempts to prune.
1035  // There is a benign race condition here, if two Clang instances happen to
1036  // notice at the same time that the timestamp is out-of-date.
1037  writeTimestampFile(TimestampFile);
1038
1039  // Walk the entire module cache, looking for unused module files and module
1040  // indices.
1041  llvm::error_code EC;
1042  SmallString<128> ModuleCachePathNative;
1043  llvm::sys::path::native(HSOpts.ModuleCachePath, ModuleCachePathNative);
1044  for (llvm::sys::fs::directory_iterator
1045         Dir(ModuleCachePathNative.str(), EC), DirEnd;
1046       Dir != DirEnd && !EC; Dir.increment(EC)) {
1047    // If we don't have a directory, there's nothing to look into.
1048    if (!llvm::sys::fs::is_directory(Dir->path()))
1049      continue;
1050
1051    // Walk all of the files within this directory.
1052    for (llvm::sys::fs::directory_iterator File(Dir->path(), EC), FileEnd;
1053         File != FileEnd && !EC; File.increment(EC)) {
1054      // We only care about module and global module index files.
1055      StringRef Extension = llvm::sys::path::extension(File->path());
1056      if (Extension != ".pcm" && Extension != ".timestamp" &&
1057          llvm::sys::path::filename(File->path()) != "modules.idx")
1058        continue;
1059
1060      // Look at this file. If we can't stat it, there's nothing interesting
1061      // there.
1062      if (::stat(File->path().c_str(), &StatBuf))
1063        continue;
1064
1065      // If the file has been used recently enough, leave it there.
1066      time_t FileAccessTime = StatBuf.st_atime;
1067      if (CurrentTime - FileAccessTime <=
1068              time_t(HSOpts.ModuleCachePruneAfter)) {
1069        continue;
1070      }
1071
1072      // Remove the file.
1073      llvm::sys::fs::remove(File->path());
1074
1075      // Remove the timestamp file.
1076      std::string TimpestampFilename = File->path() + ".timestamp";
1077      llvm::sys::fs::remove(TimpestampFilename);
1078    }
1079
1080    // If we removed all of the files in the directory, remove the directory
1081    // itself.
1082    if (llvm::sys::fs::directory_iterator(Dir->path(), EC) ==
1083            llvm::sys::fs::directory_iterator() && !EC)
1084      llvm::sys::fs::remove(Dir->path());
1085  }
1086}
1087
1088ModuleLoadResult
1089CompilerInstance::loadModule(SourceLocation ImportLoc,
1090                             ModuleIdPath Path,
1091                             Module::NameVisibilityKind Visibility,
1092                             bool IsInclusionDirective) {
1093  // Determine what file we're searching from.
1094  StringRef ModuleName = Path[0].first->getName();
1095  SourceLocation ModuleNameLoc = Path[0].second;
1096
1097  // If we've already handled this import, just return the cached result.
1098  // This one-element cache is important to eliminate redundant diagnostics
1099  // when both the preprocessor and parser see the same import declaration.
1100  if (!ImportLoc.isInvalid() && LastModuleImportLoc == ImportLoc) {
1101    // Make the named module visible.
1102    if (LastModuleImportResult && ModuleName != getLangOpts().CurrentModule)
1103      ModuleManager->makeModuleVisible(LastModuleImportResult, Visibility,
1104                                       ImportLoc, /*Complain=*/false);
1105    return LastModuleImportResult;
1106  }
1107
1108  clang::Module *Module = 0;
1109
1110  // If we don't already have information on this module, load the module now.
1111  llvm::DenseMap<const IdentifierInfo *, clang::Module *>::iterator Known
1112    = KnownModules.find(Path[0].first);
1113  if (Known != KnownModules.end()) {
1114    // Retrieve the cached top-level module.
1115    Module = Known->second;
1116  } else if (ModuleName == getLangOpts().CurrentModule) {
1117    // This is the module we're building.
1118    Module = PP->getHeaderSearchInfo().getModuleMap().findModule(ModuleName);
1119    Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
1120  } else {
1121    // Search for a module with the given name.
1122    Module = PP->getHeaderSearchInfo().lookupModule(ModuleName);
1123    if (!Module) {
1124      getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_found)
1125      << ModuleName
1126      << SourceRange(ImportLoc, ModuleNameLoc);
1127      ModuleBuildFailed = true;
1128      return ModuleLoadResult();
1129    }
1130
1131    std::string ModuleFileName = PP->getHeaderSearchInfo().getModuleFileName(Module);
1132
1133    // If we don't already have an ASTReader, create one now.
1134    if (!ModuleManager) {
1135      if (!hasASTContext())
1136        createASTContext();
1137
1138      // If we're not recursively building a module, check whether we
1139      // need to prune the module cache.
1140      if (getSourceManager().getModuleBuildStack().empty() &&
1141          getHeaderSearchOpts().ModuleCachePruneInterval > 0 &&
1142          getHeaderSearchOpts().ModuleCachePruneAfter > 0) {
1143        pruneModuleCache(getHeaderSearchOpts());
1144      }
1145
1146      HeaderSearchOptions &HSOpts = getHeaderSearchOpts();
1147      std::string Sysroot = HSOpts.Sysroot;
1148      const PreprocessorOptions &PPOpts = getPreprocessorOpts();
1149      ModuleManager = new ASTReader(getPreprocessor(), *Context,
1150                                    Sysroot.empty() ? "" : Sysroot.c_str(),
1151                                    PPOpts.DisablePCHValidation,
1152                                    /*AllowASTWithCompilerErrors=*/false,
1153                                    /*AllowConfigurationMismatch=*/false,
1154                                    HSOpts.ModulesValidateSystemHeaders,
1155                                    getFrontendOpts().UseGlobalModuleIndex);
1156      if (hasASTConsumer()) {
1157        ModuleManager->setDeserializationListener(
1158          getASTConsumer().GetASTDeserializationListener());
1159        getASTContext().setASTMutationListener(
1160          getASTConsumer().GetASTMutationListener());
1161      }
1162      getASTContext().setExternalSource(ModuleManager);
1163      if (hasSema())
1164        ModuleManager->InitializeSema(getSema());
1165      if (hasASTConsumer())
1166        ModuleManager->StartTranslationUnit(&getASTConsumer());
1167    }
1168
1169    if (TheDependencyFileGenerator)
1170      TheDependencyFileGenerator->AttachToASTReader(*ModuleManager);
1171
1172    // Try to load the module file.
1173    unsigned ARRFlags = ASTReader::ARR_OutOfDate | ASTReader::ARR_Missing;
1174    switch (ModuleManager->ReadAST(ModuleFileName, serialization::MK_Module,
1175                                   ImportLoc, ARRFlags)) {
1176    case ASTReader::Success:
1177      break;
1178
1179    case ASTReader::OutOfDate:
1180    case ASTReader::Missing: {
1181      // The module file is missing or out-of-date. Build it.
1182      assert(Module && "missing module file");
1183      // Check whether there is a cycle in the module graph.
1184      ModuleBuildStack ModPath = getSourceManager().getModuleBuildStack();
1185      ModuleBuildStack::iterator Pos = ModPath.begin(), PosEnd = ModPath.end();
1186      for (; Pos != PosEnd; ++Pos) {
1187        if (Pos->first == ModuleName)
1188          break;
1189      }
1190
1191      if (Pos != PosEnd) {
1192        SmallString<256> CyclePath;
1193        for (; Pos != PosEnd; ++Pos) {
1194          CyclePath += Pos->first;
1195          CyclePath += " -> ";
1196        }
1197        CyclePath += ModuleName;
1198
1199        getDiagnostics().Report(ModuleNameLoc, diag::err_module_cycle)
1200          << ModuleName << CyclePath;
1201        return ModuleLoadResult();
1202      }
1203
1204      // Check whether we have already attempted to build this module (but
1205      // failed).
1206      if (getPreprocessorOpts().FailedModules &&
1207          getPreprocessorOpts().FailedModules->hasAlreadyFailed(ModuleName)) {
1208        getDiagnostics().Report(ModuleNameLoc, diag::err_module_not_built)
1209          << ModuleName
1210          << SourceRange(ImportLoc, ModuleNameLoc);
1211        ModuleBuildFailed = true;
1212        return ModuleLoadResult();
1213      }
1214
1215      // Try to compile the module.
1216      compileModule(*this, ModuleNameLoc, Module, ModuleFileName);
1217
1218      // Try to read the module file, now that we've compiled it.
1219      ASTReader::ASTReadResult ReadResult
1220        = ModuleManager->ReadAST(ModuleFileName,
1221                                 serialization::MK_Module, ImportLoc,
1222                                 ASTReader::ARR_Missing);
1223      if (ReadResult != ASTReader::Success) {
1224        if (ReadResult == ASTReader::Missing) {
1225          getDiagnostics().Report(ModuleNameLoc,
1226                                  Module? diag::err_module_not_built
1227                                        : diag::err_module_not_found)
1228            << ModuleName
1229            << SourceRange(ImportLoc, ModuleNameLoc);
1230        }
1231
1232        if (getPreprocessorOpts().FailedModules)
1233          getPreprocessorOpts().FailedModules->addFailed(ModuleName);
1234        KnownModules[Path[0].first] = 0;
1235        ModuleBuildFailed = true;
1236        return ModuleLoadResult();
1237      }
1238
1239      // Okay, we've rebuilt and now loaded the module.
1240      break;
1241    }
1242
1243    case ASTReader::VersionMismatch:
1244    case ASTReader::ConfigurationMismatch:
1245    case ASTReader::HadErrors:
1246      ModuleLoader::HadFatalFailure = true;
1247      // FIXME: The ASTReader will already have complained, but can we showhorn
1248      // that diagnostic information into a more useful form?
1249      KnownModules[Path[0].first] = 0;
1250      return ModuleLoadResult();
1251
1252    case ASTReader::Failure:
1253      ModuleLoader::HadFatalFailure = true;
1254      // Already complained, but note now that we failed.
1255      KnownModules[Path[0].first] = 0;
1256      ModuleBuildFailed = true;
1257      return ModuleLoadResult();
1258    }
1259
1260    // Cache the result of this top-level module lookup for later.
1261    Known = KnownModules.insert(std::make_pair(Path[0].first, Module)).first;
1262  }
1263
1264  // If we never found the module, fail.
1265  if (!Module)
1266    return ModuleLoadResult();
1267
1268  // Verify that the rest of the module path actually corresponds to
1269  // a submodule.
1270  if (Path.size() > 1) {
1271    for (unsigned I = 1, N = Path.size(); I != N; ++I) {
1272      StringRef Name = Path[I].first->getName();
1273      clang::Module *Sub = Module->findSubmodule(Name);
1274
1275      if (!Sub) {
1276        // Attempt to perform typo correction to find a module name that works.
1277        SmallVector<StringRef, 2> Best;
1278        unsigned BestEditDistance = (std::numeric_limits<unsigned>::max)();
1279
1280        for (clang::Module::submodule_iterator J = Module->submodule_begin(),
1281                                            JEnd = Module->submodule_end();
1282             J != JEnd; ++J) {
1283          unsigned ED = Name.edit_distance((*J)->Name,
1284                                           /*AllowReplacements=*/true,
1285                                           BestEditDistance);
1286          if (ED <= BestEditDistance) {
1287            if (ED < BestEditDistance) {
1288              Best.clear();
1289              BestEditDistance = ED;
1290            }
1291
1292            Best.push_back((*J)->Name);
1293          }
1294        }
1295
1296        // If there was a clear winner, user it.
1297        if (Best.size() == 1) {
1298          getDiagnostics().Report(Path[I].second,
1299                                  diag::err_no_submodule_suggest)
1300            << Path[I].first << Module->getFullModuleName() << Best[0]
1301            << SourceRange(Path[0].second, Path[I-1].second)
1302            << FixItHint::CreateReplacement(SourceRange(Path[I].second),
1303                                            Best[0]);
1304
1305          Sub = Module->findSubmodule(Best[0]);
1306        }
1307      }
1308
1309      if (!Sub) {
1310        // No submodule by this name. Complain, and don't look for further
1311        // submodules.
1312        getDiagnostics().Report(Path[I].second, diag::err_no_submodule)
1313          << Path[I].first << Module->getFullModuleName()
1314          << SourceRange(Path[0].second, Path[I-1].second);
1315        break;
1316      }
1317
1318      Module = Sub;
1319    }
1320  }
1321
1322  // Make the named module visible, if it's not already part of the module
1323  // we are parsing.
1324  if (ModuleName != getLangOpts().CurrentModule) {
1325    if (!Module->IsFromModuleFile) {
1326      // We have an umbrella header or directory that doesn't actually include
1327      // all of the headers within the directory it covers. Complain about
1328      // this missing submodule and recover by forgetting that we ever saw
1329      // this submodule.
1330      // FIXME: Should we detect this at module load time? It seems fairly
1331      // expensive (and rare).
1332      getDiagnostics().Report(ImportLoc, diag::warn_missing_submodule)
1333        << Module->getFullModuleName()
1334        << SourceRange(Path.front().second, Path.back().second);
1335
1336      return ModuleLoadResult(0, true);
1337    }
1338
1339    // Check whether this module is available.
1340    clang::Module::Requirement Requirement;
1341    clang::Module::HeaderDirective MissingHeader;
1342    if (!Module->isAvailable(getLangOpts(), getTarget(), Requirement,
1343                             MissingHeader)) {
1344      if (MissingHeader.FileNameLoc.isValid()) {
1345        getDiagnostics().Report(MissingHeader.FileNameLoc,
1346                                diag::err_module_header_missing)
1347          << MissingHeader.IsUmbrella << MissingHeader.FileName;
1348      } else {
1349        getDiagnostics().Report(ImportLoc, diag::err_module_unavailable)
1350          << Module->getFullModuleName()
1351          << Requirement.second << Requirement.first
1352          << SourceRange(Path.front().second, Path.back().second);
1353      }
1354      LastModuleImportLoc = ImportLoc;
1355      LastModuleImportResult = ModuleLoadResult();
1356      return ModuleLoadResult();
1357    }
1358
1359    ModuleManager->makeModuleVisible(Module, Visibility, ImportLoc,
1360                                     /*Complain=*/true);
1361  }
1362
1363  // Check for any configuration macros that have changed.
1364  clang::Module *TopModule = Module->getTopLevelModule();
1365  for (unsigned I = 0, N = TopModule->ConfigMacros.size(); I != N; ++I) {
1366    checkConfigMacro(getPreprocessor(), TopModule->ConfigMacros[I],
1367                     Module, ImportLoc);
1368  }
1369
1370  // If this module import was due to an inclusion directive, create an
1371  // implicit import declaration to capture it in the AST.
1372  if (IsInclusionDirective && hasASTContext()) {
1373    TranslationUnitDecl *TU = getASTContext().getTranslationUnitDecl();
1374    ImportDecl *ImportD = ImportDecl::CreateImplicit(getASTContext(), TU,
1375                                                     ImportLoc, Module,
1376                                                     Path.back().second);
1377    TU->addDecl(ImportD);
1378    if (Consumer)
1379      Consumer->HandleImplicitImportDecl(ImportD);
1380  }
1381
1382  LastModuleImportLoc = ImportLoc;
1383  LastModuleImportResult = ModuleLoadResult(Module, false);
1384  return LastModuleImportResult;
1385}
1386
1387void CompilerInstance::makeModuleVisible(Module *Mod,
1388                                         Module::NameVisibilityKind Visibility,
1389                                         SourceLocation ImportLoc,
1390                                         bool Complain){
1391  ModuleManager->makeModuleVisible(Mod, Visibility, ImportLoc, Complain);
1392}
1393
1394