clang  3.8.0
Frontend/FrontendActions.cpp
Go to the documentation of this file.
1 //===--- FrontendActions.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 
11 #include "clang/AST/ASTConsumer.h"
14 #include "clang/Frontend/ASTUnit.h"
18 #include "clang/Frontend/Utils.h"
19 #include "clang/Lex/HeaderSearch.h"
20 #include "clang/Lex/Pragma.h"
21 #include "clang/Lex/Preprocessor.h"
22 #include "clang/Parse/Parser.h"
25 #include "llvm/Support/FileSystem.h"
26 #include "llvm/Support/MemoryBuffer.h"
27 #include "llvm/Support/raw_ostream.h"
28 #include <memory>
29 #include <system_error>
30 
31 using namespace clang;
32 
33 //===----------------------------------------------------------------------===//
34 // Custom Actions
35 //===----------------------------------------------------------------------===//
36 
37 std::unique_ptr<ASTConsumer>
38 InitOnlyAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
39  return llvm::make_unique<ASTConsumer>();
40 }
41 
42 void InitOnlyAction::ExecuteAction() {
43 }
44 
45 //===----------------------------------------------------------------------===//
46 // AST Consumer Actions
47 //===----------------------------------------------------------------------===//
48 
49 std::unique_ptr<ASTConsumer>
51  if (raw_ostream *OS = CI.createDefaultOutputFile(false, InFile))
53  return nullptr;
54 }
55 
56 std::unique_ptr<ASTConsumer>
61 }
62 
63 std::unique_ptr<ASTConsumer>
65  return CreateASTDeclNodeLister();
66 }
67 
68 std::unique_ptr<ASTConsumer>
70  return CreateASTViewer();
71 }
72 
73 std::unique_ptr<ASTConsumer>
75  StringRef InFile) {
76  return CreateDeclContextPrinter();
77 }
78 
79 std::unique_ptr<ASTConsumer>
81  std::string Sysroot;
82  std::string OutputFile;
83  raw_pwrite_stream *OS =
84  ComputeASTConsumerArguments(CI, InFile, Sysroot, OutputFile);
85  if (!OS)
86  return nullptr;
87 
89  Sysroot.clear();
90 
91  auto Buffer = std::make_shared<PCHBuffer>();
92  std::vector<std::unique_ptr<ASTConsumer>> Consumers;
93  Consumers.push_back(llvm::make_unique<PCHGenerator>(
94  CI.getPreprocessor(), OutputFile, nullptr, Sysroot,
96  Consumers.push_back(CI.getPCHContainerWriter().CreatePCHContainerGenerator(
97  CI, InFile, OutputFile, OS, Buffer));
98 
99  return llvm::make_unique<MultiplexConsumer>(std::move(Consumers));
100 }
101 
103  CompilerInstance &CI, StringRef InFile, std::string &Sysroot,
104  std::string &OutputFile) {
105  Sysroot = CI.getHeaderSearchOpts().Sysroot;
106  if (CI.getFrontendOpts().RelocatablePCH && Sysroot.empty()) {
107  CI.getDiagnostics().Report(diag::err_relocatable_without_isysroot);
108  return nullptr;
109  }
110 
111  // We use createOutputFile here because this is exposed via libclang, and we
112  // must disable the RemoveFileOnSignal behavior.
113  // We use a temporary to avoid race conditions.
114  raw_pwrite_stream *OS =
115  CI.createOutputFile(CI.getFrontendOpts().OutputFile, /*Binary=*/true,
116  /*RemoveFileOnSignal=*/false, InFile,
117  /*Extension=*/"", /*useTemporary=*/true);
118  if (!OS)
119  return nullptr;
120 
121  OutputFile = CI.getFrontendOpts().OutputFile;
122  return OS;
123 }
124 
125 std::unique_ptr<ASTConsumer>
127  StringRef InFile) {
128  std::string Sysroot;
129  std::string OutputFile;
130  raw_pwrite_stream *OS =
131  ComputeASTConsumerArguments(CI, InFile, Sysroot, OutputFile);
132  if (!OS)
133  return nullptr;
134 
135  auto Buffer = std::make_shared<PCHBuffer>();
136  std::vector<std::unique_ptr<ASTConsumer>> Consumers;
137 
138  Consumers.push_back(llvm::make_unique<PCHGenerator>(
139  CI.getPreprocessor(), OutputFile, Module, Sysroot,
141  /*AllowASTWithErrors=*/false,
142  /*IncludeTimestamps=*/
144  Consumers.push_back(CI.getPCHContainerWriter().CreatePCHContainerGenerator(
145  CI, InFile, OutputFile, OS, Buffer));
146  return llvm::make_unique<MultiplexConsumer>(std::move(Consumers));
147 }
148 
149 static SmallVectorImpl<char> &
150 operator+=(SmallVectorImpl<char> &Includes, StringRef RHS) {
151  Includes.append(RHS.begin(), RHS.end());
152  return Includes;
153 }
154 
155 static std::error_code addHeaderInclude(StringRef HeaderName,
156  SmallVectorImpl<char> &Includes,
157  const LangOptions &LangOpts,
158  bool IsExternC) {
159  if (IsExternC && LangOpts.CPlusPlus)
160  Includes += "extern \"C\" {\n";
161  if (LangOpts.ObjC1)
162  Includes += "#import \"";
163  else
164  Includes += "#include \"";
165 
166  Includes += HeaderName;
167 
168  Includes += "\"\n";
169  if (IsExternC && LangOpts.CPlusPlus)
170  Includes += "}\n";
171  return std::error_code();
172 }
173 
174 /// \brief Collect the set of header includes needed to construct the given
175 /// module and update the TopHeaders file set of the module.
176 ///
177 /// \param Module The module we're collecting includes from.
178 ///
179 /// \param Includes Will be augmented with the set of \#includes or \#imports
180 /// needed to load all of the named headers.
181 static std::error_code
183  ModuleMap &ModMap, clang::Module *Module,
184  SmallVectorImpl<char> &Includes) {
185  // Don't collect any headers for unavailable modules.
186  if (!Module->isAvailable())
187  return std::error_code();
188 
189  // Add includes for each of these headers.
190  for (auto HK : {Module::HK_Normal, Module::HK_Private}) {
191  for (Module::Header &H : Module->Headers[HK]) {
192  Module->addTopHeader(H.Entry);
193  // Use the path as specified in the module map file. We'll look for this
194  // file relative to the module build directory (the directory containing
195  // the module map file) so this will find the same file that we found
196  // while parsing the module map.
197  if (std::error_code Err = addHeaderInclude(H.NameAsWritten, Includes,
198  LangOpts, Module->IsExternC))
199  return Err;
200  }
201  }
202  // Note that Module->PrivateHeaders will not be a TopHeader.
203 
204  if (Module::Header UmbrellaHeader = Module->getUmbrellaHeader()) {
205  Module->addTopHeader(UmbrellaHeader.Entry);
206  if (Module->Parent) {
207  // Include the umbrella header for submodules.
208  if (std::error_code Err = addHeaderInclude(UmbrellaHeader.NameAsWritten,
209  Includes, LangOpts,
210  Module->IsExternC))
211  return Err;
212  }
213  } else if (Module::DirectoryName UmbrellaDir = Module->getUmbrellaDir()) {
214  // Add all of the headers we find in this subdirectory.
215  std::error_code EC;
216  SmallString<128> DirNative;
217  llvm::sys::path::native(UmbrellaDir.Entry->getName(), DirNative);
218  for (llvm::sys::fs::recursive_directory_iterator Dir(DirNative, EC),
219  DirEnd;
220  Dir != DirEnd && !EC; Dir.increment(EC)) {
221  // Check whether this entry has an extension typically associated with
222  // headers.
223  if (!llvm::StringSwitch<bool>(llvm::sys::path::extension(Dir->path()))
224  .Cases(".h", ".H", ".hh", ".hpp", true)
225  .Default(false))
226  continue;
227 
228  const FileEntry *Header = FileMgr.getFile(Dir->path());
229  // FIXME: This shouldn't happen unless there is a file system race. Is
230  // that worth diagnosing?
231  if (!Header)
232  continue;
233 
234  // If this header is marked 'unavailable' in this module, don't include
235  // it.
236  if (ModMap.isHeaderUnavailableInModule(Header, Module))
237  continue;
238 
239  // Compute the relative path from the directory to this file.
240  SmallVector<StringRef, 16> Components;
241  auto PathIt = llvm::sys::path::rbegin(Dir->path());
242  for (int I = 0; I != Dir.level() + 1; ++I, ++PathIt)
243  Components.push_back(*PathIt);
244  SmallString<128> RelativeHeader(UmbrellaDir.NameAsWritten);
245  for (auto It = Components.rbegin(), End = Components.rend(); It != End;
246  ++It)
247  llvm::sys::path::append(RelativeHeader, *It);
248 
249  // Include this header as part of the umbrella directory.
250  Module->addTopHeader(Header);
251  if (std::error_code Err = addHeaderInclude(RelativeHeader, Includes,
252  LangOpts, Module->IsExternC))
253  return Err;
254  }
255 
256  if (EC)
257  return EC;
258  }
259 
260  // Recurse into submodules.
262  SubEnd = Module->submodule_end();
263  Sub != SubEnd; ++Sub)
264  if (std::error_code Err = collectModuleHeaderIncludes(
265  LangOpts, FileMgr, ModMap, *Sub, Includes))
266  return Err;
267 
268  return std::error_code();
269 }
270 
272  StringRef Filename) {
273  // Find the module map file.
274  const FileEntry *ModuleMap =
275  CI.getFileManager().getFile(Filename, /*openFile*/true);
276  if (!ModuleMap) {
277  CI.getDiagnostics().Report(diag::err_module_map_not_found)
278  << Filename;
279  return false;
280  }
281 
282  // Set up embedding for any specified files. Do this before we load any
283  // source files, including the primary module map for the compilation.
284  for (const auto &F : CI.getFrontendOpts().ModulesEmbedFiles) {
285  if (const auto *FE = CI.getFileManager().getFile(F, /*openFile*/true))
287  else
288  CI.getDiagnostics().Report(diag::err_modules_embed_file_not_found) << F;
289  }
292 
293  // Parse the module map file.
295  if (HS.loadModuleMapFile(ModuleMap, IsSystem))
296  return false;
297 
298  if (CI.getLangOpts().CurrentModule.empty()) {
299  CI.getDiagnostics().Report(diag::err_missing_module_name);
300 
301  // FIXME: Eventually, we could consider asking whether there was just
302  // a single module described in the module map, and use that as a
303  // default. Then it would be fairly trivial to just "compile" a module
304  // map with a single module (the common case).
305  return false;
306  }
307 
308  // If we're being run from the command-line, the module build stack will not
309  // have been filled in yet, so complete it now in order to allow us to detect
310  // module cycles.
312  if (SourceMgr.getModuleBuildStack().empty())
314  FullSourceLoc(SourceLocation(), SourceMgr));
315 
316  // Dig out the module definition.
318  /*AllowSearch=*/false);
319  if (!Module) {
320  CI.getDiagnostics().Report(diag::err_missing_module)
322 
323  return false;
324  }
325 
326  // Check whether we can build this module at all.
327  clang::Module::Requirement Requirement;
329  if (!Module->isAvailable(CI.getLangOpts(), CI.getTarget(), Requirement,
330  MissingHeader)) {
331  if (MissingHeader.FileNameLoc.isValid()) {
332  CI.getDiagnostics().Report(MissingHeader.FileNameLoc,
333  diag::err_module_header_missing)
334  << MissingHeader.IsUmbrella << MissingHeader.FileName;
335  } else {
336  CI.getDiagnostics().Report(diag::err_module_unavailable)
338  << Requirement.second << Requirement.first;
339  }
340 
341  return false;
342  }
343 
344  if (ModuleMapForUniquing && ModuleMapForUniquing != ModuleMap) {
345  Module->IsInferred = true;
346  HS.getModuleMap().setInferredModuleAllowedBy(Module, ModuleMapForUniquing);
347  } else {
348  ModuleMapForUniquing = ModuleMap;
349  }
350 
351  FileManager &FileMgr = CI.getFileManager();
352 
353  // Collect the set of #includes we need to build the module.
354  SmallString<256> HeaderContents;
355  std::error_code Err = std::error_code();
356  if (Module::Header UmbrellaHeader = Module->getUmbrellaHeader())
357  Err = addHeaderInclude(UmbrellaHeader.NameAsWritten, HeaderContents,
358  CI.getLangOpts(), Module->IsExternC);
359  if (!Err)
361  CI.getLangOpts(), FileMgr,
363  HeaderContents);
364 
365  if (Err) {
366  CI.getDiagnostics().Report(diag::err_module_cannot_create_includes)
367  << Module->getFullModuleName() << Err.message();
368  return false;
369  }
370 
371  // Inform the preprocessor that includes from within the input buffer should
372  // be resolved relative to the build directory of the module map file.
374 
375  std::unique_ptr<llvm::MemoryBuffer> InputBuffer =
376  llvm::MemoryBuffer::getMemBufferCopy(HeaderContents,
378  // Ownership of InputBuffer will be transferred to the SourceManager.
379  setCurrentInput(FrontendInputFile(InputBuffer.release(), getCurrentFileKind(),
380  Module->IsSystem));
381  return true;
382 }
383 
385  CompilerInstance &CI, StringRef InFile, std::string &Sysroot,
386  std::string &OutputFile) {
387  // If no output file was provided, figure out where this module would go
388  // in the module cache.
389  if (CI.getFrontendOpts().OutputFile.empty()) {
393  ModuleMapForUniquing->getName());
394  }
395 
396  // We use createOutputFile here because this is exposed via libclang, and we
397  // must disable the RemoveFileOnSignal behavior.
398  // We use a temporary to avoid race conditions.
399  raw_pwrite_stream *OS =
400  CI.createOutputFile(CI.getFrontendOpts().OutputFile, /*Binary=*/true,
401  /*RemoveFileOnSignal=*/false, InFile,
402  /*Extension=*/"", /*useTemporary=*/true,
403  /*CreateMissingDirectories=*/true);
404  if (!OS)
405  return nullptr;
406 
407  OutputFile = CI.getFrontendOpts().OutputFile;
408  return OS;
409 }
410 
411 std::unique_ptr<ASTConsumer>
413  return llvm::make_unique<ASTConsumer>();
414 }
415 
416 std::unique_ptr<ASTConsumer>
418  StringRef InFile) {
419  return llvm::make_unique<ASTConsumer>();
420 }
421 
422 std::unique_ptr<ASTConsumer>
424  return llvm::make_unique<ASTConsumer>();
425 }
426 
429  bool Preamble = CI.getPreprocessorOpts().PrecompiledPreambleBytes.first != 0;
430  const std::string &Sysroot = CI.getHeaderSearchOpts().Sysroot;
431  std::unique_ptr<ASTReader> Reader(new ASTReader(
434  Sysroot.empty() ? "" : Sysroot.c_str(),
435  /*DisableValidation*/ false,
436  /*AllowPCHWithCompilerErrors*/ false,
437  /*AllowConfigurationMismatch*/ true,
438  /*ValidateSystemInputs*/ true));
439 
440  Reader->ReadAST(getCurrentFile(),
441  Preamble ? serialization::MK_Preamble
443  SourceLocation(),
445 }
446 
447 namespace {
448  /// \brief AST reader listener that dumps module information for a module
449  /// file.
450  class DumpModuleInfoListener : public ASTReaderListener {
451  llvm::raw_ostream &Out;
452 
453  public:
454  DumpModuleInfoListener(llvm::raw_ostream &Out) : Out(Out) { }
455 
456 #define DUMP_BOOLEAN(Value, Text) \
457  Out.indent(4) << Text << ": " << (Value? "Yes" : "No") << "\n"
458 
459  bool ReadFullVersionInformation(StringRef FullVersion) override {
460  Out.indent(2)
461  << "Generated by "
462  << (FullVersion == getClangFullRepositoryVersion()? "this"
463  : "a different")
464  << " Clang: " << FullVersion << "\n";
466  }
467 
468  void ReadModuleName(StringRef ModuleName) override {
469  Out.indent(2) << "Module name: " << ModuleName << "\n";
470  }
471  void ReadModuleMapFile(StringRef ModuleMapPath) override {
472  Out.indent(2) << "Module map file: " << ModuleMapPath << "\n";
473  }
474 
475  bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain,
476  bool AllowCompatibleDifferences) override {
477  Out.indent(2) << "Language options:\n";
478 #define LANGOPT(Name, Bits, Default, Description) \
479  DUMP_BOOLEAN(LangOpts.Name, Description);
480 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
481  Out.indent(4) << Description << ": " \
482  << static_cast<unsigned>(LangOpts.get##Name()) << "\n";
483 #define VALUE_LANGOPT(Name, Bits, Default, Description) \
484  Out.indent(4) << Description << ": " << LangOpts.Name << "\n";
485 #define BENIGN_LANGOPT(Name, Bits, Default, Description)
486 #define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
487 #include "clang/Basic/LangOptions.def"
488 
489  if (!LangOpts.ModuleFeatures.empty()) {
490  Out.indent(4) << "Module features:\n";
491  for (StringRef Feature : LangOpts.ModuleFeatures)
492  Out.indent(6) << Feature << "\n";
493  }
494 
495  return false;
496  }
497 
498  bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain,
499  bool AllowCompatibleDifferences) override {
500  Out.indent(2) << "Target options:\n";
501  Out.indent(4) << " Triple: " << TargetOpts.Triple << "\n";
502  Out.indent(4) << " CPU: " << TargetOpts.CPU << "\n";
503  Out.indent(4) << " ABI: " << TargetOpts.ABI << "\n";
504 
505  if (!TargetOpts.FeaturesAsWritten.empty()) {
506  Out.indent(4) << "Target features:\n";
507  for (unsigned I = 0, N = TargetOpts.FeaturesAsWritten.size();
508  I != N; ++I) {
509  Out.indent(6) << TargetOpts.FeaturesAsWritten[I] << "\n";
510  }
511  }
512 
513  return false;
514  }
515 
516  bool ReadDiagnosticOptions(IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts,
517  bool Complain) override {
518  Out.indent(2) << "Diagnostic options:\n";
519 #define DIAGOPT(Name, Bits, Default) DUMP_BOOLEAN(DiagOpts->Name, #Name);
520 #define ENUM_DIAGOPT(Name, Type, Bits, Default) \
521  Out.indent(4) << #Name << ": " << DiagOpts->get##Name() << "\n";
522 #define VALUE_DIAGOPT(Name, Bits, Default) \
523  Out.indent(4) << #Name << ": " << DiagOpts->Name << "\n";
524 #include "clang/Basic/DiagnosticOptions.def"
525 
526  Out.indent(4) << "Diagnostic flags:\n";
527  for (const std::string &Warning : DiagOpts->Warnings)
528  Out.indent(6) << "-W" << Warning << "\n";
529  for (const std::string &Remark : DiagOpts->Remarks)
530  Out.indent(6) << "-R" << Remark << "\n";
531 
532  return false;
533  }
534 
535  bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
536  StringRef SpecificModuleCachePath,
537  bool Complain) override {
538  Out.indent(2) << "Header search options:\n";
539  Out.indent(4) << "System root [-isysroot=]: '" << HSOpts.Sysroot << "'\n";
540  Out.indent(4) << "Module Cache: '" << SpecificModuleCachePath << "'\n";
542  "Use builtin include directories [-nobuiltininc]");
544  "Use standard system include directories [-nostdinc]");
546  "Use standard C++ include directories [-nostdinc++]");
547  DUMP_BOOLEAN(HSOpts.UseLibcxx,
548  "Use libc++ (rather than libstdc++) [-stdlib=]");
549  return false;
550  }
551 
552  bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
553  bool Complain,
554  std::string &SuggestedPredefines) override {
555  Out.indent(2) << "Preprocessor options:\n";
557  "Uses compiler/target-specific predefines [-undef]");
559  "Uses detailed preprocessing record (for indexing)");
560 
561  if (!PPOpts.Macros.empty()) {
562  Out.indent(4) << "Predefined macros:\n";
563  }
564 
565  for (std::vector<std::pair<std::string, bool/*isUndef*/> >::const_iterator
566  I = PPOpts.Macros.begin(), IEnd = PPOpts.Macros.end();
567  I != IEnd; ++I) {
568  Out.indent(6);
569  if (I->second)
570  Out << "-U";
571  else
572  Out << "-D";
573  Out << I->first << "\n";
574  }
575  return false;
576  }
577 
578  /// Indicates that a particular module file extension has been read.
579  void readModuleFileExtension(
580  const ModuleFileExtensionMetadata &Metadata) override {
581  Out.indent(2) << "Module file extension '"
582  << Metadata.BlockName << "' " << Metadata.MajorVersion
583  << "." << Metadata.MinorVersion;
584  if (!Metadata.UserInfo.empty()) {
585  Out << ": ";
586  Out.write_escaped(Metadata.UserInfo);
587  }
588 
589  Out << "\n";
590  }
591 #undef DUMP_BOOLEAN
592  };
593 }
594 
596  // Set up the output file.
597  std::unique_ptr<llvm::raw_fd_ostream> OutFile;
598  StringRef OutputFileName = getCompilerInstance().getFrontendOpts().OutputFile;
599  if (!OutputFileName.empty() && OutputFileName != "-") {
600  std::error_code EC;
601  OutFile.reset(new llvm::raw_fd_ostream(OutputFileName.str(), EC,
602  llvm::sys::fs::F_Text));
603  }
604  llvm::raw_ostream &Out = OutFile.get()? *OutFile.get() : llvm::outs();
605 
606  Out << "Information for module file '" << getCurrentFile() << "':\n";
607  DumpModuleInfoListener Listener(Out);
609  getCurrentFile(), getCompilerInstance().getFileManager(),
610  getCompilerInstance().getPCHContainerReader(),
611  /*FindModuleFileExtensions=*/true, Listener);
612 }
613 
614 //===----------------------------------------------------------------------===//
615 // Preprocessor Actions
616 //===----------------------------------------------------------------------===//
617 
621 
622  // Start lexing the specified input file.
623  const llvm::MemoryBuffer *FromFile = SM.getBuffer(SM.getMainFileID());
624  Lexer RawLex(SM.getMainFileID(), FromFile, SM, PP.getLangOpts());
625  RawLex.SetKeepWhitespaceMode(true);
626 
627  Token RawTok;
628  RawLex.LexFromRawLexer(RawTok);
629  while (RawTok.isNot(tok::eof)) {
630  PP.DumpToken(RawTok, true);
631  llvm::errs() << "\n";
632  RawLex.LexFromRawLexer(RawTok);
633  }
634 }
635 
638  // Start preprocessing the specified input file.
639  Token Tok;
640  PP.EnterMainSourceFile();
641  do {
642  PP.Lex(Tok);
643  PP.DumpToken(Tok, true);
644  llvm::errs() << "\n";
645  } while (Tok.isNot(tok::eof));
646 }
647 
650  raw_pwrite_stream *OS = CI.createDefaultOutputFile(true, getCurrentFile());
651  if (!OS)
652  return;
653 
654  CacheTokens(CI.getPreprocessor(), OS);
655 }
656 
659 
660  // Ignore unknown pragmas.
661  PP.IgnorePragmas();
662 
663  Token Tok;
664  // Start parsing the specified input file.
665  PP.EnterMainSourceFile();
666  do {
667  PP.Lex(Tok);
668  } while (Tok.isNot(tok::eof));
669 }
670 
673  // Output file may need to be set to 'Binary', to avoid converting Unix style
674  // line feeds (<LF>) to Microsoft style line feeds (<CR><LF>).
675  //
676  // Look to see what type of line endings the file uses. If there's a
677  // CRLF, then we won't open the file up in binary mode. If there is
678  // just an LF or CR, then we will open the file up in binary mode.
679  // In this fashion, the output format should match the input format, unless
680  // the input format has inconsistent line endings.
681  //
682  // This should be a relatively fast operation since most files won't have
683  // all of their source code on a single line. However, that is still a
684  // concern, so if we scan for too long, we'll just assume the file should
685  // be opened in binary mode.
686  bool BinaryMode = true;
687  bool InvalidFile = false;
688  const SourceManager& SM = CI.getSourceManager();
689  const llvm::MemoryBuffer *Buffer = SM.getBuffer(SM.getMainFileID(),
690  &InvalidFile);
691  if (!InvalidFile) {
692  const char *cur = Buffer->getBufferStart();
693  const char *end = Buffer->getBufferEnd();
694  const char *next = (cur != end) ? cur + 1 : end;
695 
696  // Limit ourselves to only scanning 256 characters into the source
697  // file. This is mostly a sanity check in case the file has no
698  // newlines whatsoever.
699  if (end - cur > 256) end = cur + 256;
700 
701  while (next < end) {
702  if (*cur == 0x0D) { // CR
703  if (*next == 0x0A) // CRLF
704  BinaryMode = false;
705 
706  break;
707  } else if (*cur == 0x0A) // LF
708  break;
709 
710  ++cur, ++next;
711  }
712  }
713 
714  raw_ostream *OS = CI.createDefaultOutputFile(BinaryMode, getCurrentFile());
715  if (!OS) return;
716 
719 }
720 
722  switch (getCurrentFileKind()) {
723  case IK_C:
724  case IK_CXX:
725  case IK_ObjC:
726  case IK_ObjCXX:
727  case IK_OpenCL:
728  case IK_CUDA:
729  break;
730 
731  case IK_None:
732  case IK_Asm:
733  case IK_PreprocessedC:
734  case IK_PreprocessedCuda:
735  case IK_PreprocessedCXX:
736  case IK_PreprocessedObjC:
738  case IK_AST:
739  case IK_LLVM_IR:
740  // We can't do anything with these.
741  return;
742  }
743 
746  if (Buffer) {
747  unsigned Preamble =
748  Lexer::ComputePreamble((*Buffer)->getBuffer(), CI.getLangOpts()).first;
749  llvm::outs().write((*Buffer)->getBufferStart(), Preamble);
750  }
751 }
std::string OutputFile
The output file, if any.
SourceManager & getSourceManager() const
Definition: Preprocessor.h:687
LangOptions & getLangOpts()
ASTContext & getASTContext() const
std::unique_ptr< ASTConsumer > CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override
Create the AST consumer object for this action, if supported.
PreprocessorOptions & getPreprocessorOpts()
Header getUmbrellaHeader() const
Retrieve the header that serves as the umbrella header for this module.
Definition: Basic/Module.h:401
std::vector< std::pair< std::string, bool > > Macros
Lexer - This provides a simple interface that turns a text buffer into a stream of tokens...
Definition: Lexer.h:46
bool BeginSourceFileAction(CompilerInstance &CI, StringRef Filename) override
Callback at the start of processing a single input.
unsigned UseLibcxx
Use libc++ instead of the default libstdc++.
Implements support for file system lookup, file system caching, and directory search management...
Definition: FileManager.h:115
static std::pair< unsigned, bool > ComputePreamble(StringRef Buffer, const LangOptions &LangOpts, unsigned MaxLines=0)
Compute the preamble of the given file.
Definition: Lexer.cpp:537
Defines the clang::FileManager interface and associated types.
submodule_iterator submodule_begin()
Definition: Basic/Module.h:474
unsigned IsExternC
Whether this is an 'extern "C"' module (which implicitly puts all headers in it within an 'extern "...
Definition: Basic/Module.h:178
std::unique_ptr< ASTConsumer > CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override
Create the AST consumer object for this action, if supported.
CompilerInstance & getCompilerInstance() const
llvm::MemoryBuffer * getBuffer(FileID FID, SourceLocation Loc, bool *Invalid=nullptr) const
Return the buffer for the specified FileID.
std::string getModuleFileName(Module *Module)
Retrieve the name of the module file that should be used to load the given module.
std::unique_ptr< llvm::MemoryBuffer > Buffer
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1117
PreprocessorOptions - This class is used for passing the various options used in preprocessor initial...
std::string ASTDumpFilter
If given, filter dumped AST Decl nodes by this substring.
TargetInfo & getTarget() const
SourceManager & getSourceManager() const
Return the current source manager.
void IgnorePragmas()
Install empty handlers for all pragmas (making them ignored).
Definition: Pragma.cpp:1488
Options for controlling the target.
Definition: TargetOptions.h:24
InputKind getCurrentFileKind() const
ModuleMap & getModuleMap()
Retrieve the module map.
Definition: HeaderSearch.h:591
bool isHeaderUnavailableInModule(const FileEntry *Header, const Module *RequestingModule) const
Determine whether the given header is unavailable as part of the specified module.
Definition: ModuleMap.cpp:443
void DumpToken(const Token &Tok, bool DumpFlags=false) const
Print the token to stderr, used for debugging.
std::string getFullModuleName() const
Retrieve the full name of this module, including the path from its top-level module.
std::unique_ptr< ASTConsumer > CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override
Create the AST consumer object for this action, if supported.
static StringRef getModuleInputBufferName()
Definition: Basic/Module.h:492
static bool readASTFileControlBlock(StringRef Filename, FileManager &FileMgr, const PCHContainerReader &PCHContainerRdr, bool FindModuleFileExtensions, ASTReaderListener &Listener)
Read the control block for the named AST file.
Definition: ASTReader.cpp:4189
void ExecuteAction() override
Callback to run the program action, using the initialized compiler instance.
const LangOptions & getLangOpts() const
Definition: Preprocessor.h:683
Token - This structure provides full information about a lexed token.
Definition: Token.h:37
unsigned DetailedRecord
Whether we should maintain a detailed record of all macro definitions and expansions.
The client can handle an AST file that cannot load because it's compiled configuration doesn't match ...
Definition: ASTReader.h:1351
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:48
void ExecuteAction() override
Callback to run the program action, using the initialized compiler instance.
unsigned BuildingImplicitModule
Whether we are performing an implicit module build.
std::vector< std::string > ModulesEmbedFiles
The list of files to embed into the compiled module file.
Describes a module or submodule.
Definition: Basic/Module.h:47
unsigned RelocatablePCH
When generating PCH files, instruct the AST writer to create relocatable PCH files.
virtual std::unique_ptr< ASTConsumer > CreatePCHContainerGenerator(CompilerInstance &CI, const std::string &MainFileName, const std::string &OutputFileName, llvm::raw_pwrite_stream *OS, std::shared_ptr< PCHBuffer > Buffer) const =0
Return an ASTConsumer that can be chained with a PCHGenerator that produces a wrapper file format con...
std::string UserInfo
A string containing additional user information that will be stored with the metadata.
bool isAvailable() const
Determine whether this module is available for use within the current translation unit...
Definition: Basic/Module.h:314
FrontendOptions & getFrontendOpts()
PreprocessorOutputOptions & getPreprocessorOutputOpts()
HeaderSearch & getHeaderSearchInfo() const
Definition: Preprocessor.h:688
std::unique_ptr< ASTConsumer > CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override
Create the AST consumer object for this action, if supported.
Module * Parent
The parent of this module.
Definition: Basic/Module.h:57
unsigned IsInferred
Whether this is an inferred submodule (module * { ... }).
Definition: Basic/Module.h:181
submodule_iterator submodule_end()
Definition: Basic/Module.h:476
void CacheTokens(Preprocessor &PP, raw_pwrite_stream *OS)
Cache tokens for use with PCH. Note that this requires a seekable stream.
std::unique_ptr< ASTConsumer > CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override
Create the AST consumer object for this action, if supported.
#define DUMP_BOOLEAN(Value, Text)
iterator end() const
HeaderSearchOptions & getHeaderSearchOpts()
void ExecuteAction() override
Implement the ExecuteAction interface by running Sema on the already-initialized AST consumer...
detail::InMemoryDirectory::const_iterator I
Preprocessor & getPreprocessor() const
Return the current preprocessor.
std::vector< Module * >::iterator submodule_iterator
Definition: Basic/Module.h:471
std::vector< std::string > ModuleFeatures
The names of any features to enable in module 'requires' decls in addition to the hard-coded list in ...
Definition: LangOptions.h:107
Encapsulates the information needed to find the file referenced by a #include or #include_next, (sub-)framework lookup, etc.
Definition: HeaderSearch.h:137
unsigned IsSystem
Whether this is a "system" module (which assumes that all headers in it are system headers)...
Definition: Basic/Module.h:173
const FileEntry * getFile(StringRef Filename, bool OpenFile=false, bool CacheFailure=true)
Lookup, cache, and verify the specified file (real or virtual).
std::string CurrentModule
The name of the current module.
Definition: LangOptions.h:96
StringRef Filename
Definition: Format.cpp:1723
static std::error_code addHeaderInclude(StringRef HeaderName, SmallVectorImpl< char > &Includes, const LangOptions &LangOpts, bool IsExternC)
const SmallVectorImpl< AnnotatedLine * >::const_iterator End
void setCurrentInput(const FrontendInputFile &CurrentInput, std::unique_ptr< ASTUnit > AST=nullptr)
void setFileIsTransient(const FileEntry *SourceFile)
Specify that a file is transient.
SourceManager & SM
unsigned UsePredefines
Initialize the preprocessor with the compiler and target specific predefines.
void DoPrintPreprocessedInput(Preprocessor &PP, raw_ostream *OS, const PreprocessorOutputOptions &Opts)
DoPrintPreprocessedInput - Implement -E mode.
ModuleBuildStack getModuleBuildStack() const
Retrieve the module build stack.
static SmallVectorImpl< char > & operator+=(SmallVectorImpl< char > &Includes, StringRef RHS)
SourceManager & SourceMgr
Definition: Format.cpp:1352
bool loadModuleMapFile(const FileEntry *File, bool IsSystem)
Read the contents of the given module map file.
void EnterMainSourceFile()
Enter the specified FileID as the main source file, which implicitly adds the builtin defines etc...
Defines the clang::Preprocessor interface.
unsigned UseBuiltinIncludes
Include the compiler builtin includes.
unsigned ModulesEmbedAllFiles
Whether we should embed all used files into the PCM file.
bool isNot(tok::TokenKind K) const
Definition: Token.h:96
An input file for the front end.
DiagnosticsEngine & getDiagnostics() const
Get the current diagnostics engine.
DirectoryName getUmbrellaDir() const
Retrieve the directory for which this module serves as the umbrella.
static std::error_code collectModuleHeaderIncludes(const LangOptions &LangOpts, FileManager &FileMgr, ModuleMap &ModMap, clang::Module *Module, SmallVectorImpl< char > &Includes)
Collect the set of header includes needed to construct the given module and update the TopHeaders fil...
Information about a header directive as found in the module map file.
Definition: Basic/Module.h:109
Module * lookupModule(StringRef ModuleName, bool AllowSearch=true)
Lookup a module Search for a module with the given name.
unsigned MajorVersion
The major version of the extension data.
unsigned MinorVersion
The minor version of the extension data.
std::string CPU
If given, the name of the target CPU to generate code for.
Definition: TargetOptions.h:31
const DirectoryEntry * Directory
The build directory of this module.
Definition: Basic/Module.h:62
void ExecuteAction() override
Callback to run the program action, using the initialized compiler instance.
std::string ABI
If given, the name of the target ABI to use.
Definition: TargetOptions.h:37
File is a PCH file treated as the preamble.
const char * getName() const
Definition: FileManager.h:84
void ExecuteAction() override
Callback to run the program action, using the initialized compiler instance.
CompilerInstance - Helper class for managing a single instance of the Clang compiler.
Encodes a location in the source.
unsigned UseStandardSystemIncludes
Include the system standard include search directories.
const PCHContainerReader & getPCHContainerReader() const
Return the appropriate PCHContainerReader depending on the current CodeGenOptions.
File is a PCH file treated as such.
raw_pwrite_stream * ComputeASTConsumerArguments(CompilerInstance &CI, StringRef InFile, std::string &Sysroot, std::string &OutputFile)
Compute the AST consumer arguments that will be used to create the PCHGenerator instance returned by ...
bool isValid() const
Return true if this is a valid SourceLocation object.
const StringRef getCurrentFile() const
Information about a directory name as found in the module map file.
Definition: Basic/Module.h:118
Cached information about one file (either on disk or in the virtual file system). ...
Definition: FileManager.h:53
SmallVector< Header, 2 > Headers[5]
The headers that are part of this module.
Definition: Basic/Module.h:126
std::string getClangFullRepositoryVersion()
Retrieves the full repository version that is an amalgamation of the information in getClangRepositor...
Definition: Version.cpp:90
void Lex(Token &Result)
Lex the next token for this preprocessor.
virtual bool ReadFullVersionInformation(StringRef FullVersion)
Receives the full Clang version information.
Definition: ASTReader.h:111
unsigned ASTDumpLookups
Whether we include lookup table dumps in AST dumps.
std::vector< std::string > FeaturesAsWritten
The list of target specific features to enable or disable, as written on the command line...
Definition: TargetOptions.h:43
void pushModuleBuildStack(StringRef moduleName, FullSourceLoc importLoc)
Push an entry to the module build stack.
FileID getMainFileID() const
Returns the FileID of the main source file.
void ExecuteAction() override
Callback to run the program action, using the initialized compiler instance.
std::unique_ptr< ASTConsumer > CreateASTPrinter(raw_ostream *OS, StringRef FilterString)
Stored information about a header directive that was found in the module map file but has not been re...
Definition: Basic/Module.h:130
void ExecuteAction() override
Callback to run the program action, using the initialized compiler instance.
std::unique_ptr< ASTConsumer > CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override
Create the AST consumer object for this action, if supported.
Reads an AST files chain containing the contents of a translation unit.
Definition: ASTReader.h:311
FileManager & getFileManager() const
Return the current file manager to the caller.
llvm::ErrorOr< std::unique_ptr< llvm::MemoryBuffer > > getBufferForFile(const FileEntry *Entry, bool isVolatile=false, bool ShouldCloseOpenFile=true)
Open the specified file as a MemoryBuffer, returning a new MemoryBuffer if successful, otherwise returning null.
std::unique_ptr< ASTConsumer > CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override
Create the AST consumer object for this action, if supported.
void addTopHeader(const FileEntry *File)
Add a top-level header associated with this module.
Definition: Basic/Module.h:414
std::string BlockName
The name used to identify this particular extension block within the resulting module file...
Abstract interface for callback invocations by the ASTReader.
Definition: ASTReader.h:103
std::unique_ptr< ASTConsumer > CreateDeclContextPrinter()
std::pair< std::string, bool > Requirement
An individual requirement: a feature name and a flag indicating the required state of that feature...
Definition: Basic/Module.h:142
std::unique_ptr< ASTConsumer > CreateASTViewer()
Metadata for a module file extension.
const PCHContainerWriter & getPCHContainerWriter() const
Return the appropriate PCHContainerWriter depending on the current CodeGenOptions.
raw_pwrite_stream * createDefaultOutputFile(bool Binary=true, StringRef BaseInput="", StringRef Extension="")
Create the default output file (from the invocation's options) and add it to the list of tracked outp...
std::unique_ptr< ASTConsumer > CreateASTDeclNodeLister()
void setMainFileDir(const DirectoryEntry *Dir)
Set the directory in which the main file should be considered to have been found, if it is not a real...
unsigned ASTDumpDecls
Whether we include declaration dumps in AST dumps.
std::unique_ptr< ASTConsumer > CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override
Create the AST consumer object for this action, if supported.
std::pair< unsigned, bool > PrecompiledPreambleBytes
If non-zero, the implicit PCH include is actually a precompiled preamble that covers this number of b...
std::vector< IntrusiveRefCntPtr< ModuleFileExtension > > ModuleFileExtensions
The list of module file extensions.
A SourceLocation and its associated SourceManager.
HeaderSearchOptions - Helper class for storing options related to the initialization of the HeaderSea...
std::string Sysroot
If non-empty, the directory to use as a "virtual system root" for include paths.
std::unique_ptr< ASTConsumer > CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override
Create the AST consumer object for this action, if supported.
static raw_pwrite_stream * ComputeASTConsumerArguments(CompilerInstance &CI, StringRef InFile, std::string &Sysroot, std::string &OutputFile)
Compute the AST consumer arguments that will be used to create the PCHGenerator instance returned by ...
std::unique_ptr< ASTConsumer > CreateASTDumper(StringRef FilterString, bool DumpDecls, bool DumpLookups)
void setAllFilesAreTransient(bool Transient)
Specify that all files that are read during this compilation are transient.
std::unique_ptr< ASTConsumer > CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override
Create the AST consumer object for this action, if supported.
unsigned UseStandardCXXIncludes
Include the system standard C++ library include search directories.
void SetKeepWhitespaceMode(bool Val)
SetKeepWhitespaceMode - This method lets clients enable or disable whitespace retention mode...
Definition: Lexer.h:172
raw_pwrite_stream * createOutputFile(StringRef OutputPath, bool Binary, bool RemoveFileOnSignal, StringRef BaseInput, StringRef Extension, bool UseTemporary, bool CreateMissingDirectories=false)
Create a new output file and add it to the list of tracked output files, optionally deriving the outp...
std::string Triple
If given, the name of the target triple to compile for.
Definition: TargetOptions.h:28
void setInferredModuleAllowedBy(Module *M, const FileEntry *ModuleMap)
Definition: ModuleMap.cpp:851
This class handles loading and caching of source files into memory.
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:96
void ExecuteAction() override
Implement the ExecuteAction interface by running Sema on the already-initialized AST consumer...