1//===--- FrontendActions.cpp ----------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "clang/Frontend/FrontendActions.h"
10#include "clang/AST/ASTConsumer.h"
11#include "clang/AST/Decl.h"
12#include "clang/Basic/FileManager.h"
13#include "clang/Basic/LangStandard.h"
14#include "clang/Basic/Module.h"
15#include "clang/Basic/TargetInfo.h"
16#include "clang/Frontend/ASTConsumers.h"
17#include "clang/Frontend/CompilerInstance.h"
18#include "clang/Frontend/FrontendDiagnostic.h"
19#include "clang/Frontend/MultiplexConsumer.h"
20#include "clang/Frontend/Utils.h"
21#include "clang/Lex/DependencyDirectivesScanner.h"
22#include "clang/Lex/HeaderSearch.h"
23#include "clang/Lex/Preprocessor.h"
24#include "clang/Lex/PreprocessorOptions.h"
25#include "clang/Sema/TemplateInstCallback.h"
26#include "clang/Serialization/ASTReader.h"
27#include "clang/Serialization/ASTWriter.h"
28#include "clang/Serialization/ModuleFile.h"
29#include "llvm/Support/ErrorHandling.h"
30#include "llvm/Support/FileSystem.h"
31#include "llvm/Support/MemoryBuffer.h"
32#include "llvm/Support/Path.h"
33#include "llvm/Support/YAMLTraits.h"
34#include "llvm/Support/raw_ostream.h"
35#include <memory>
36#include <optional>
37#include <system_error>
38
39using namespace clang;
40
41namespace {
42CodeCompleteConsumer *GetCodeCompletionConsumer(CompilerInstance &CI) {
43 return CI.hasCodeCompletionConsumer() ? &CI.getCodeCompletionConsumer()
44 : nullptr;
45}
46
47void EnsureSemaIsCreated(CompilerInstance &CI, FrontendAction &Action) {
48 if (Action.hasCodeCompletionSupport() &&
49 !CI.getFrontendOpts().CodeCompletionAt.FileName.empty())
50 CI.createCodeCompletionConsumer();
51
52 if (!CI.hasSema())
53 CI.createSema(TUKind: Action.getTranslationUnitKind(),
54 CompletionConsumer: GetCodeCompletionConsumer(CI));
55}
56} // namespace
57
58//===----------------------------------------------------------------------===//
59// Custom Actions
60//===----------------------------------------------------------------------===//
61
62std::unique_ptr<ASTConsumer>
63InitOnlyAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
64 return std::make_unique<ASTConsumer>();
65}
66
67void InitOnlyAction::ExecuteAction() {
68}
69
70// Basically PreprocessOnlyAction::ExecuteAction.
71void ReadPCHAndPreprocessAction::ExecuteAction() {
72 Preprocessor &PP = getCompilerInstance().getPreprocessor();
73
74 // Ignore unknown pragmas.
75 PP.IgnorePragmas();
76
77 Token Tok;
78 // Start parsing the specified input file.
79 PP.EnterMainSourceFile();
80 do {
81 PP.Lex(Result&: Tok);
82 } while (Tok.isNot(K: tok::eof));
83}
84
85std::unique_ptr<ASTConsumer>
86ReadPCHAndPreprocessAction::CreateASTConsumer(CompilerInstance &CI,
87 StringRef InFile) {
88 return std::make_unique<ASTConsumer>();
89}
90
91//===----------------------------------------------------------------------===//
92// AST Consumer Actions
93//===----------------------------------------------------------------------===//
94
95std::unique_ptr<ASTConsumer>
96ASTPrintAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
97 if (std::unique_ptr<raw_ostream> OS =
98 CI.createDefaultOutputFile(Binary: false, BaseInput: InFile))
99 return CreateASTPrinter(OS: std::move(OS), FilterString: CI.getFrontendOpts().ASTDumpFilter);
100 return nullptr;
101}
102
103std::unique_ptr<ASTConsumer>
104ASTDumpAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
105 const FrontendOptions &Opts = CI.getFrontendOpts();
106 return CreateASTDumper(OS: nullptr /*Dump to stdout.*/, FilterString: Opts.ASTDumpFilter,
107 DumpDecls: Opts.ASTDumpDecls, Deserialize: Opts.ASTDumpAll,
108 DumpLookups: Opts.ASTDumpLookups, DumpDeclTypes: Opts.ASTDumpDeclTypes,
109 Format: Opts.ASTDumpFormat);
110}
111
112std::unique_ptr<ASTConsumer>
113ASTDeclListAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
114 return CreateASTDeclNodeLister();
115}
116
117std::unique_ptr<ASTConsumer>
118ASTViewAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
119 return CreateASTViewer();
120}
121
122std::unique_ptr<ASTConsumer>
123GeneratePCHAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
124 std::string Sysroot;
125 if (!ComputeASTConsumerArguments(CI, /*ref*/ Sysroot))
126 return nullptr;
127
128 std::string OutputFile;
129 std::unique_ptr<raw_pwrite_stream> OS =
130 CreateOutputFile(CI, InFile, /*ref*/ OutputFile);
131 if (!OS)
132 return nullptr;
133
134 if (!CI.getFrontendOpts().RelocatablePCH)
135 Sysroot.clear();
136
137 const auto &FrontendOpts = CI.getFrontendOpts();
138 auto Buffer = std::make_shared<PCHBuffer>();
139 std::vector<std::unique_ptr<ASTConsumer>> Consumers;
140 Consumers.push_back(x: std::make_unique<PCHGenerator>(
141 args&: CI.getPreprocessor(), args&: CI.getModuleCache(), args&: OutputFile, args&: Sysroot, args&: Buffer,
142 args: FrontendOpts.ModuleFileExtensions,
143 args&: CI.getPreprocessorOpts().AllowPCHWithCompilerErrors,
144 args: FrontendOpts.IncludeTimestamps, args: FrontendOpts.BuildingImplicitModule,
145 args: +CI.getLangOpts().CacheGeneratedPCH));
146 Consumers.push_back(x: CI.getPCHContainerWriter().CreatePCHContainerGenerator(
147 CI, MainFileName: std::string(InFile), OutputFileName: OutputFile, OS: std::move(OS), Buffer));
148
149 return std::make_unique<MultiplexConsumer>(args: std::move(Consumers));
150}
151
152bool GeneratePCHAction::ComputeASTConsumerArguments(CompilerInstance &CI,
153 std::string &Sysroot) {
154 Sysroot = CI.getHeaderSearchOpts().Sysroot;
155 if (CI.getFrontendOpts().RelocatablePCH && Sysroot.empty()) {
156 CI.getDiagnostics().Report(diag::err_relocatable_without_isysroot);
157 return false;
158 }
159
160 return true;
161}
162
163std::unique_ptr<llvm::raw_pwrite_stream>
164GeneratePCHAction::CreateOutputFile(CompilerInstance &CI, StringRef InFile,
165 std::string &OutputFile) {
166 // Because this is exposed via libclang we must disable RemoveFileOnSignal.
167 std::unique_ptr<raw_pwrite_stream> OS = CI.createDefaultOutputFile(
168 /*Binary=*/true, BaseInput: InFile, /*Extension=*/"", /*RemoveFileOnSignal=*/false);
169 if (!OS)
170 return nullptr;
171
172 OutputFile = CI.getFrontendOpts().OutputFile;
173 return OS;
174}
175
176bool GeneratePCHAction::shouldEraseOutputFiles() {
177 if (getCompilerInstance().getPreprocessorOpts().AllowPCHWithCompilerErrors)
178 return false;
179 return ASTFrontendAction::shouldEraseOutputFiles();
180}
181
182bool GeneratePCHAction::BeginSourceFileAction(CompilerInstance &CI) {
183 CI.getLangOpts().CompilingPCH = true;
184 return true;
185}
186
187std::vector<std::unique_ptr<ASTConsumer>>
188GenerateModuleAction::CreateMultiplexConsumer(CompilerInstance &CI,
189 StringRef InFile) {
190 std::unique_ptr<raw_pwrite_stream> OS = CreateOutputFile(CI, InFile);
191 if (!OS)
192 return {};
193
194 std::string OutputFile = CI.getFrontendOpts().OutputFile;
195 std::string Sysroot;
196
197 auto Buffer = std::make_shared<PCHBuffer>();
198 std::vector<std::unique_ptr<ASTConsumer>> Consumers;
199
200 Consumers.push_back(x: std::make_unique<PCHGenerator>(
201 args&: CI.getPreprocessor(), args&: CI.getModuleCache(), args&: OutputFile, args&: Sysroot, args&: Buffer,
202 args&: CI.getFrontendOpts().ModuleFileExtensions,
203 /*AllowASTWithErrors=*/
204 args: +CI.getFrontendOpts().AllowPCMWithCompilerErrors,
205 /*IncludeTimestamps=*/
206 args: +CI.getFrontendOpts().BuildingImplicitModule &&
207 +CI.getFrontendOpts().IncludeTimestamps,
208 /*BuildingImplicitModule=*/args: +CI.getFrontendOpts().BuildingImplicitModule,
209 /*ShouldCacheASTInMemory=*/
210 args: +CI.getFrontendOpts().BuildingImplicitModule));
211 Consumers.push_back(x: CI.getPCHContainerWriter().CreatePCHContainerGenerator(
212 CI, MainFileName: std::string(InFile), OutputFileName: OutputFile, OS: std::move(OS), Buffer));
213 return Consumers;
214}
215
216std::unique_ptr<ASTConsumer>
217GenerateModuleAction::CreateASTConsumer(CompilerInstance &CI,
218 StringRef InFile) {
219 std::vector<std::unique_ptr<ASTConsumer>> Consumers =
220 CreateMultiplexConsumer(CI, InFile);
221 if (Consumers.empty())
222 return nullptr;
223
224 return std::make_unique<MultiplexConsumer>(args: std::move(Consumers));
225}
226
227bool GenerateModuleAction::shouldEraseOutputFiles() {
228 return !getCompilerInstance().getFrontendOpts().AllowPCMWithCompilerErrors &&
229 ASTFrontendAction::shouldEraseOutputFiles();
230}
231
232bool GenerateModuleFromModuleMapAction::BeginSourceFileAction(
233 CompilerInstance &CI) {
234 if (!CI.getLangOpts().Modules) {
235 CI.getDiagnostics().Report(diag::err_module_build_requires_fmodules);
236 return false;
237 }
238
239 return GenerateModuleAction::BeginSourceFileAction(CI);
240}
241
242std::unique_ptr<raw_pwrite_stream>
243GenerateModuleFromModuleMapAction::CreateOutputFile(CompilerInstance &CI,
244 StringRef InFile) {
245 // If no output file was provided, figure out where this module would go
246 // in the module cache.
247 if (CI.getFrontendOpts().OutputFile.empty()) {
248 StringRef ModuleMapFile = CI.getFrontendOpts().OriginalModuleMap;
249 if (ModuleMapFile.empty())
250 ModuleMapFile = InFile;
251
252 HeaderSearch &HS = CI.getPreprocessor().getHeaderSearchInfo();
253 CI.getFrontendOpts().OutputFile =
254 HS.getCachedModuleFileName(ModuleName: CI.getLangOpts().CurrentModule,
255 ModuleMapPath: ModuleMapFile);
256 }
257
258 // Because this is exposed via libclang we must disable RemoveFileOnSignal.
259 return CI.createDefaultOutputFile(/*Binary=*/true, BaseInput: InFile, /*Extension=*/"",
260 /*RemoveFileOnSignal=*/false,
261 /*CreateMissingDirectories=*/true,
262 /*ForceUseTemporary=*/true);
263}
264
265bool GenerateModuleInterfaceAction::BeginSourceFileAction(
266 CompilerInstance &CI) {
267 CI.getLangOpts().setCompilingModule(LangOptions::CMK_ModuleInterface);
268
269 return GenerateModuleAction::BeginSourceFileAction(CI);
270}
271
272std::unique_ptr<ASTConsumer>
273GenerateModuleInterfaceAction::CreateASTConsumer(CompilerInstance &CI,
274 StringRef InFile) {
275 CI.getHeaderSearchOpts().ModulesSkipDiagnosticOptions = true;
276 CI.getHeaderSearchOpts().ModulesSkipHeaderSearchPaths = true;
277 CI.getHeaderSearchOpts().ModulesSkipPragmaDiagnosticMappings = true;
278
279 std::vector<std::unique_ptr<ASTConsumer>> Consumers =
280 CreateMultiplexConsumer(CI, InFile);
281 if (Consumers.empty())
282 return nullptr;
283
284 if (CI.getFrontendOpts().GenReducedBMI &&
285 !CI.getFrontendOpts().ModuleOutputPath.empty()) {
286 Consumers.push_back(x: std::make_unique<ReducedBMIGenerator>(
287 args&: CI.getPreprocessor(), args&: CI.getModuleCache(),
288 args&: CI.getFrontendOpts().ModuleOutputPath));
289 }
290
291 return std::make_unique<MultiplexConsumer>(args: std::move(Consumers));
292}
293
294std::unique_ptr<raw_pwrite_stream>
295GenerateModuleInterfaceAction::CreateOutputFile(CompilerInstance &CI,
296 StringRef InFile) {
297 return CI.createDefaultOutputFile(/*Binary=*/true, BaseInput: InFile, Extension: "pcm");
298}
299
300std::unique_ptr<ASTConsumer>
301GenerateReducedModuleInterfaceAction::CreateASTConsumer(CompilerInstance &CI,
302 StringRef InFile) {
303 return std::make_unique<ReducedBMIGenerator>(args&: CI.getPreprocessor(),
304 args&: CI.getModuleCache(),
305 args&: CI.getFrontendOpts().OutputFile);
306}
307
308bool GenerateHeaderUnitAction::BeginSourceFileAction(CompilerInstance &CI) {
309 if (!CI.getLangOpts().CPlusPlusModules) {
310 CI.getDiagnostics().Report(diag::err_module_interface_requires_cpp_modules);
311 return false;
312 }
313 CI.getLangOpts().setCompilingModule(LangOptions::CMK_HeaderUnit);
314 return GenerateModuleAction::BeginSourceFileAction(CI);
315}
316
317std::unique_ptr<raw_pwrite_stream>
318GenerateHeaderUnitAction::CreateOutputFile(CompilerInstance &CI,
319 StringRef InFile) {
320 return CI.createDefaultOutputFile(/*Binary=*/true, BaseInput: InFile, Extension: "pcm");
321}
322
323SyntaxOnlyAction::~SyntaxOnlyAction() {
324}
325
326std::unique_ptr<ASTConsumer>
327SyntaxOnlyAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
328 return std::make_unique<ASTConsumer>();
329}
330
331std::unique_ptr<ASTConsumer>
332DumpModuleInfoAction::CreateASTConsumer(CompilerInstance &CI,
333 StringRef InFile) {
334 return std::make_unique<ASTConsumer>();
335}
336
337std::unique_ptr<ASTConsumer>
338VerifyPCHAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
339 return std::make_unique<ASTConsumer>();
340}
341
342void VerifyPCHAction::ExecuteAction() {
343 CompilerInstance &CI = getCompilerInstance();
344 bool Preamble = CI.getPreprocessorOpts().PrecompiledPreambleBytes.first != 0;
345 const std::string &Sysroot = CI.getHeaderSearchOpts().Sysroot;
346 std::unique_ptr<ASTReader> Reader(new ASTReader(
347 CI.getPreprocessor(), CI.getModuleCache(), &CI.getASTContext(),
348 CI.getPCHContainerReader(), CI.getFrontendOpts().ModuleFileExtensions,
349 Sysroot.empty() ? "" : Sysroot.c_str(),
350 DisableValidationForModuleKind::None,
351 /*AllowASTWithCompilerErrors*/ false,
352 /*AllowConfigurationMismatch*/ true,
353 /*ValidateSystemInputs*/ true));
354
355 Reader->ReadAST(FileName: getCurrentFile(),
356 Type: Preamble ? serialization::MK_Preamble
357 : serialization::MK_PCH,
358 ImportLoc: SourceLocation(),
359 ClientLoadCapabilities: ASTReader::ARR_ConfigurationMismatch);
360}
361
362namespace {
363struct TemplightEntry {
364 std::string Name;
365 std::string Kind;
366 std::string Event;
367 std::string DefinitionLocation;
368 std::string PointOfInstantiation;
369};
370} // namespace
371
372namespace llvm {
373namespace yaml {
374template <> struct MappingTraits<TemplightEntry> {
375 static void mapping(IO &io, TemplightEntry &fields) {
376 io.mapRequired(Key: "name", Val&: fields.Name);
377 io.mapRequired(Key: "kind", Val&: fields.Kind);
378 io.mapRequired(Key: "event", Val&: fields.Event);
379 io.mapRequired(Key: "orig", Val&: fields.DefinitionLocation);
380 io.mapRequired(Key: "poi", Val&: fields.PointOfInstantiation);
381 }
382};
383} // namespace yaml
384} // namespace llvm
385
386namespace {
387class DefaultTemplateInstCallback : public TemplateInstantiationCallback {
388 using CodeSynthesisContext = Sema::CodeSynthesisContext;
389
390public:
391 void initialize(const Sema &) override {}
392
393 void finalize(const Sema &) override {}
394
395 void atTemplateBegin(const Sema &TheSema,
396 const CodeSynthesisContext &Inst) override {
397 displayTemplightEntry<true>(Out&: llvm::outs(), TheSema, Inst);
398 }
399
400 void atTemplateEnd(const Sema &TheSema,
401 const CodeSynthesisContext &Inst) override {
402 displayTemplightEntry<false>(Out&: llvm::outs(), TheSema, Inst);
403 }
404
405private:
406 static std::string toString(CodeSynthesisContext::SynthesisKind Kind) {
407 switch (Kind) {
408 case CodeSynthesisContext::TemplateInstantiation:
409 return "TemplateInstantiation";
410 case CodeSynthesisContext::DefaultTemplateArgumentInstantiation:
411 return "DefaultTemplateArgumentInstantiation";
412 case CodeSynthesisContext::DefaultFunctionArgumentInstantiation:
413 return "DefaultFunctionArgumentInstantiation";
414 case CodeSynthesisContext::ExplicitTemplateArgumentSubstitution:
415 return "ExplicitTemplateArgumentSubstitution";
416 case CodeSynthesisContext::DeducedTemplateArgumentSubstitution:
417 return "DeducedTemplateArgumentSubstitution";
418 case CodeSynthesisContext::LambdaExpressionSubstitution:
419 return "LambdaExpressionSubstitution";
420 case CodeSynthesisContext::PriorTemplateArgumentSubstitution:
421 return "PriorTemplateArgumentSubstitution";
422 case CodeSynthesisContext::DefaultTemplateArgumentChecking:
423 return "DefaultTemplateArgumentChecking";
424 case CodeSynthesisContext::ExceptionSpecEvaluation:
425 return "ExceptionSpecEvaluation";
426 case CodeSynthesisContext::ExceptionSpecInstantiation:
427 return "ExceptionSpecInstantiation";
428 case CodeSynthesisContext::DeclaringSpecialMember:
429 return "DeclaringSpecialMember";
430 case CodeSynthesisContext::DeclaringImplicitEqualityComparison:
431 return "DeclaringImplicitEqualityComparison";
432 case CodeSynthesisContext::DefiningSynthesizedFunction:
433 return "DefiningSynthesizedFunction";
434 case CodeSynthesisContext::RewritingOperatorAsSpaceship:
435 return "RewritingOperatorAsSpaceship";
436 case CodeSynthesisContext::Memoization:
437 return "Memoization";
438 case CodeSynthesisContext::ConstraintsCheck:
439 return "ConstraintsCheck";
440 case CodeSynthesisContext::ConstraintSubstitution:
441 return "ConstraintSubstitution";
442 case CodeSynthesisContext::ConstraintNormalization:
443 return "ConstraintNormalization";
444 case CodeSynthesisContext::RequirementParameterInstantiation:
445 return "RequirementParameterInstantiation";
446 case CodeSynthesisContext::ParameterMappingSubstitution:
447 return "ParameterMappingSubstitution";
448 case CodeSynthesisContext::RequirementInstantiation:
449 return "RequirementInstantiation";
450 case CodeSynthesisContext::NestedRequirementConstraintsCheck:
451 return "NestedRequirementConstraintsCheck";
452 case CodeSynthesisContext::InitializingStructuredBinding:
453 return "InitializingStructuredBinding";
454 case CodeSynthesisContext::MarkingClassDllexported:
455 return "MarkingClassDllexported";
456 case CodeSynthesisContext::BuildingBuiltinDumpStructCall:
457 return "BuildingBuiltinDumpStructCall";
458 case CodeSynthesisContext::BuildingDeductionGuides:
459 return "BuildingDeductionGuides";
460 case CodeSynthesisContext::TypeAliasTemplateInstantiation:
461 return "TypeAliasTemplateInstantiation";
462 }
463 return "";
464 }
465
466 template <bool BeginInstantiation>
467 static void displayTemplightEntry(llvm::raw_ostream &Out, const Sema &TheSema,
468 const CodeSynthesisContext &Inst) {
469 std::string YAML;
470 {
471 llvm::raw_string_ostream OS(YAML);
472 llvm::yaml::Output YO(OS);
473 TemplightEntry Entry =
474 getTemplightEntry<BeginInstantiation>(TheSema, Inst);
475 llvm::yaml::EmptyContext Context;
476 llvm::yaml::yamlize(io&: YO, Val&: Entry, true, Ctx&: Context);
477 }
478 Out << "---" << YAML << "\n";
479 }
480
481 static void printEntryName(const Sema &TheSema, const Decl *Entity,
482 llvm::raw_string_ostream &OS) {
483 auto *NamedTemplate = cast<NamedDecl>(Val: Entity);
484
485 PrintingPolicy Policy = TheSema.Context.getPrintingPolicy();
486 // FIXME: Also ask for FullyQualifiedNames?
487 Policy.SuppressDefaultTemplateArgs = false;
488 NamedTemplate->getNameForDiagnostic(OS, Policy, Qualified: true);
489
490 if (!OS.str().empty())
491 return;
492
493 Decl *Ctx = Decl::castFromDeclContext(NamedTemplate->getDeclContext());
494 NamedDecl *NamedCtx = dyn_cast_or_null<NamedDecl>(Val: Ctx);
495
496 if (const auto *Decl = dyn_cast<TagDecl>(Val: NamedTemplate)) {
497 if (const auto *R = dyn_cast<RecordDecl>(Val: Decl)) {
498 if (R->isLambda()) {
499 OS << "lambda at ";
500 Decl->getLocation().print(OS, TheSema.getSourceManager());
501 return;
502 }
503 }
504 OS << "unnamed " << Decl->getKindName();
505 return;
506 }
507
508 assert(NamedCtx && "NamedCtx cannot be null");
509
510 if (const auto *Decl = dyn_cast<ParmVarDecl>(Val: NamedTemplate)) {
511 OS << "unnamed function parameter " << Decl->getFunctionScopeIndex()
512 << " ";
513 if (Decl->getFunctionScopeDepth() > 0)
514 OS << "(at depth " << Decl->getFunctionScopeDepth() << ") ";
515 OS << "of ";
516 NamedCtx->getNameForDiagnostic(OS, Policy: TheSema.getLangOpts(), Qualified: true);
517 return;
518 }
519
520 if (const auto *Decl = dyn_cast<TemplateTypeParmDecl>(Val: NamedTemplate)) {
521 if (const Type *Ty = Decl->getTypeForDecl()) {
522 if (const auto *TTPT = dyn_cast_or_null<TemplateTypeParmType>(Ty)) {
523 OS << "unnamed template type parameter " << TTPT->getIndex() << " ";
524 if (TTPT->getDepth() > 0)
525 OS << "(at depth " << TTPT->getDepth() << ") ";
526 OS << "of ";
527 NamedCtx->getNameForDiagnostic(OS, Policy: TheSema.getLangOpts(), Qualified: true);
528 return;
529 }
530 }
531 }
532
533 if (const auto *Decl = dyn_cast<NonTypeTemplateParmDecl>(Val: NamedTemplate)) {
534 OS << "unnamed template non-type parameter " << Decl->getIndex() << " ";
535 if (Decl->getDepth() > 0)
536 OS << "(at depth " << Decl->getDepth() << ") ";
537 OS << "of ";
538 NamedCtx->getNameForDiagnostic(OS, Policy: TheSema.getLangOpts(), Qualified: true);
539 return;
540 }
541
542 if (const auto *Decl = dyn_cast<TemplateTemplateParmDecl>(Val: NamedTemplate)) {
543 OS << "unnamed template template parameter " << Decl->getIndex() << " ";
544 if (Decl->getDepth() > 0)
545 OS << "(at depth " << Decl->getDepth() << ") ";
546 OS << "of ";
547 NamedCtx->getNameForDiagnostic(OS, Policy: TheSema.getLangOpts(), Qualified: true);
548 return;
549 }
550
551 llvm_unreachable("Failed to retrieve a name for this entry!");
552 OS << "unnamed identifier";
553 }
554
555 template <bool BeginInstantiation>
556 static TemplightEntry getTemplightEntry(const Sema &TheSema,
557 const CodeSynthesisContext &Inst) {
558 TemplightEntry Entry;
559 Entry.Kind = toString(Kind: Inst.Kind);
560 Entry.Event = BeginInstantiation ? "Begin" : "End";
561 llvm::raw_string_ostream OS(Entry.Name);
562 printEntryName(TheSema, Entity: Inst.Entity, OS);
563 const PresumedLoc DefLoc =
564 TheSema.getSourceManager().getPresumedLoc(Loc: Inst.Entity->getLocation());
565 if (!DefLoc.isInvalid())
566 Entry.DefinitionLocation = std::string(DefLoc.getFilename()) + ":" +
567 std::to_string(val: DefLoc.getLine()) + ":" +
568 std::to_string(val: DefLoc.getColumn());
569 const PresumedLoc PoiLoc =
570 TheSema.getSourceManager().getPresumedLoc(Loc: Inst.PointOfInstantiation);
571 if (!PoiLoc.isInvalid()) {
572 Entry.PointOfInstantiation = std::string(PoiLoc.getFilename()) + ":" +
573 std::to_string(val: PoiLoc.getLine()) + ":" +
574 std::to_string(val: PoiLoc.getColumn());
575 }
576 return Entry;
577 }
578};
579} // namespace
580
581std::unique_ptr<ASTConsumer>
582TemplightDumpAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
583 return std::make_unique<ASTConsumer>();
584}
585
586void TemplightDumpAction::ExecuteAction() {
587 CompilerInstance &CI = getCompilerInstance();
588
589 // This part is normally done by ASTFrontEndAction, but needs to happen
590 // before Templight observers can be created
591 // FIXME: Move the truncation aspect of this into Sema, we delayed this till
592 // here so the source manager would be initialized.
593 EnsureSemaIsCreated(CI, Action&: *this);
594
595 CI.getSema().TemplateInstCallbacks.push_back(
596 x: std::make_unique<DefaultTemplateInstCallback>());
597 ASTFrontendAction::ExecuteAction();
598}
599
600namespace {
601 /// AST reader listener that dumps module information for a module
602 /// file.
603 class DumpModuleInfoListener : public ASTReaderListener {
604 llvm::raw_ostream &Out;
605
606 public:
607 DumpModuleInfoListener(llvm::raw_ostream &Out) : Out(Out) { }
608
609#define DUMP_BOOLEAN(Value, Text) \
610 Out.indent(4) << Text << ": " << (Value? "Yes" : "No") << "\n"
611
612 bool ReadFullVersionInformation(StringRef FullVersion) override {
613 Out.indent(NumSpaces: 2)
614 << "Generated by "
615 << (FullVersion == getClangFullRepositoryVersion()? "this"
616 : "a different")
617 << " Clang: " << FullVersion << "\n";
618 return ASTReaderListener::ReadFullVersionInformation(FullVersion);
619 }
620
621 void ReadModuleName(StringRef ModuleName) override {
622 Out.indent(NumSpaces: 2) << "Module name: " << ModuleName << "\n";
623 }
624 void ReadModuleMapFile(StringRef ModuleMapPath) override {
625 Out.indent(NumSpaces: 2) << "Module map file: " << ModuleMapPath << "\n";
626 }
627
628 bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain,
629 bool AllowCompatibleDifferences) override {
630 Out.indent(NumSpaces: 2) << "Language options:\n";
631#define LANGOPT(Name, Bits, Default, Description) \
632 DUMP_BOOLEAN(LangOpts.Name, Description);
633#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
634 Out.indent(4) << Description << ": " \
635 << static_cast<unsigned>(LangOpts.get##Name()) << "\n";
636#define VALUE_LANGOPT(Name, Bits, Default, Description) \
637 Out.indent(4) << Description << ": " << LangOpts.Name << "\n";
638#define BENIGN_LANGOPT(Name, Bits, Default, Description)
639#define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
640#include "clang/Basic/LangOptions.def"
641
642 if (!LangOpts.ModuleFeatures.empty()) {
643 Out.indent(NumSpaces: 4) << "Module features:\n";
644 for (StringRef Feature : LangOpts.ModuleFeatures)
645 Out.indent(NumSpaces: 6) << Feature << "\n";
646 }
647
648 return false;
649 }
650
651 bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain,
652 bool AllowCompatibleDifferences) override {
653 Out.indent(NumSpaces: 2) << "Target options:\n";
654 Out.indent(NumSpaces: 4) << " Triple: " << TargetOpts.Triple << "\n";
655 Out.indent(NumSpaces: 4) << " CPU: " << TargetOpts.CPU << "\n";
656 Out.indent(NumSpaces: 4) << " TuneCPU: " << TargetOpts.TuneCPU << "\n";
657 Out.indent(NumSpaces: 4) << " ABI: " << TargetOpts.ABI << "\n";
658
659 if (!TargetOpts.FeaturesAsWritten.empty()) {
660 Out.indent(NumSpaces: 4) << "Target features:\n";
661 for (unsigned I = 0, N = TargetOpts.FeaturesAsWritten.size();
662 I != N; ++I) {
663 Out.indent(NumSpaces: 6) << TargetOpts.FeaturesAsWritten[I] << "\n";
664 }
665 }
666
667 return false;
668 }
669
670 bool ReadDiagnosticOptions(IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts,
671 bool Complain) override {
672 Out.indent(NumSpaces: 2) << "Diagnostic options:\n";
673#define DIAGOPT(Name, Bits, Default) DUMP_BOOLEAN(DiagOpts->Name, #Name);
674#define ENUM_DIAGOPT(Name, Type, Bits, Default) \
675 Out.indent(4) << #Name << ": " << DiagOpts->get##Name() << "\n";
676#define VALUE_DIAGOPT(Name, Bits, Default) \
677 Out.indent(4) << #Name << ": " << DiagOpts->Name << "\n";
678#include "clang/Basic/DiagnosticOptions.def"
679
680 Out.indent(NumSpaces: 4) << "Diagnostic flags:\n";
681 for (const std::string &Warning : DiagOpts->Warnings)
682 Out.indent(NumSpaces: 6) << "-W" << Warning << "\n";
683 for (const std::string &Remark : DiagOpts->Remarks)
684 Out.indent(NumSpaces: 6) << "-R" << Remark << "\n";
685
686 return false;
687 }
688
689 bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
690 StringRef SpecificModuleCachePath,
691 bool Complain) override {
692 Out.indent(NumSpaces: 2) << "Header search options:\n";
693 Out.indent(NumSpaces: 4) << "System root [-isysroot=]: '" << HSOpts.Sysroot << "'\n";
694 Out.indent(NumSpaces: 4) << "Resource dir [ -resource-dir=]: '" << HSOpts.ResourceDir << "'\n";
695 Out.indent(NumSpaces: 4) << "Module Cache: '" << SpecificModuleCachePath << "'\n";
696 DUMP_BOOLEAN(HSOpts.UseBuiltinIncludes,
697 "Use builtin include directories [-nobuiltininc]");
698 DUMP_BOOLEAN(HSOpts.UseStandardSystemIncludes,
699 "Use standard system include directories [-nostdinc]");
700 DUMP_BOOLEAN(HSOpts.UseStandardCXXIncludes,
701 "Use standard C++ include directories [-nostdinc++]");
702 DUMP_BOOLEAN(HSOpts.UseLibcxx,
703 "Use libc++ (rather than libstdc++) [-stdlib=]");
704 return false;
705 }
706
707 bool ReadHeaderSearchPaths(const HeaderSearchOptions &HSOpts,
708 bool Complain) override {
709 Out.indent(NumSpaces: 2) << "Header search paths:\n";
710 Out.indent(NumSpaces: 4) << "User entries:\n";
711 for (const auto &Entry : HSOpts.UserEntries)
712 Out.indent(NumSpaces: 6) << Entry.Path << "\n";
713 Out.indent(NumSpaces: 4) << "System header prefixes:\n";
714 for (const auto &Prefix : HSOpts.SystemHeaderPrefixes)
715 Out.indent(NumSpaces: 6) << Prefix.Prefix << "\n";
716 Out.indent(NumSpaces: 4) << "VFS overlay files:\n";
717 for (const auto &Overlay : HSOpts.VFSOverlayFiles)
718 Out.indent(NumSpaces: 6) << Overlay << "\n";
719 return false;
720 }
721
722 bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
723 bool ReadMacros, bool Complain,
724 std::string &SuggestedPredefines) override {
725 Out.indent(NumSpaces: 2) << "Preprocessor options:\n";
726 DUMP_BOOLEAN(PPOpts.UsePredefines,
727 "Uses compiler/target-specific predefines [-undef]");
728 DUMP_BOOLEAN(PPOpts.DetailedRecord,
729 "Uses detailed preprocessing record (for indexing)");
730
731 if (ReadMacros) {
732 Out.indent(NumSpaces: 4) << "Predefined macros:\n";
733 }
734
735 for (std::vector<std::pair<std::string, bool/*isUndef*/> >::const_iterator
736 I = PPOpts.Macros.begin(), IEnd = PPOpts.Macros.end();
737 I != IEnd; ++I) {
738 Out.indent(NumSpaces: 6);
739 if (I->second)
740 Out << "-U";
741 else
742 Out << "-D";
743 Out << I->first << "\n";
744 }
745 return false;
746 }
747
748 /// Indicates that a particular module file extension has been read.
749 void readModuleFileExtension(
750 const ModuleFileExtensionMetadata &Metadata) override {
751 Out.indent(NumSpaces: 2) << "Module file extension '"
752 << Metadata.BlockName << "' " << Metadata.MajorVersion
753 << "." << Metadata.MinorVersion;
754 if (!Metadata.UserInfo.empty()) {
755 Out << ": ";
756 Out.write_escaped(Str: Metadata.UserInfo);
757 }
758
759 Out << "\n";
760 }
761
762 /// Tells the \c ASTReaderListener that we want to receive the
763 /// input files of the AST file via \c visitInputFile.
764 bool needsInputFileVisitation() override { return true; }
765
766 /// Tells the \c ASTReaderListener that we want to receive the
767 /// input files of the AST file via \c visitInputFile.
768 bool needsSystemInputFileVisitation() override { return true; }
769
770 /// Indicates that the AST file contains particular input file.
771 ///
772 /// \returns true to continue receiving the next input file, false to stop.
773 bool visitInputFile(StringRef Filename, bool isSystem,
774 bool isOverridden, bool isExplicitModule) override {
775
776 Out.indent(NumSpaces: 2) << "Input file: " << Filename;
777
778 if (isSystem || isOverridden || isExplicitModule) {
779 Out << " [";
780 if (isSystem) {
781 Out << "System";
782 if (isOverridden || isExplicitModule)
783 Out << ", ";
784 }
785 if (isOverridden) {
786 Out << "Overridden";
787 if (isExplicitModule)
788 Out << ", ";
789 }
790 if (isExplicitModule)
791 Out << "ExplicitModule";
792
793 Out << "]";
794 }
795
796 Out << "\n";
797
798 return true;
799 }
800
801 /// Returns true if this \c ASTReaderListener wants to receive the
802 /// imports of the AST file via \c visitImport, false otherwise.
803 bool needsImportVisitation() const override { return true; }
804
805 /// If needsImportVisitation returns \c true, this is called for each
806 /// AST file imported by this AST file.
807 void visitImport(StringRef ModuleName, StringRef Filename) override {
808 Out.indent(NumSpaces: 2) << "Imports module '" << ModuleName
809 << "': " << Filename.str() << "\n";
810 }
811#undef DUMP_BOOLEAN
812 };
813}
814
815bool DumpModuleInfoAction::BeginInvocation(CompilerInstance &CI) {
816 // The Object file reader also supports raw ast files and there is no point in
817 // being strict about the module file format in -module-file-info mode.
818 CI.getHeaderSearchOpts().ModuleFormat = "obj";
819 return true;
820}
821
822static StringRef ModuleKindName(Module::ModuleKind MK) {
823 switch (MK) {
824 case Module::ModuleMapModule:
825 return "Module Map Module";
826 case Module::ModuleInterfaceUnit:
827 return "Interface Unit";
828 case Module::ModuleImplementationUnit:
829 return "Implementation Unit";
830 case Module::ModulePartitionInterface:
831 return "Partition Interface";
832 case Module::ModulePartitionImplementation:
833 return "Partition Implementation";
834 case Module::ModuleHeaderUnit:
835 return "Header Unit";
836 case Module::ExplicitGlobalModuleFragment:
837 return "Global Module Fragment";
838 case Module::ImplicitGlobalModuleFragment:
839 return "Implicit Module Fragment";
840 case Module::PrivateModuleFragment:
841 return "Private Module Fragment";
842 }
843 llvm_unreachable("unknown module kind!");
844}
845
846void DumpModuleInfoAction::ExecuteAction() {
847 assert(isCurrentFileAST() && "dumping non-AST?");
848 // Set up the output file.
849 CompilerInstance &CI = getCompilerInstance();
850 StringRef OutputFileName = CI.getFrontendOpts().OutputFile;
851 if (!OutputFileName.empty() && OutputFileName != "-") {
852 std::error_code EC;
853 OutputStream.reset(p: new llvm::raw_fd_ostream(
854 OutputFileName.str(), EC, llvm::sys::fs::OF_TextWithCRLF));
855 }
856 llvm::raw_ostream &Out = OutputStream ? *OutputStream : llvm::outs();
857
858 Out << "Information for module file '" << getCurrentFile() << "':\n";
859 auto &FileMgr = CI.getFileManager();
860 auto Buffer = FileMgr.getBufferForFile(Filename: getCurrentFile());
861 StringRef Magic = (*Buffer)->getMemBufferRef().getBuffer();
862 bool IsRaw = Magic.starts_with(Prefix: "CPCH");
863 Out << " Module format: " << (IsRaw ? "raw" : "obj") << "\n";
864
865 Preprocessor &PP = CI.getPreprocessor();
866 DumpModuleInfoListener Listener(Out);
867 HeaderSearchOptions &HSOpts = PP.getHeaderSearchInfo().getHeaderSearchOpts();
868
869 // The FrontendAction::BeginSourceFile () method loads the AST so that much
870 // of the information is already available and modules should have been
871 // loaded.
872
873 const LangOptions &LO = getCurrentASTUnit().getLangOpts();
874 if (LO.CPlusPlusModules && !LO.CurrentModule.empty()) {
875 ASTReader *R = getCurrentASTUnit().getASTReader().get();
876 unsigned SubModuleCount = R->getTotalNumSubmodules();
877 serialization::ModuleFile &MF = R->getModuleManager().getPrimaryModule();
878 Out << " ====== C++20 Module structure ======\n";
879
880 if (MF.ModuleName != LO.CurrentModule)
881 Out << " Mismatched module names : " << MF.ModuleName << " and "
882 << LO.CurrentModule << "\n";
883
884 struct SubModInfo {
885 unsigned Idx;
886 Module *Mod;
887 Module::ModuleKind Kind;
888 std::string &Name;
889 bool Seen;
890 };
891 std::map<std::string, SubModInfo> SubModMap;
892 auto PrintSubMapEntry = [&](std::string Name, Module::ModuleKind Kind) {
893 Out << " " << ModuleKindName(MK: Kind) << " '" << Name << "'";
894 auto I = SubModMap.find(x: Name);
895 if (I == SubModMap.end())
896 Out << " was not found in the sub modules!\n";
897 else {
898 I->second.Seen = true;
899 Out << " is at index #" << I->second.Idx << "\n";
900 }
901 };
902 Module *Primary = nullptr;
903 for (unsigned Idx = 0; Idx <= SubModuleCount; ++Idx) {
904 Module *M = R->getModule(ID: Idx);
905 if (!M)
906 continue;
907 if (M->Name == LO.CurrentModule) {
908 Primary = M;
909 Out << " " << ModuleKindName(MK: M->Kind) << " '" << LO.CurrentModule
910 << "' is the Primary Module at index #" << Idx << "\n";
911 SubModMap.insert(x: {M->Name, {.Idx: Idx, .Mod: M, .Kind: M->Kind, .Name: M->Name, .Seen: true}});
912 } else
913 SubModMap.insert(x: {M->Name, {.Idx: Idx, .Mod: M, .Kind: M->Kind, .Name: M->Name, .Seen: false}});
914 }
915 if (Primary) {
916 if (!Primary->submodules().empty())
917 Out << " Sub Modules:\n";
918 for (auto *MI : Primary->submodules()) {
919 PrintSubMapEntry(MI->Name, MI->Kind);
920 }
921 if (!Primary->Imports.empty())
922 Out << " Imports:\n";
923 for (auto *IMP : Primary->Imports) {
924 PrintSubMapEntry(IMP->Name, IMP->Kind);
925 }
926 if (!Primary->Exports.empty())
927 Out << " Exports:\n";
928 for (unsigned MN = 0, N = Primary->Exports.size(); MN != N; ++MN) {
929 if (Module *M = Primary->Exports[MN].getPointer()) {
930 PrintSubMapEntry(M->Name, M->Kind);
931 }
932 }
933 }
934
935 // Emit the macro definitions in the module file so that we can know how
936 // much definitions in the module file quickly.
937 // TODO: Emit the macro definition bodies completely.
938 if (auto FilteredMacros = llvm::make_filter_range(
939 Range: R->getPreprocessor().macros(),
940 Pred: [](const auto &Macro) { return Macro.first->isFromAST(); });
941 !FilteredMacros.empty()) {
942 Out << " Macro Definitions:\n";
943 for (/*<IdentifierInfo *, MacroState> pair*/ const auto &Macro :
944 FilteredMacros)
945 Out << " " << Macro.first->getName() << "\n";
946 }
947
948 // Now let's print out any modules we did not see as part of the Primary.
949 for (const auto &SM : SubModMap) {
950 if (!SM.second.Seen && SM.second.Mod) {
951 Out << " " << ModuleKindName(MK: SM.second.Kind) << " '" << SM.first
952 << "' at index #" << SM.second.Idx
953 << " has no direct reference in the Primary\n";
954 }
955 }
956 Out << " ====== ======\n";
957 }
958
959 // The reminder of the output is produced from the listener as the AST
960 // FileCcontrolBlock is (re-)parsed.
961 ASTReader::readASTFileControlBlock(
962 Filename: getCurrentFile(), FileMgr, ModuleCache: CI.getModuleCache(),
963 PCHContainerRdr: CI.getPCHContainerReader(),
964 /*FindModuleFileExtensions=*/true, Listener,
965 ValidateDiagnosticOptions: HSOpts.ModulesValidateDiagnosticOptions);
966}
967
968//===----------------------------------------------------------------------===//
969// Preprocessor Actions
970//===----------------------------------------------------------------------===//
971
972void DumpRawTokensAction::ExecuteAction() {
973 Preprocessor &PP = getCompilerInstance().getPreprocessor();
974 SourceManager &SM = PP.getSourceManager();
975
976 // Start lexing the specified input file.
977 llvm::MemoryBufferRef FromFile = SM.getBufferOrFake(FID: SM.getMainFileID());
978 Lexer RawLex(SM.getMainFileID(), FromFile, SM, PP.getLangOpts());
979 RawLex.SetKeepWhitespaceMode(true);
980
981 Token RawTok;
982 RawLex.LexFromRawLexer(Result&: RawTok);
983 while (RawTok.isNot(K: tok::eof)) {
984 PP.DumpToken(Tok: RawTok, DumpFlags: true);
985 llvm::errs() << "\n";
986 RawLex.LexFromRawLexer(Result&: RawTok);
987 }
988}
989
990void DumpTokensAction::ExecuteAction() {
991 Preprocessor &PP = getCompilerInstance().getPreprocessor();
992 // Start preprocessing the specified input file.
993 Token Tok;
994 PP.EnterMainSourceFile();
995 do {
996 PP.Lex(Result&: Tok);
997 PP.DumpToken(Tok, DumpFlags: true);
998 llvm::errs() << "\n";
999 } while (Tok.isNot(K: tok::eof));
1000}
1001
1002void PreprocessOnlyAction::ExecuteAction() {
1003 Preprocessor &PP = getCompilerInstance().getPreprocessor();
1004
1005 // Ignore unknown pragmas.
1006 PP.IgnorePragmas();
1007
1008 Token Tok;
1009 // Start parsing the specified input file.
1010 PP.EnterMainSourceFile();
1011 do {
1012 PP.Lex(Result&: Tok);
1013 } while (Tok.isNot(K: tok::eof));
1014}
1015
1016void PrintPreprocessedAction::ExecuteAction() {
1017 CompilerInstance &CI = getCompilerInstance();
1018 // Output file may need to be set to 'Binary', to avoid converting Unix style
1019 // line feeds (<LF>) to Microsoft style line feeds (<CR><LF>) on Windows.
1020 //
1021 // Look to see what type of line endings the file uses. If there's a
1022 // CRLF, then we won't open the file up in binary mode. If there is
1023 // just an LF or CR, then we will open the file up in binary mode.
1024 // In this fashion, the output format should match the input format, unless
1025 // the input format has inconsistent line endings.
1026 //
1027 // This should be a relatively fast operation since most files won't have
1028 // all of their source code on a single line. However, that is still a
1029 // concern, so if we scan for too long, we'll just assume the file should
1030 // be opened in binary mode.
1031
1032 bool BinaryMode = false;
1033 if (llvm::Triple(LLVM_HOST_TRIPLE).isOSWindows()) {
1034 BinaryMode = true;
1035 const SourceManager &SM = CI.getSourceManager();
1036 if (std::optional<llvm::MemoryBufferRef> Buffer =
1037 SM.getBufferOrNone(FID: SM.getMainFileID())) {
1038 const char *cur = Buffer->getBufferStart();
1039 const char *end = Buffer->getBufferEnd();
1040 const char *next = (cur != end) ? cur + 1 : end;
1041
1042 // Limit ourselves to only scanning 256 characters into the source
1043 // file. This is mostly a check in case the file has no
1044 // newlines whatsoever.
1045 if (end - cur > 256)
1046 end = cur + 256;
1047
1048 while (next < end) {
1049 if (*cur == 0x0D) { // CR
1050 if (*next == 0x0A) // CRLF
1051 BinaryMode = false;
1052
1053 break;
1054 } else if (*cur == 0x0A) // LF
1055 break;
1056
1057 ++cur;
1058 ++next;
1059 }
1060 }
1061 }
1062
1063 std::unique_ptr<raw_ostream> OS =
1064 CI.createDefaultOutputFile(Binary: BinaryMode, BaseInput: getCurrentFileOrBufferName());
1065 if (!OS) return;
1066
1067 // If we're preprocessing a module map, start by dumping the contents of the
1068 // module itself before switching to the input buffer.
1069 auto &Input = getCurrentInput();
1070 if (Input.getKind().getFormat() == InputKind::ModuleMap) {
1071 if (Input.isFile()) {
1072 (*OS) << "# 1 \"";
1073 OS->write_escaped(Str: Input.getFile());
1074 (*OS) << "\"\n";
1075 }
1076 getCurrentModule()->print(OS&: *OS);
1077 (*OS) << "#pragma clang module contents\n";
1078 }
1079
1080 DoPrintPreprocessedInput(PP&: CI.getPreprocessor(), OS: OS.get(),
1081 Opts: CI.getPreprocessorOutputOpts());
1082}
1083
1084void PrintPreambleAction::ExecuteAction() {
1085 switch (getCurrentFileKind().getLanguage()) {
1086 case Language::C:
1087 case Language::CXX:
1088 case Language::ObjC:
1089 case Language::ObjCXX:
1090 case Language::OpenCL:
1091 case Language::OpenCLCXX:
1092 case Language::CUDA:
1093 case Language::HIP:
1094 case Language::HLSL:
1095 case Language::CIR:
1096 break;
1097
1098 case Language::Unknown:
1099 case Language::Asm:
1100 case Language::LLVM_IR:
1101 case Language::RenderScript:
1102 // We can't do anything with these.
1103 return;
1104 }
1105
1106 // We don't expect to find any #include directives in a preprocessed input.
1107 if (getCurrentFileKind().isPreprocessed())
1108 return;
1109
1110 CompilerInstance &CI = getCompilerInstance();
1111 auto Buffer = CI.getFileManager().getBufferForFile(Filename: getCurrentFile());
1112 if (Buffer) {
1113 unsigned Preamble =
1114 Lexer::ComputePreamble(Buffer: (*Buffer)->getBuffer(), LangOpts: CI.getLangOpts()).Size;
1115 llvm::outs().write(Ptr: (*Buffer)->getBufferStart(), Size: Preamble);
1116 }
1117}
1118
1119void DumpCompilerOptionsAction::ExecuteAction() {
1120 CompilerInstance &CI = getCompilerInstance();
1121 std::unique_ptr<raw_ostream> OSP =
1122 CI.createDefaultOutputFile(Binary: false, BaseInput: getCurrentFile());
1123 if (!OSP)
1124 return;
1125
1126 raw_ostream &OS = *OSP;
1127 const Preprocessor &PP = CI.getPreprocessor();
1128 const LangOptions &LangOpts = PP.getLangOpts();
1129
1130 // FIXME: Rather than manually format the JSON (which is awkward due to
1131 // needing to remove trailing commas), this should make use of a JSON library.
1132 // FIXME: Instead of printing enums as an integral value and specifying the
1133 // type as a separate field, use introspection to print the enumerator.
1134
1135 OS << "{\n";
1136 OS << "\n\"features\" : [\n";
1137 {
1138 llvm::SmallString<128> Str;
1139#define FEATURE(Name, Predicate) \
1140 ("\t{\"" #Name "\" : " + llvm::Twine(Predicate ? "true" : "false") + "},\n") \
1141 .toVector(Str);
1142#include "clang/Basic/Features.def"
1143#undef FEATURE
1144 // Remove the newline and comma from the last entry to ensure this remains
1145 // valid JSON.
1146 OS << Str.substr(Start: 0, N: Str.size() - 2);
1147 }
1148 OS << "\n],\n";
1149
1150 OS << "\n\"extensions\" : [\n";
1151 {
1152 llvm::SmallString<128> Str;
1153#define EXTENSION(Name, Predicate) \
1154 ("\t{\"" #Name "\" : " + llvm::Twine(Predicate ? "true" : "false") + "},\n") \
1155 .toVector(Str);
1156#include "clang/Basic/Features.def"
1157#undef EXTENSION
1158 // Remove the newline and comma from the last entry to ensure this remains
1159 // valid JSON.
1160 OS << Str.substr(Start: 0, N: Str.size() - 2);
1161 }
1162 OS << "\n]\n";
1163
1164 OS << "}";
1165}
1166
1167void PrintDependencyDirectivesSourceMinimizerAction::ExecuteAction() {
1168 CompilerInstance &CI = getCompilerInstance();
1169 SourceManager &SM = CI.getPreprocessor().getSourceManager();
1170 llvm::MemoryBufferRef FromFile = SM.getBufferOrFake(FID: SM.getMainFileID());
1171
1172 llvm::SmallVector<dependency_directives_scan::Token, 16> Tokens;
1173 llvm::SmallVector<dependency_directives_scan::Directive, 32> Directives;
1174 if (scanSourceForDependencyDirectives(
1175 Input: FromFile.getBuffer(), Tokens, Directives, Diags: &CI.getDiagnostics(),
1176 InputSourceLoc: SM.getLocForStartOfFile(FID: SM.getMainFileID()))) {
1177 assert(CI.getDiagnostics().hasErrorOccurred() &&
1178 "no errors reported for failure");
1179
1180 // Preprocess the source when verifying the diagnostics to capture the
1181 // 'expected' comments.
1182 if (CI.getDiagnosticOpts().VerifyDiagnostics) {
1183 // Make sure we don't emit new diagnostics!
1184 CI.getDiagnostics().setSuppressAllDiagnostics(true);
1185 Preprocessor &PP = getCompilerInstance().getPreprocessor();
1186 PP.EnterMainSourceFile();
1187 Token Tok;
1188 do {
1189 PP.Lex(Result&: Tok);
1190 } while (Tok.isNot(K: tok::eof));
1191 }
1192 return;
1193 }
1194 printDependencyDirectivesAsSource(Source: FromFile.getBuffer(), Directives,
1195 OS&: llvm::outs());
1196}
1197
1198void GetDependenciesByModuleNameAction::ExecuteAction() {
1199 CompilerInstance &CI = getCompilerInstance();
1200 Preprocessor &PP = CI.getPreprocessor();
1201 SourceManager &SM = PP.getSourceManager();
1202 FileID MainFileID = SM.getMainFileID();
1203 SourceLocation FileStart = SM.getLocForStartOfFile(FID: MainFileID);
1204 SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 2> Path;
1205 IdentifierInfo *ModuleID = PP.getIdentifierInfo(Name: ModuleName);
1206 Path.push_back(Elt: std::make_pair(x&: ModuleID, y&: FileStart));
1207 auto ModResult = CI.loadModule(ImportLoc: FileStart, Path, Visibility: Module::Hidden, IsInclusionDirective: false);
1208 PPCallbacks *CB = PP.getPPCallbacks();
1209 CB->moduleImport(ImportLoc: SourceLocation(), Path, Imported: ModResult);
1210}
1211

source code of clang/lib/Frontend/FrontendActions.cpp