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
10#include "clang/Frontend/FrontendActions.h"
11#include "clang/AST/ASTConsumer.h"
12#include "clang/Basic/FileManager.h"
13#include "clang/Frontend/ASTConsumers.h"
14#include "clang/Frontend/ASTUnit.h"
15#include "clang/Frontend/CompilerInstance.h"
16#include "clang/Frontend/FrontendDiagnostic.h"
17#include "clang/Frontend/Utils.h"
18#include "clang/Lex/HeaderSearch.h"
19#include "clang/Lex/Pragma.h"
20#include "clang/Lex/Preprocessor.h"
21#include "clang/Parse/Parser.h"
22#include "clang/Serialization/ASTReader.h"
23#include "clang/Serialization/ASTWriter.h"
24#include "llvm/Support/FileSystem.h"
25#include "llvm/Support/MemoryBuffer.h"
26#include "llvm/Support/raw_ostream.h"
27#include <memory>
28#include <system_error>
29
30using namespace clang;
31
32//===----------------------------------------------------------------------===//
33// Custom Actions
34//===----------------------------------------------------------------------===//
35
36ASTConsumer *InitOnlyAction::CreateASTConsumer(CompilerInstance &CI,
37                                               StringRef InFile) {
38  return new ASTConsumer();
39}
40
41void InitOnlyAction::ExecuteAction() {
42}
43
44//===----------------------------------------------------------------------===//
45// AST Consumer Actions
46//===----------------------------------------------------------------------===//
47
48ASTConsumer *ASTPrintAction::CreateASTConsumer(CompilerInstance &CI,
49                                               StringRef InFile) {
50  if (raw_ostream *OS = CI.createDefaultOutputFile(false, InFile))
51    return CreateASTPrinter(OS, CI.getFrontendOpts().ASTDumpFilter);
52  return nullptr;
53}
54
55ASTConsumer *ASTDumpAction::CreateASTConsumer(CompilerInstance &CI,
56                                              StringRef InFile) {
57  return CreateASTDumper(CI.getFrontendOpts().ASTDumpFilter,
58                         CI.getFrontendOpts().ASTDumpLookups);
59}
60
61ASTConsumer *ASTDeclListAction::CreateASTConsumer(CompilerInstance &CI,
62                                                  StringRef InFile) {
63  return CreateASTDeclNodeLister();
64}
65
66ASTConsumer *ASTViewAction::CreateASTConsumer(CompilerInstance &CI,
67                                              StringRef InFile) {
68  return CreateASTViewer();
69}
70
71ASTConsumer *DeclContextPrintAction::CreateASTConsumer(CompilerInstance &CI,
72                                                       StringRef InFile) {
73  return CreateDeclContextPrinter();
74}
75
76ASTConsumer *GeneratePCHAction::CreateASTConsumer(CompilerInstance &CI,
77                                                  StringRef InFile) {
78  std::string Sysroot;
79  std::string OutputFile;
80  raw_ostream *OS = nullptr;
81  if (ComputeASTConsumerArguments(CI, InFile, Sysroot, OutputFile, OS))
82    return nullptr;
83
84  if (!CI.getFrontendOpts().RelocatablePCH)
85    Sysroot.clear();
86  return new PCHGenerator(CI.getPreprocessor(), OutputFile, nullptr, Sysroot,
87                          OS);
88}
89
90bool GeneratePCHAction::ComputeASTConsumerArguments(CompilerInstance &CI,
91                                                    StringRef InFile,
92                                                    std::string &Sysroot,
93                                                    std::string &OutputFile,
94                                                    raw_ostream *&OS) {
95  Sysroot = CI.getHeaderSearchOpts().Sysroot;
96  if (CI.getFrontendOpts().RelocatablePCH && Sysroot.empty()) {
97    CI.getDiagnostics().Report(diag::err_relocatable_without_isysroot);
98    return true;
99  }
100
101  // We use createOutputFile here because this is exposed via libclang, and we
102  // must disable the RemoveFileOnSignal behavior.
103  // We use a temporary to avoid race conditions.
104  OS = CI.createOutputFile(CI.getFrontendOpts().OutputFile, /*Binary=*/true,
105                           /*RemoveFileOnSignal=*/false, InFile,
106                           /*Extension=*/"", /*useTemporary=*/true);
107  if (!OS)
108    return true;
109
110  OutputFile = CI.getFrontendOpts().OutputFile;
111  return false;
112}
113
114ASTConsumer *GenerateModuleAction::CreateASTConsumer(CompilerInstance &CI,
115                                                     StringRef InFile) {
116  std::string Sysroot;
117  std::string OutputFile;
118  raw_ostream *OS = nullptr;
119  if (ComputeASTConsumerArguments(CI, InFile, Sysroot, OutputFile, OS))
120    return nullptr;
121
122  return new PCHGenerator(CI.getPreprocessor(), OutputFile, Module,
123                          Sysroot, OS);
124}
125
126static SmallVectorImpl<char> &
127operator+=(SmallVectorImpl<char> &Includes, StringRef RHS) {
128  Includes.append(RHS.begin(), RHS.end());
129  return Includes;
130}
131
132static std::error_code addHeaderInclude(StringRef HeaderName,
133                                        SmallVectorImpl<char> &Includes,
134                                        const LangOptions &LangOpts,
135                                        bool IsExternC) {
136  if (IsExternC && LangOpts.CPlusPlus)
137    Includes += "extern \"C\" {\n";
138  if (LangOpts.ObjC1)
139    Includes += "#import \"";
140  else
141    Includes += "#include \"";
142  // Use an absolute path for the include; there's no reason to think that
143  // a relative path will work (. might not be on our include path) or that
144  // it will find the same file.
145  if (llvm::sys::path::is_absolute(HeaderName)) {
146    Includes += HeaderName;
147  } else {
148    SmallString<256> Header = HeaderName;
149    if (std::error_code Err = llvm::sys::fs::make_absolute(Header))
150      return Err;
151    Includes += Header;
152  }
153  Includes += "\"\n";
154  if (IsExternC && LangOpts.CPlusPlus)
155    Includes += "}\n";
156  return std::error_code();
157}
158
159static std::error_code addHeaderInclude(const FileEntry *Header,
160                                        SmallVectorImpl<char> &Includes,
161                                        const LangOptions &LangOpts,
162                                        bool IsExternC) {
163  return addHeaderInclude(Header->getName(), Includes, LangOpts, IsExternC);
164}
165
166/// \brief Collect the set of header includes needed to construct the given
167/// module and update the TopHeaders file set of the module.
168///
169/// \param Module The module we're collecting includes from.
170///
171/// \param Includes Will be augmented with the set of \#includes or \#imports
172/// needed to load all of the named headers.
173static std::error_code
174collectModuleHeaderIncludes(const LangOptions &LangOpts, FileManager &FileMgr,
175                            ModuleMap &ModMap, clang::Module *Module,
176                            SmallVectorImpl<char> &Includes) {
177  // Don't collect any headers for unavailable modules.
178  if (!Module->isAvailable())
179    return std::error_code();
180
181  // Add includes for each of these headers.
182  for (unsigned I = 0, N = Module->NormalHeaders.size(); I != N; ++I) {
183    const FileEntry *Header = Module->NormalHeaders[I];
184    Module->addTopHeader(Header);
185    if (std::error_code Err =
186            addHeaderInclude(Header, Includes, LangOpts, Module->IsExternC))
187      return Err;
188  }
189  // Note that Module->PrivateHeaders will not be a TopHeader.
190
191  if (const FileEntry *UmbrellaHeader = Module->getUmbrellaHeader()) {
192    Module->addTopHeader(UmbrellaHeader);
193    if (Module->Parent) {
194      // Include the umbrella header for submodules.
195      if (std::error_code Err = addHeaderInclude(UmbrellaHeader, Includes,
196                                                 LangOpts, Module->IsExternC))
197        return Err;
198    }
199  } else if (const DirectoryEntry *UmbrellaDir = Module->getUmbrellaDir()) {
200    // Add all of the headers we find in this subdirectory.
201    std::error_code EC;
202    SmallString<128> DirNative;
203    llvm::sys::path::native(UmbrellaDir->getName(), DirNative);
204    for (llvm::sys::fs::recursive_directory_iterator Dir(DirNative.str(), EC),
205                                                     DirEnd;
206         Dir != DirEnd && !EC; Dir.increment(EC)) {
207      // Check whether this entry has an extension typically associated with
208      // headers.
209      if (!llvm::StringSwitch<bool>(llvm::sys::path::extension(Dir->path()))
210          .Cases(".h", ".H", ".hh", ".hpp", true)
211          .Default(false))
212        continue;
213
214      // If this header is marked 'unavailable' in this module, don't include
215      // it.
216      if (const FileEntry *Header = FileMgr.getFile(Dir->path())) {
217        if (ModMap.isHeaderUnavailableInModule(Header, Module))
218          continue;
219        Module->addTopHeader(Header);
220      }
221
222      // Include this header as part of the umbrella directory.
223      if (std::error_code Err = addHeaderInclude(Dir->path(), Includes,
224                                                 LangOpts, Module->IsExternC))
225        return Err;
226    }
227
228    if (EC)
229      return EC;
230  }
231
232  // Recurse into submodules.
233  for (clang::Module::submodule_iterator Sub = Module->submodule_begin(),
234                                      SubEnd = Module->submodule_end();
235       Sub != SubEnd; ++Sub)
236    if (std::error_code Err = collectModuleHeaderIncludes(
237            LangOpts, FileMgr, ModMap, *Sub, Includes))
238      return Err;
239
240  return std::error_code();
241}
242
243bool GenerateModuleAction::BeginSourceFileAction(CompilerInstance &CI,
244                                                 StringRef Filename) {
245  // Find the module map file.
246  const FileEntry *ModuleMap = CI.getFileManager().getFile(Filename);
247  if (!ModuleMap)  {
248    CI.getDiagnostics().Report(diag::err_module_map_not_found)
249      << Filename;
250    return false;
251  }
252
253  // Parse the module map file.
254  HeaderSearch &HS = CI.getPreprocessor().getHeaderSearchInfo();
255  if (HS.loadModuleMapFile(ModuleMap, IsSystem))
256    return false;
257
258  if (CI.getLangOpts().CurrentModule.empty()) {
259    CI.getDiagnostics().Report(diag::err_missing_module_name);
260
261    // FIXME: Eventually, we could consider asking whether there was just
262    // a single module described in the module map, and use that as a
263    // default. Then it would be fairly trivial to just "compile" a module
264    // map with a single module (the common case).
265    return false;
266  }
267
268  // If we're being run from the command-line, the module build stack will not
269  // have been filled in yet, so complete it now in order to allow us to detect
270  // module cycles.
271  SourceManager &SourceMgr = CI.getSourceManager();
272  if (SourceMgr.getModuleBuildStack().empty())
273    SourceMgr.pushModuleBuildStack(CI.getLangOpts().CurrentModule,
274                                   FullSourceLoc(SourceLocation(), SourceMgr));
275
276  // Dig out the module definition.
277  Module = HS.lookupModule(CI.getLangOpts().CurrentModule,
278                           /*AllowSearch=*/false);
279  if (!Module) {
280    CI.getDiagnostics().Report(diag::err_missing_module)
281      << CI.getLangOpts().CurrentModule << Filename;
282
283    return false;
284  }
285
286  // Check whether we can build this module at all.
287  clang::Module::Requirement Requirement;
288  clang::Module::HeaderDirective MissingHeader;
289  if (!Module->isAvailable(CI.getLangOpts(), CI.getTarget(), Requirement,
290                           MissingHeader)) {
291    if (MissingHeader.FileNameLoc.isValid()) {
292      CI.getDiagnostics().Report(MissingHeader.FileNameLoc,
293                                 diag::err_module_header_missing)
294        << MissingHeader.IsUmbrella << MissingHeader.FileName;
295    } else {
296      CI.getDiagnostics().Report(diag::err_module_unavailable)
297        << Module->getFullModuleName()
298        << Requirement.second << Requirement.first;
299    }
300
301    return false;
302  }
303
304  if (!ModuleMapForUniquing)
305    ModuleMapForUniquing = ModuleMap;
306  Module->ModuleMap = ModuleMapForUniquing;
307  assert(Module->ModuleMap && "missing module map file");
308
309  FileManager &FileMgr = CI.getFileManager();
310
311  // Collect the set of #includes we need to build the module.
312  SmallString<256> HeaderContents;
313  std::error_code Err = std::error_code();
314  if (const FileEntry *UmbrellaHeader = Module->getUmbrellaHeader())
315    Err = addHeaderInclude(UmbrellaHeader, HeaderContents, CI.getLangOpts(),
316                           Module->IsExternC);
317  if (!Err)
318    Err = collectModuleHeaderIncludes(
319        CI.getLangOpts(), FileMgr,
320        CI.getPreprocessor().getHeaderSearchInfo().getModuleMap(), Module,
321        HeaderContents);
322
323  if (Err) {
324    CI.getDiagnostics().Report(diag::err_module_cannot_create_includes)
325      << Module->getFullModuleName() << Err.message();
326    return false;
327  }
328
329  llvm::MemoryBuffer *InputBuffer =
330      llvm::MemoryBuffer::getMemBufferCopy(HeaderContents,
331                                           Module::getModuleInputBufferName());
332  // Ownership of InputBuffer will be transferred to the SourceManager.
333  setCurrentInput(FrontendInputFile(InputBuffer, getCurrentFileKind(),
334                                    Module->IsSystem));
335  return true;
336}
337
338bool GenerateModuleAction::ComputeASTConsumerArguments(CompilerInstance &CI,
339                                                       StringRef InFile,
340                                                       std::string &Sysroot,
341                                                       std::string &OutputFile,
342                                                       raw_ostream *&OS) {
343  // If no output file was provided, figure out where this module would go
344  // in the module cache.
345  if (CI.getFrontendOpts().OutputFile.empty()) {
346    HeaderSearch &HS = CI.getPreprocessor().getHeaderSearchInfo();
347    CI.getFrontendOpts().OutputFile =
348        HS.getModuleFileName(CI.getLangOpts().CurrentModule,
349                             ModuleMapForUniquing->getName());
350  }
351
352  // We use createOutputFile here because this is exposed via libclang, and we
353  // must disable the RemoveFileOnSignal behavior.
354  // We use a temporary to avoid race conditions.
355  OS = CI.createOutputFile(CI.getFrontendOpts().OutputFile, /*Binary=*/true,
356                           /*RemoveFileOnSignal=*/false, InFile,
357                           /*Extension=*/"", /*useTemporary=*/true,
358                           /*CreateMissingDirectories=*/true);
359  if (!OS)
360    return true;
361
362  OutputFile = CI.getFrontendOpts().OutputFile;
363  return false;
364}
365
366ASTConsumer *SyntaxOnlyAction::CreateASTConsumer(CompilerInstance &CI,
367                                                 StringRef InFile) {
368  return new ASTConsumer();
369}
370
371ASTConsumer *DumpModuleInfoAction::CreateASTConsumer(CompilerInstance &CI,
372                                                     StringRef InFile) {
373  return new ASTConsumer();
374}
375
376ASTConsumer *VerifyPCHAction::CreateASTConsumer(CompilerInstance &CI,
377                                                StringRef InFile) {
378  return new ASTConsumer();
379}
380
381void VerifyPCHAction::ExecuteAction() {
382  CompilerInstance &CI = getCompilerInstance();
383  bool Preamble = CI.getPreprocessorOpts().PrecompiledPreambleBytes.first != 0;
384  const std::string &Sysroot = CI.getHeaderSearchOpts().Sysroot;
385  std::unique_ptr<ASTReader> Reader(
386      new ASTReader(CI.getPreprocessor(), CI.getASTContext(),
387                    Sysroot.empty() ? "" : Sysroot.c_str(),
388                    /*DisableValidation*/ false,
389                    /*AllowPCHWithCompilerErrors*/ false,
390                    /*AllowConfigurationMismatch*/ true,
391                    /*ValidateSystemInputs*/ true));
392
393  Reader->ReadAST(getCurrentFile(),
394                  Preamble ? serialization::MK_Preamble
395                           : serialization::MK_PCH,
396                  SourceLocation(),
397                  ASTReader::ARR_ConfigurationMismatch);
398}
399
400namespace {
401  /// \brief AST reader listener that dumps module information for a module
402  /// file.
403  class DumpModuleInfoListener : public ASTReaderListener {
404    llvm::raw_ostream &Out;
405
406  public:
407    DumpModuleInfoListener(llvm::raw_ostream &Out) : Out(Out) { }
408
409#define DUMP_BOOLEAN(Value, Text)                       \
410    Out.indent(4) << Text << ": " << (Value? "Yes" : "No") << "\n"
411
412    bool ReadFullVersionInformation(StringRef FullVersion) override {
413      Out.indent(2)
414        << "Generated by "
415        << (FullVersion == getClangFullRepositoryVersion()? "this"
416                                                          : "a different")
417        << " Clang: " << FullVersion << "\n";
418      return ASTReaderListener::ReadFullVersionInformation(FullVersion);
419    }
420
421    void ReadModuleName(StringRef ModuleName) override {
422      Out.indent(2) << "Module name: " << ModuleName << "\n";
423    }
424    void ReadModuleMapFile(StringRef ModuleMapPath) override {
425      Out.indent(2) << "Module map file: " << ModuleMapPath << "\n";
426    }
427
428    bool ReadLanguageOptions(const LangOptions &LangOpts,
429                             bool Complain) override {
430      Out.indent(2) << "Language options:\n";
431#define LANGOPT(Name, Bits, Default, Description) \
432      DUMP_BOOLEAN(LangOpts.Name, Description);
433#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
434      Out.indent(4) << Description << ": "                   \
435                    << static_cast<unsigned>(LangOpts.get##Name()) << "\n";
436#define VALUE_LANGOPT(Name, Bits, Default, Description) \
437      Out.indent(4) << Description << ": " << LangOpts.Name << "\n";
438#define BENIGN_LANGOPT(Name, Bits, Default, Description)
439#define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
440#include "clang/Basic/LangOptions.def"
441      return false;
442    }
443
444    bool ReadTargetOptions(const TargetOptions &TargetOpts,
445                           bool Complain) override {
446      Out.indent(2) << "Target options:\n";
447      Out.indent(4) << "  Triple: " << TargetOpts.Triple << "\n";
448      Out.indent(4) << "  CPU: " << TargetOpts.CPU << "\n";
449      Out.indent(4) << "  ABI: " << TargetOpts.ABI << "\n";
450
451      if (!TargetOpts.FeaturesAsWritten.empty()) {
452        Out.indent(4) << "Target features:\n";
453        for (unsigned I = 0, N = TargetOpts.FeaturesAsWritten.size();
454             I != N; ++I) {
455          Out.indent(6) << TargetOpts.FeaturesAsWritten[I] << "\n";
456        }
457      }
458
459      return false;
460    }
461
462    virtual bool
463    ReadDiagnosticOptions(IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts,
464                          bool Complain) override {
465      Out.indent(2) << "Diagnostic options:\n";
466#define DIAGOPT(Name, Bits, Default) DUMP_BOOLEAN(DiagOpts->Name, #Name);
467#define ENUM_DIAGOPT(Name, Type, Bits, Default) \
468      Out.indent(4) << #Name << ": " << DiagOpts->get##Name() << "\n";
469#define VALUE_DIAGOPT(Name, Bits, Default) \
470      Out.indent(4) << #Name << ": " << DiagOpts->Name << "\n";
471#include "clang/Basic/DiagnosticOptions.def"
472
473      Out.indent(4) << "Warning options:\n";
474      for (const std::string &Warning : DiagOpts->Warnings) {
475        Out.indent(6) << "-W" << Warning << "\n";
476      }
477
478      return false;
479    }
480
481    bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
482                                 bool Complain) override {
483      Out.indent(2) << "Header search options:\n";
484      Out.indent(4) << "System root [-isysroot=]: '" << HSOpts.Sysroot << "'\n";
485      DUMP_BOOLEAN(HSOpts.UseBuiltinIncludes,
486                   "Use builtin include directories [-nobuiltininc]");
487      DUMP_BOOLEAN(HSOpts.UseStandardSystemIncludes,
488                   "Use standard system include directories [-nostdinc]");
489      DUMP_BOOLEAN(HSOpts.UseStandardCXXIncludes,
490                   "Use standard C++ include directories [-nostdinc++]");
491      DUMP_BOOLEAN(HSOpts.UseLibcxx,
492                   "Use libc++ (rather than libstdc++) [-stdlib=]");
493      return false;
494    }
495
496    bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
497                                 bool Complain,
498                                 std::string &SuggestedPredefines) override {
499      Out.indent(2) << "Preprocessor options:\n";
500      DUMP_BOOLEAN(PPOpts.UsePredefines,
501                   "Uses compiler/target-specific predefines [-undef]");
502      DUMP_BOOLEAN(PPOpts.DetailedRecord,
503                   "Uses detailed preprocessing record (for indexing)");
504
505      if (!PPOpts.Macros.empty()) {
506        Out.indent(4) << "Predefined macros:\n";
507      }
508
509      for (std::vector<std::pair<std::string, bool/*isUndef*/> >::const_iterator
510             I = PPOpts.Macros.begin(), IEnd = PPOpts.Macros.end();
511           I != IEnd; ++I) {
512        Out.indent(6);
513        if (I->second)
514          Out << "-U";
515        else
516          Out << "-D";
517        Out << I->first << "\n";
518      }
519      return false;
520    }
521#undef DUMP_BOOLEAN
522  };
523}
524
525void DumpModuleInfoAction::ExecuteAction() {
526  // Set up the output file.
527  std::unique_ptr<llvm::raw_fd_ostream> OutFile;
528  StringRef OutputFileName = getCompilerInstance().getFrontendOpts().OutputFile;
529  if (!OutputFileName.empty() && OutputFileName != "-") {
530    std::string ErrorInfo;
531    OutFile.reset(new llvm::raw_fd_ostream(OutputFileName.str().c_str(),
532                                           ErrorInfo, llvm::sys::fs::F_Text));
533  }
534  llvm::raw_ostream &Out = OutFile.get()? *OutFile.get() : llvm::outs();
535
536  Out << "Information for module file '" << getCurrentFile() << "':\n";
537  DumpModuleInfoListener Listener(Out);
538  ASTReader::readASTFileControlBlock(getCurrentFile(),
539                                     getCompilerInstance().getFileManager(),
540                                     Listener);
541}
542
543//===----------------------------------------------------------------------===//
544// Preprocessor Actions
545//===----------------------------------------------------------------------===//
546
547void DumpRawTokensAction::ExecuteAction() {
548  Preprocessor &PP = getCompilerInstance().getPreprocessor();
549  SourceManager &SM = PP.getSourceManager();
550
551  // Start lexing the specified input file.
552  const llvm::MemoryBuffer *FromFile = SM.getBuffer(SM.getMainFileID());
553  Lexer RawLex(SM.getMainFileID(), FromFile, SM, PP.getLangOpts());
554  RawLex.SetKeepWhitespaceMode(true);
555
556  Token RawTok;
557  RawLex.LexFromRawLexer(RawTok);
558  while (RawTok.isNot(tok::eof)) {
559    PP.DumpToken(RawTok, true);
560    llvm::errs() << "\n";
561    RawLex.LexFromRawLexer(RawTok);
562  }
563}
564
565void DumpTokensAction::ExecuteAction() {
566  Preprocessor &PP = getCompilerInstance().getPreprocessor();
567  // Start preprocessing the specified input file.
568  Token Tok;
569  PP.EnterMainSourceFile();
570  do {
571    PP.Lex(Tok);
572    PP.DumpToken(Tok, true);
573    llvm::errs() << "\n";
574  } while (Tok.isNot(tok::eof));
575}
576
577void GeneratePTHAction::ExecuteAction() {
578  CompilerInstance &CI = getCompilerInstance();
579  if (CI.getFrontendOpts().OutputFile.empty() ||
580      CI.getFrontendOpts().OutputFile == "-") {
581    // FIXME: Don't fail this way.
582    // FIXME: Verify that we can actually seek in the given file.
583    llvm::report_fatal_error("PTH requires a seekable file for output!");
584  }
585  llvm::raw_fd_ostream *OS =
586    CI.createDefaultOutputFile(true, getCurrentFile());
587  if (!OS) return;
588
589  CacheTokens(CI.getPreprocessor(), OS);
590}
591
592void PreprocessOnlyAction::ExecuteAction() {
593  Preprocessor &PP = getCompilerInstance().getPreprocessor();
594
595  // Ignore unknown pragmas.
596  PP.IgnorePragmas();
597
598  Token Tok;
599  // Start parsing the specified input file.
600  PP.EnterMainSourceFile();
601  do {
602    PP.Lex(Tok);
603  } while (Tok.isNot(tok::eof));
604}
605
606void PrintPreprocessedAction::ExecuteAction() {
607  CompilerInstance &CI = getCompilerInstance();
608  // Output file may need to be set to 'Binary', to avoid converting Unix style
609  // line feeds (<LF>) to Microsoft style line feeds (<CR><LF>).
610  //
611  // Look to see what type of line endings the file uses. If there's a
612  // CRLF, then we won't open the file up in binary mode. If there is
613  // just an LF or CR, then we will open the file up in binary mode.
614  // In this fashion, the output format should match the input format, unless
615  // the input format has inconsistent line endings.
616  //
617  // This should be a relatively fast operation since most files won't have
618  // all of their source code on a single line. However, that is still a
619  // concern, so if we scan for too long, we'll just assume the file should
620  // be opened in binary mode.
621  bool BinaryMode = true;
622  bool InvalidFile = false;
623  const SourceManager& SM = CI.getSourceManager();
624  const llvm::MemoryBuffer *Buffer = SM.getBuffer(SM.getMainFileID(),
625                                                     &InvalidFile);
626  if (!InvalidFile) {
627    const char *cur = Buffer->getBufferStart();
628    const char *end = Buffer->getBufferEnd();
629    const char *next = (cur != end) ? cur + 1 : end;
630
631    // Limit ourselves to only scanning 256 characters into the source
632    // file.  This is mostly a sanity check in case the file has no
633    // newlines whatsoever.
634    if (end - cur > 256) end = cur + 256;
635
636    while (next < end) {
637      if (*cur == 0x0D) {  // CR
638        if (*next == 0x0A)  // CRLF
639          BinaryMode = false;
640
641        break;
642      } else if (*cur == 0x0A)  // LF
643        break;
644
645      ++cur, ++next;
646    }
647  }
648
649  raw_ostream *OS = CI.createDefaultOutputFile(BinaryMode, getCurrentFile());
650  if (!OS) return;
651
652  DoPrintPreprocessedInput(CI.getPreprocessor(), OS,
653                           CI.getPreprocessorOutputOpts());
654}
655
656void PrintPreambleAction::ExecuteAction() {
657  switch (getCurrentFileKind()) {
658  case IK_C:
659  case IK_CXX:
660  case IK_ObjC:
661  case IK_ObjCXX:
662  case IK_OpenCL:
663  case IK_CUDA:
664    break;
665
666  case IK_None:
667  case IK_Asm:
668  case IK_PreprocessedC:
669  case IK_PreprocessedCXX:
670  case IK_PreprocessedObjC:
671  case IK_PreprocessedObjCXX:
672  case IK_AST:
673  case IK_LLVM_IR:
674    // We can't do anything with these.
675    return;
676  }
677
678  CompilerInstance &CI = getCompilerInstance();
679  llvm::MemoryBuffer *Buffer
680      = CI.getFileManager().getBufferForFile(getCurrentFile());
681  if (Buffer) {
682    unsigned Preamble = Lexer::ComputePreamble(Buffer, CI.getLangOpts()).first;
683    llvm::outs().write(Buffer->getBufferStart(), Preamble);
684    delete Buffer;
685  }
686}
687