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/CompilerInstance.h"
15 #include "clang/Frontend/FrontendDiagnostic.h"
16 #include "clang/Frontend/MultiplexConsumer.h"
17 #include "clang/Frontend/Utils.h"
18 #include "clang/Lex/HeaderSearch.h"
19 #include "clang/Lex/Preprocessor.h"
20 #include "clang/Lex/PreprocessorOptions.h"
21 #include "clang/Sema/TemplateInstCallback.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/Path.h"
27 #include "llvm/Support/raw_ostream.h"
28 #include "llvm/Support/YAMLTraits.h"
29 #include <memory>
30 #include <system_error>
31 
32 using namespace clang;
33 
34 namespace {
35 CodeCompleteConsumer *GetCodeCompletionConsumer(CompilerInstance &CI) {
36   return CI.hasCodeCompletionConsumer() ? &CI.getCodeCompletionConsumer()
37                                         : nullptr;
38 }
39 
40 void EnsureSemaIsCreated(CompilerInstance &CI, FrontendAction &Action) {
41   if (Action.hasCodeCompletionSupport() &&
42       !CI.getFrontendOpts().CodeCompletionAt.FileName.empty())
43     CI.createCodeCompletionConsumer();
44 
45   if (!CI.hasSema())
46     CI.createSema(Action.getTranslationUnitKind(),
47                   GetCodeCompletionConsumer(CI));
48 }
49 } // namespace
50 
51 //===----------------------------------------------------------------------===//
52 // Custom Actions
53 //===----------------------------------------------------------------------===//
54 
55 std::unique_ptr<ASTConsumer>
56 InitOnlyAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
57   return llvm::make_unique<ASTConsumer>();
58 }
59 
60 void InitOnlyAction::ExecuteAction() {
61 }
62 
63 //===----------------------------------------------------------------------===//
64 // AST Consumer Actions
65 //===----------------------------------------------------------------------===//
66 
67 std::unique_ptr<ASTConsumer>
68 ASTPrintAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
69   if (std::unique_ptr<raw_ostream> OS =
70           CI.createDefaultOutputFile(false, InFile))
71     return CreateASTPrinter(std::move(OS), CI.getFrontendOpts().ASTDumpFilter);
72   return nullptr;
73 }
74 
75 std::unique_ptr<ASTConsumer>
76 ASTDumpAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
77   return CreateASTDumper(CI.getFrontendOpts().ASTDumpFilter,
78                          CI.getFrontendOpts().ASTDumpDecls,
79                          CI.getFrontendOpts().ASTDumpAll,
80                          CI.getFrontendOpts().ASTDumpLookups);
81 }
82 
83 std::unique_ptr<ASTConsumer>
84 ASTDeclListAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
85   return CreateASTDeclNodeLister();
86 }
87 
88 std::unique_ptr<ASTConsumer>
89 ASTViewAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
90   return CreateASTViewer();
91 }
92 
93 std::unique_ptr<ASTConsumer>
94 DeclContextPrintAction::CreateASTConsumer(CompilerInstance &CI,
95                                           StringRef InFile) {
96   return CreateDeclContextPrinter();
97 }
98 
99 std::unique_ptr<ASTConsumer>
100 GeneratePCHAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
101   std::string Sysroot;
102   if (!ComputeASTConsumerArguments(CI, /*ref*/ Sysroot))
103     return nullptr;
104 
105   std::string OutputFile;
106   std::unique_ptr<raw_pwrite_stream> OS =
107       CreateOutputFile(CI, InFile, /*ref*/ OutputFile);
108   if (!OS)
109     return nullptr;
110 
111   if (!CI.getFrontendOpts().RelocatablePCH)
112     Sysroot.clear();
113 
114   auto Buffer = std::make_shared<PCHBuffer>();
115   std::vector<std::unique_ptr<ASTConsumer>> Consumers;
116   Consumers.push_back(llvm::make_unique<PCHGenerator>(
117                         CI.getPreprocessor(), OutputFile, Sysroot,
118                         Buffer, CI.getFrontendOpts().ModuleFileExtensions,
119       /*AllowASTWithErrors*/CI.getPreprocessorOpts().AllowPCHWithCompilerErrors,
120                         /*IncludeTimestamps*/
121                           +CI.getFrontendOpts().IncludeTimestamps));
122   Consumers.push_back(CI.getPCHContainerWriter().CreatePCHContainerGenerator(
123       CI, InFile, OutputFile, std::move(OS), Buffer));
124 
125   return llvm::make_unique<MultiplexConsumer>(std::move(Consumers));
126 }
127 
128 bool GeneratePCHAction::ComputeASTConsumerArguments(CompilerInstance &CI,
129                                                     std::string &Sysroot) {
130   Sysroot = CI.getHeaderSearchOpts().Sysroot;
131   if (CI.getFrontendOpts().RelocatablePCH && Sysroot.empty()) {
132     CI.getDiagnostics().Report(diag::err_relocatable_without_isysroot);
133     return false;
134   }
135 
136   return true;
137 }
138 
139 std::unique_ptr<llvm::raw_pwrite_stream>
140 GeneratePCHAction::CreateOutputFile(CompilerInstance &CI, StringRef InFile,
141                                     std::string &OutputFile) {
142   // We use createOutputFile here because this is exposed via libclang, and we
143   // must disable the RemoveFileOnSignal behavior.
144   // We use a temporary to avoid race conditions.
145   std::unique_ptr<raw_pwrite_stream> OS =
146       CI.createOutputFile(CI.getFrontendOpts().OutputFile, /*Binary=*/true,
147                           /*RemoveFileOnSignal=*/false, InFile,
148                           /*Extension=*/"", /*useTemporary=*/true);
149   if (!OS)
150     return nullptr;
151 
152   OutputFile = CI.getFrontendOpts().OutputFile;
153   return OS;
154 }
155 
156 bool GeneratePCHAction::shouldEraseOutputFiles() {
157   if (getCompilerInstance().getPreprocessorOpts().AllowPCHWithCompilerErrors)
158     return false;
159   return ASTFrontendAction::shouldEraseOutputFiles();
160 }
161 
162 bool GeneratePCHAction::BeginSourceFileAction(CompilerInstance &CI) {
163   CI.getLangOpts().CompilingPCH = true;
164   return true;
165 }
166 
167 std::unique_ptr<ASTConsumer>
168 GenerateModuleAction::CreateASTConsumer(CompilerInstance &CI,
169                                         StringRef InFile) {
170   std::unique_ptr<raw_pwrite_stream> OS = CreateOutputFile(CI, InFile);
171   if (!OS)
172     return nullptr;
173 
174   std::string OutputFile = CI.getFrontendOpts().OutputFile;
175   std::string Sysroot;
176 
177   auto Buffer = std::make_shared<PCHBuffer>();
178   std::vector<std::unique_ptr<ASTConsumer>> Consumers;
179 
180   Consumers.push_back(llvm::make_unique<PCHGenerator>(
181                         CI.getPreprocessor(), OutputFile, Sysroot,
182                         Buffer, CI.getFrontendOpts().ModuleFileExtensions,
183                         /*AllowASTWithErrors=*/false,
184                         /*IncludeTimestamps=*/
185                           +CI.getFrontendOpts().BuildingImplicitModule));
186   Consumers.push_back(CI.getPCHContainerWriter().CreatePCHContainerGenerator(
187       CI, InFile, OutputFile, std::move(OS), Buffer));
188   return llvm::make_unique<MultiplexConsumer>(std::move(Consumers));
189 }
190 
191 bool GenerateModuleFromModuleMapAction::BeginSourceFileAction(
192     CompilerInstance &CI) {
193   if (!CI.getLangOpts().Modules) {
194     CI.getDiagnostics().Report(diag::err_module_build_requires_fmodules);
195     return false;
196   }
197 
198   return GenerateModuleAction::BeginSourceFileAction(CI);
199 }
200 
201 std::unique_ptr<raw_pwrite_stream>
202 GenerateModuleFromModuleMapAction::CreateOutputFile(CompilerInstance &CI,
203                                                     StringRef InFile) {
204   // If no output file was provided, figure out where this module would go
205   // in the module cache.
206   if (CI.getFrontendOpts().OutputFile.empty()) {
207     StringRef ModuleMapFile = CI.getFrontendOpts().OriginalModuleMap;
208     if (ModuleMapFile.empty())
209       ModuleMapFile = InFile;
210 
211     HeaderSearch &HS = CI.getPreprocessor().getHeaderSearchInfo();
212     CI.getFrontendOpts().OutputFile =
213         HS.getCachedModuleFileName(CI.getLangOpts().CurrentModule,
214                                    ModuleMapFile);
215   }
216 
217   // We use createOutputFile here because this is exposed via libclang, and we
218   // must disable the RemoveFileOnSignal behavior.
219   // We use a temporary to avoid race conditions.
220   return CI.createOutputFile(CI.getFrontendOpts().OutputFile, /*Binary=*/true,
221                              /*RemoveFileOnSignal=*/false, InFile,
222                              /*Extension=*/"", /*useTemporary=*/true,
223                              /*CreateMissingDirectories=*/true);
224 }
225 
226 bool GenerateModuleInterfaceAction::BeginSourceFileAction(
227     CompilerInstance &CI) {
228   if (!CI.getLangOpts().ModulesTS) {
229     CI.getDiagnostics().Report(diag::err_module_interface_requires_modules_ts);
230     return false;
231   }
232 
233   CI.getLangOpts().setCompilingModule(LangOptions::CMK_ModuleInterface);
234 
235   return GenerateModuleAction::BeginSourceFileAction(CI);
236 }
237 
238 std::unique_ptr<raw_pwrite_stream>
239 GenerateModuleInterfaceAction::CreateOutputFile(CompilerInstance &CI,
240                                                 StringRef InFile) {
241   return CI.createDefaultOutputFile(/*Binary=*/true, InFile, "pcm");
242 }
243 
244 SyntaxOnlyAction::~SyntaxOnlyAction() {
245 }
246 
247 std::unique_ptr<ASTConsumer>
248 SyntaxOnlyAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
249   return llvm::make_unique<ASTConsumer>();
250 }
251 
252 std::unique_ptr<ASTConsumer>
253 DumpModuleInfoAction::CreateASTConsumer(CompilerInstance &CI,
254                                         StringRef InFile) {
255   return llvm::make_unique<ASTConsumer>();
256 }
257 
258 std::unique_ptr<ASTConsumer>
259 VerifyPCHAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
260   return llvm::make_unique<ASTConsumer>();
261 }
262 
263 void VerifyPCHAction::ExecuteAction() {
264   CompilerInstance &CI = getCompilerInstance();
265   bool Preamble = CI.getPreprocessorOpts().PrecompiledPreambleBytes.first != 0;
266   const std::string &Sysroot = CI.getHeaderSearchOpts().Sysroot;
267   std::unique_ptr<ASTReader> Reader(new ASTReader(
268       CI.getPreprocessor(), &CI.getASTContext(), CI.getPCHContainerReader(),
269       CI.getFrontendOpts().ModuleFileExtensions,
270       Sysroot.empty() ? "" : Sysroot.c_str(),
271       /*DisableValidation*/ false,
272       /*AllowPCHWithCompilerErrors*/ false,
273       /*AllowConfigurationMismatch*/ true,
274       /*ValidateSystemInputs*/ true));
275 
276   Reader->ReadAST(getCurrentFile(),
277                   Preamble ? serialization::MK_Preamble
278                            : serialization::MK_PCH,
279                   SourceLocation(),
280                   ASTReader::ARR_ConfigurationMismatch);
281 }
282 
283 namespace {
284 struct TemplightEntry {
285   std::string Name;
286   std::string Kind;
287   std::string Event;
288   std::string DefinitionLocation;
289   std::string PointOfInstantiation;
290 };
291 } // namespace
292 
293 namespace llvm {
294 namespace yaml {
295 template <> struct MappingTraits<TemplightEntry> {
296   static void mapping(IO &io, TemplightEntry &fields) {
297     io.mapRequired("name", fields.Name);
298     io.mapRequired("kind", fields.Kind);
299     io.mapRequired("event", fields.Event);
300     io.mapRequired("orig", fields.DefinitionLocation);
301     io.mapRequired("poi", fields.PointOfInstantiation);
302   }
303 };
304 } // namespace yaml
305 } // namespace llvm
306 
307 namespace {
308 class DefaultTemplateInstCallback : public TemplateInstantiationCallback {
309   using CodeSynthesisContext = Sema::CodeSynthesisContext;
310 
311 public:
312   void initialize(const Sema &) override {}
313 
314   void finalize(const Sema &) override {}
315 
316   void atTemplateBegin(const Sema &TheSema,
317                        const CodeSynthesisContext &Inst) override {
318     displayTemplightEntry<true>(llvm::outs(), TheSema, Inst);
319   }
320 
321   void atTemplateEnd(const Sema &TheSema,
322                      const CodeSynthesisContext &Inst) override {
323     displayTemplightEntry<false>(llvm::outs(), TheSema, Inst);
324   }
325 
326 private:
327   static std::string toString(CodeSynthesisContext::SynthesisKind Kind) {
328     switch (Kind) {
329     case CodeSynthesisContext::TemplateInstantiation:
330       return "TemplateInstantiation";
331     case CodeSynthesisContext::DefaultTemplateArgumentInstantiation:
332       return "DefaultTemplateArgumentInstantiation";
333     case CodeSynthesisContext::DefaultFunctionArgumentInstantiation:
334       return "DefaultFunctionArgumentInstantiation";
335     case CodeSynthesisContext::ExplicitTemplateArgumentSubstitution:
336       return "ExplicitTemplateArgumentSubstitution";
337     case CodeSynthesisContext::DeducedTemplateArgumentSubstitution:
338       return "DeducedTemplateArgumentSubstitution";
339     case CodeSynthesisContext::PriorTemplateArgumentSubstitution:
340       return "PriorTemplateArgumentSubstitution";
341     case CodeSynthesisContext::DefaultTemplateArgumentChecking:
342       return "DefaultTemplateArgumentChecking";
343     case CodeSynthesisContext::ExceptionSpecInstantiation:
344       return "ExceptionSpecInstantiation";
345     case CodeSynthesisContext::DeclaringSpecialMember:
346       return "DeclaringSpecialMember";
347     case CodeSynthesisContext::DefiningSynthesizedFunction:
348       return "DefiningSynthesizedFunction";
349     case CodeSynthesisContext::Memoization:
350       return "Memoization";
351     }
352     return "";
353   }
354 
355   template <bool BeginInstantiation>
356   static void displayTemplightEntry(llvm::raw_ostream &Out, const Sema &TheSema,
357                                     const CodeSynthesisContext &Inst) {
358     std::string YAML;
359     {
360       llvm::raw_string_ostream OS(YAML);
361       llvm::yaml::Output YO(OS);
362       TemplightEntry Entry =
363           getTemplightEntry<BeginInstantiation>(TheSema, Inst);
364       llvm::yaml::EmptyContext Context;
365       llvm::yaml::yamlize(YO, Entry, true, Context);
366     }
367     Out << "---" << YAML << "\n";
368   }
369 
370   template <bool BeginInstantiation>
371   static TemplightEntry getTemplightEntry(const Sema &TheSema,
372                                           const CodeSynthesisContext &Inst) {
373     TemplightEntry Entry;
374     Entry.Kind = toString(Inst.Kind);
375     Entry.Event = BeginInstantiation ? "Begin" : "End";
376     if (auto *NamedTemplate = dyn_cast_or_null<NamedDecl>(Inst.Entity)) {
377       llvm::raw_string_ostream OS(Entry.Name);
378       NamedTemplate->getNameForDiagnostic(OS, TheSema.getLangOpts(), true);
379       const PresumedLoc DefLoc =
380         TheSema.getSourceManager().getPresumedLoc(Inst.Entity->getLocation());
381       if(!DefLoc.isInvalid())
382         Entry.DefinitionLocation = std::string(DefLoc.getFilename()) + ":" +
383                                    std::to_string(DefLoc.getLine()) + ":" +
384                                    std::to_string(DefLoc.getColumn());
385     }
386     const PresumedLoc PoiLoc =
387         TheSema.getSourceManager().getPresumedLoc(Inst.PointOfInstantiation);
388     if (!PoiLoc.isInvalid()) {
389       Entry.PointOfInstantiation = std::string(PoiLoc.getFilename()) + ":" +
390                                    std::to_string(PoiLoc.getLine()) + ":" +
391                                    std::to_string(PoiLoc.getColumn());
392     }
393     return Entry;
394   }
395 };
396 } // namespace
397 
398 std::unique_ptr<ASTConsumer>
399 TemplightDumpAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
400   return llvm::make_unique<ASTConsumer>();
401 }
402 
403 void TemplightDumpAction::ExecuteAction() {
404   CompilerInstance &CI = getCompilerInstance();
405 
406   // This part is normally done by ASTFrontEndAction, but needs to happen
407   // before Templight observers can be created
408   // FIXME: Move the truncation aspect of this into Sema, we delayed this till
409   // here so the source manager would be initialized.
410   EnsureSemaIsCreated(CI, *this);
411 
412   CI.getSema().TemplateInstCallbacks.push_back(
413       llvm::make_unique<DefaultTemplateInstCallback>());
414   ASTFrontendAction::ExecuteAction();
415 }
416 
417 namespace {
418   /// \brief AST reader listener that dumps module information for a module
419   /// file.
420   class DumpModuleInfoListener : public ASTReaderListener {
421     llvm::raw_ostream &Out;
422 
423   public:
424     DumpModuleInfoListener(llvm::raw_ostream &Out) : Out(Out) { }
425 
426 #define DUMP_BOOLEAN(Value, Text)                       \
427     Out.indent(4) << Text << ": " << (Value? "Yes" : "No") << "\n"
428 
429     bool ReadFullVersionInformation(StringRef FullVersion) override {
430       Out.indent(2)
431         << "Generated by "
432         << (FullVersion == getClangFullRepositoryVersion()? "this"
433                                                           : "a different")
434         << " Clang: " << FullVersion << "\n";
435       return ASTReaderListener::ReadFullVersionInformation(FullVersion);
436     }
437 
438     void ReadModuleName(StringRef ModuleName) override {
439       Out.indent(2) << "Module name: " << ModuleName << "\n";
440     }
441     void ReadModuleMapFile(StringRef ModuleMapPath) override {
442       Out.indent(2) << "Module map file: " << ModuleMapPath << "\n";
443     }
444 
445     bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain,
446                              bool AllowCompatibleDifferences) override {
447       Out.indent(2) << "Language options:\n";
448 #define LANGOPT(Name, Bits, Default, Description) \
449       DUMP_BOOLEAN(LangOpts.Name, Description);
450 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
451       Out.indent(4) << Description << ": "                   \
452                     << static_cast<unsigned>(LangOpts.get##Name()) << "\n";
453 #define VALUE_LANGOPT(Name, Bits, Default, Description) \
454       Out.indent(4) << Description << ": " << LangOpts.Name << "\n";
455 #define BENIGN_LANGOPT(Name, Bits, Default, Description)
456 #define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
457 #include "clang/Basic/LangOptions.def"
458 
459       if (!LangOpts.ModuleFeatures.empty()) {
460         Out.indent(4) << "Module features:\n";
461         for (StringRef Feature : LangOpts.ModuleFeatures)
462           Out.indent(6) << Feature << "\n";
463       }
464 
465       return false;
466     }
467 
468     bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain,
469                            bool AllowCompatibleDifferences) override {
470       Out.indent(2) << "Target options:\n";
471       Out.indent(4) << "  Triple: " << TargetOpts.Triple << "\n";
472       Out.indent(4) << "  CPU: " << TargetOpts.CPU << "\n";
473       Out.indent(4) << "  ABI: " << TargetOpts.ABI << "\n";
474 
475       if (!TargetOpts.FeaturesAsWritten.empty()) {
476         Out.indent(4) << "Target features:\n";
477         for (unsigned I = 0, N = TargetOpts.FeaturesAsWritten.size();
478              I != N; ++I) {
479           Out.indent(6) << TargetOpts.FeaturesAsWritten[I] << "\n";
480         }
481       }
482 
483       return false;
484     }
485 
486     bool ReadDiagnosticOptions(IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts,
487                                bool Complain) override {
488       Out.indent(2) << "Diagnostic options:\n";
489 #define DIAGOPT(Name, Bits, Default) DUMP_BOOLEAN(DiagOpts->Name, #Name);
490 #define ENUM_DIAGOPT(Name, Type, Bits, Default) \
491       Out.indent(4) << #Name << ": " << DiagOpts->get##Name() << "\n";
492 #define VALUE_DIAGOPT(Name, Bits, Default) \
493       Out.indent(4) << #Name << ": " << DiagOpts->Name << "\n";
494 #include "clang/Basic/DiagnosticOptions.def"
495 
496       Out.indent(4) << "Diagnostic flags:\n";
497       for (const std::string &Warning : DiagOpts->Warnings)
498         Out.indent(6) << "-W" << Warning << "\n";
499       for (const std::string &Remark : DiagOpts->Remarks)
500         Out.indent(6) << "-R" << Remark << "\n";
501 
502       return false;
503     }
504 
505     bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
506                                  StringRef SpecificModuleCachePath,
507                                  bool Complain) override {
508       Out.indent(2) << "Header search options:\n";
509       Out.indent(4) << "System root [-isysroot=]: '" << HSOpts.Sysroot << "'\n";
510       Out.indent(4) << "Resource dir [ -resource-dir=]: '" << HSOpts.ResourceDir << "'\n";
511       Out.indent(4) << "Module Cache: '" << SpecificModuleCachePath << "'\n";
512       DUMP_BOOLEAN(HSOpts.UseBuiltinIncludes,
513                    "Use builtin include directories [-nobuiltininc]");
514       DUMP_BOOLEAN(HSOpts.UseStandardSystemIncludes,
515                    "Use standard system include directories [-nostdinc]");
516       DUMP_BOOLEAN(HSOpts.UseStandardCXXIncludes,
517                    "Use standard C++ include directories [-nostdinc++]");
518       DUMP_BOOLEAN(HSOpts.UseLibcxx,
519                    "Use libc++ (rather than libstdc++) [-stdlib=]");
520       return false;
521     }
522 
523     bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
524                                  bool Complain,
525                                  std::string &SuggestedPredefines) override {
526       Out.indent(2) << "Preprocessor options:\n";
527       DUMP_BOOLEAN(PPOpts.UsePredefines,
528                    "Uses compiler/target-specific predefines [-undef]");
529       DUMP_BOOLEAN(PPOpts.DetailedRecord,
530                    "Uses detailed preprocessing record (for indexing)");
531 
532       if (!PPOpts.Macros.empty()) {
533         Out.indent(4) << "Predefined macros:\n";
534       }
535 
536       for (std::vector<std::pair<std::string, bool/*isUndef*/> >::const_iterator
537              I = PPOpts.Macros.begin(), IEnd = PPOpts.Macros.end();
538            I != IEnd; ++I) {
539         Out.indent(6);
540         if (I->second)
541           Out << "-U";
542         else
543           Out << "-D";
544         Out << I->first << "\n";
545       }
546       return false;
547     }
548 
549     /// Indicates that a particular module file extension has been read.
550     void readModuleFileExtension(
551            const ModuleFileExtensionMetadata &Metadata) override {
552       Out.indent(2) << "Module file extension '"
553                     << Metadata.BlockName << "' " << Metadata.MajorVersion
554                     << "." << Metadata.MinorVersion;
555       if (!Metadata.UserInfo.empty()) {
556         Out << ": ";
557         Out.write_escaped(Metadata.UserInfo);
558       }
559 
560       Out << "\n";
561     }
562 #undef DUMP_BOOLEAN
563   };
564 }
565 
566 bool DumpModuleInfoAction::BeginInvocation(CompilerInstance &CI) {
567   // The Object file reader also supports raw ast files and there is no point in
568   // being strict about the module file format in -module-file-info mode.
569   CI.getHeaderSearchOpts().ModuleFormat = "obj";
570   return true;
571 }
572 
573 void DumpModuleInfoAction::ExecuteAction() {
574   // Set up the output file.
575   std::unique_ptr<llvm::raw_fd_ostream> OutFile;
576   StringRef OutputFileName = getCompilerInstance().getFrontendOpts().OutputFile;
577   if (!OutputFileName.empty() && OutputFileName != "-") {
578     std::error_code EC;
579     OutFile.reset(new llvm::raw_fd_ostream(OutputFileName.str(), EC,
580                                            llvm::sys::fs::F_Text));
581   }
582   llvm::raw_ostream &Out = OutFile.get()? *OutFile.get() : llvm::outs();
583 
584   Out << "Information for module file '" << getCurrentFile() << "':\n";
585   auto &FileMgr = getCompilerInstance().getFileManager();
586   auto Buffer = FileMgr.getBufferForFile(getCurrentFile());
587   StringRef Magic = (*Buffer)->getMemBufferRef().getBuffer();
588   bool IsRaw = (Magic.size() >= 4 && Magic[0] == 'C' && Magic[1] == 'P' &&
589                 Magic[2] == 'C' && Magic[3] == 'H');
590   Out << "  Module format: " << (IsRaw ? "raw" : "obj") << "\n";
591 
592   Preprocessor &PP = getCompilerInstance().getPreprocessor();
593   DumpModuleInfoListener Listener(Out);
594   HeaderSearchOptions &HSOpts =
595       PP.getHeaderSearchInfo().getHeaderSearchOpts();
596   ASTReader::readASTFileControlBlock(
597       getCurrentFile(), FileMgr, getCompilerInstance().getPCHContainerReader(),
598       /*FindModuleFileExtensions=*/true, Listener,
599       HSOpts.ModulesValidateDiagnosticOptions);
600 }
601 
602 //===----------------------------------------------------------------------===//
603 // Preprocessor Actions
604 //===----------------------------------------------------------------------===//
605 
606 void DumpRawTokensAction::ExecuteAction() {
607   Preprocessor &PP = getCompilerInstance().getPreprocessor();
608   SourceManager &SM = PP.getSourceManager();
609 
610   // Start lexing the specified input file.
611   const llvm::MemoryBuffer *FromFile = SM.getBuffer(SM.getMainFileID());
612   Lexer RawLex(SM.getMainFileID(), FromFile, SM, PP.getLangOpts());
613   RawLex.SetKeepWhitespaceMode(true);
614 
615   Token RawTok;
616   RawLex.LexFromRawLexer(RawTok);
617   while (RawTok.isNot(tok::eof)) {
618     PP.DumpToken(RawTok, true);
619     llvm::errs() << "\n";
620     RawLex.LexFromRawLexer(RawTok);
621   }
622 }
623 
624 void DumpTokensAction::ExecuteAction() {
625   Preprocessor &PP = getCompilerInstance().getPreprocessor();
626   // Start preprocessing the specified input file.
627   Token Tok;
628   PP.EnterMainSourceFile();
629   do {
630     PP.Lex(Tok);
631     PP.DumpToken(Tok, true);
632     llvm::errs() << "\n";
633   } while (Tok.isNot(tok::eof));
634 }
635 
636 void GeneratePTHAction::ExecuteAction() {
637   CompilerInstance &CI = getCompilerInstance();
638   std::unique_ptr<raw_pwrite_stream> OS =
639       CI.createDefaultOutputFile(true, getCurrentFile());
640   if (!OS)
641     return;
642 
643   CacheTokens(CI.getPreprocessor(), OS.get());
644 }
645 
646 void PreprocessOnlyAction::ExecuteAction() {
647   Preprocessor &PP = getCompilerInstance().getPreprocessor();
648 
649   // Ignore unknown pragmas.
650   PP.IgnorePragmas();
651 
652   Token Tok;
653   // Start parsing the specified input file.
654   PP.EnterMainSourceFile();
655   do {
656     PP.Lex(Tok);
657   } while (Tok.isNot(tok::eof));
658 }
659 
660 void PrintPreprocessedAction::ExecuteAction() {
661   CompilerInstance &CI = getCompilerInstance();
662   // Output file may need to be set to 'Binary', to avoid converting Unix style
663   // line feeds (<LF>) to Microsoft style line feeds (<CR><LF>).
664   //
665   // Look to see what type of line endings the file uses. If there's a
666   // CRLF, then we won't open the file up in binary mode. If there is
667   // just an LF or CR, then we will open the file up in binary mode.
668   // In this fashion, the output format should match the input format, unless
669   // the input format has inconsistent line endings.
670   //
671   // This should be a relatively fast operation since most files won't have
672   // all of their source code on a single line. However, that is still a
673   // concern, so if we scan for too long, we'll just assume the file should
674   // be opened in binary mode.
675   bool BinaryMode = true;
676   bool InvalidFile = false;
677   const SourceManager& SM = CI.getSourceManager();
678   const llvm::MemoryBuffer *Buffer = SM.getBuffer(SM.getMainFileID(),
679                                                      &InvalidFile);
680   if (!InvalidFile) {
681     const char *cur = Buffer->getBufferStart();
682     const char *end = Buffer->getBufferEnd();
683     const char *next = (cur != end) ? cur + 1 : end;
684 
685     // Limit ourselves to only scanning 256 characters into the source
686     // file.  This is mostly a sanity check in case the file has no
687     // newlines whatsoever.
688     if (end - cur > 256) end = cur + 256;
689 
690     while (next < end) {
691       if (*cur == 0x0D) {  // CR
692         if (*next == 0x0A)  // CRLF
693           BinaryMode = false;
694 
695         break;
696       } else if (*cur == 0x0A)  // LF
697         break;
698 
699       ++cur;
700       ++next;
701     }
702   }
703 
704   std::unique_ptr<raw_ostream> OS =
705       CI.createDefaultOutputFile(BinaryMode, getCurrentFile());
706   if (!OS) return;
707 
708   // If we're preprocessing a module map, start by dumping the contents of the
709   // module itself before switching to the input buffer.
710   auto &Input = getCurrentInput();
711   if (Input.getKind().getFormat() == InputKind::ModuleMap) {
712     if (Input.isFile()) {
713       (*OS) << "# 1 \"";
714       OS->write_escaped(Input.getFile());
715       (*OS) << "\"\n";
716     }
717     // FIXME: Include additional information here so that we don't need the
718     // original source files to exist on disk.
719     getCurrentModule()->print(*OS);
720     (*OS) << "#pragma clang module contents\n";
721   }
722 
723   DoPrintPreprocessedInput(CI.getPreprocessor(), OS.get(),
724                            CI.getPreprocessorOutputOpts());
725 }
726 
727 void PrintPreambleAction::ExecuteAction() {
728   switch (getCurrentFileKind().getLanguage()) {
729   case InputKind::C:
730   case InputKind::CXX:
731   case InputKind::ObjC:
732   case InputKind::ObjCXX:
733   case InputKind::OpenCL:
734   case InputKind::CUDA:
735     break;
736 
737   case InputKind::Unknown:
738   case InputKind::Asm:
739   case InputKind::LLVM_IR:
740   case InputKind::RenderScript:
741     // We can't do anything with these.
742     return;
743   }
744 
745   // We don't expect to find any #include directives in a preprocessed input.
746   if (getCurrentFileKind().isPreprocessed())
747     return;
748 
749   CompilerInstance &CI = getCompilerInstance();
750   auto Buffer = CI.getFileManager().getBufferForFile(getCurrentFile());
751   if (Buffer) {
752     unsigned Preamble =
753         Lexer::ComputePreamble((*Buffer)->getBuffer(), CI.getLangOpts()).Size;
754     llvm::outs().write((*Buffer)->getBufferStart(), Preamble);
755   }
756 }
757