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