clang 19.0.0git
FrontendActions.cpp
Go to the documentation of this file.
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
11#include "clang/AST/Decl.h"
14#include "clang/Basic/Module.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) {
44 : nullptr;
45}
46
47void EnsureSemaIsCreated(CompilerInstance &CI, FrontendAction &Action) {
48 if (Action.hasCodeCompletionSupport() &&
51
52 if (!CI.hasSema())
54 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() {
73
74 // Ignore unknown pragmas.
75 PP.IgnorePragmas();
76
77 Token Tok;
78 // Start parsing the specified input file.
80 do {
81 PP.Lex(Tok);
82 } while (Tok.isNot(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>
97 if (std::unique_ptr<raw_ostream> OS =
98 CI.createDefaultOutputFile(false, InFile))
99 return CreateASTPrinter(std::move(OS), CI.getFrontendOpts().ASTDumpFilter);
100 return nullptr;
101}
102
103std::unique_ptr<ASTConsumer>
105 const FrontendOptions &Opts = CI.getFrontendOpts();
106 return CreateASTDumper(nullptr /*Dump to stdout.*/, Opts.ASTDumpFilter,
107 Opts.ASTDumpDecls, Opts.ASTDumpAll,
109 Opts.ASTDumpFormat);
110}
111
112std::unique_ptr<ASTConsumer>
115}
116
117std::unique_ptr<ASTConsumer>
119 return CreateASTViewer();
120}
121
122std::unique_ptr<ASTConsumer>
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
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(std::make_unique<PCHGenerator>(
141 CI.getPreprocessor(), CI.getModuleCache(), OutputFile, Sysroot, Buffer,
142 FrontendOpts.ModuleFileExtensions,
144 FrontendOpts.IncludeTimestamps, FrontendOpts.BuildingImplicitModule,
145 +CI.getLangOpts().CacheGeneratedPCH));
146 Consumers.push_back(CI.getPCHContainerWriter().CreatePCHContainerGenerator(
147 CI, std::string(InFile), OutputFile, std::move(OS), Buffer));
148
149 return std::make_unique<MultiplexConsumer>(std::move(Consumers));
150}
151
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>
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, InFile, /*Extension=*/"", /*RemoveFileOnSignal=*/false);
169 if (!OS)
170 return nullptr;
171
172 OutputFile = CI.getFrontendOpts().OutputFile;
173 return OS;
174}
175
177 if (getCompilerInstance().getPreprocessorOpts().AllowPCHWithCompilerErrors)
178 return false;
180}
181
183 CI.getLangOpts().CompilingPCH = true;
184 return true;
185}
186
187std::vector<std::unique_ptr<ASTConsumer>>
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(std::make_unique<PCHGenerator>(
201 CI.getPreprocessor(), CI.getModuleCache(), OutputFile, Sysroot, Buffer,
203 /*AllowASTWithErrors=*/
205 /*IncludeTimestamps=*/
208 /*BuildingImplicitModule=*/+CI.getFrontendOpts().BuildingImplicitModule,
209 /*ShouldCacheASTInMemory=*/
211 Consumers.push_back(CI.getPCHContainerWriter().CreatePCHContainerGenerator(
212 CI, std::string(InFile), OutputFile, std::move(OS), Buffer));
213 return Consumers;
214}
215
216std::unique_ptr<ASTConsumer>
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>(std::move(Consumers));
225}
226
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
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
255 ModuleMapFile);
256 }
257
258 // Because this is exposed via libclang we must disable RemoveFileOnSignal.
259 return CI.createDefaultOutputFile(/*Binary=*/true, InFile, /*Extension=*/"",
260 /*RemoveFileOnSignal=*/false,
261 /*CreateMissingDirectories=*/true,
262 /*ForceUseTemporary=*/true);
263}
264
266 CompilerInstance &CI) {
267 CI.getLangOpts().setCompilingModule(LangOptions::CMK_ModuleInterface);
268
270}
271
272std::unique_ptr<ASTConsumer>
274 StringRef InFile) {
278
279 std::vector<std::unique_ptr<ASTConsumer>> Consumers =
280 CreateMultiplexConsumer(CI, InFile);
281 if (Consumers.empty())
282 return nullptr;
283
285 !CI.getFrontendOpts().ModuleOutputPath.empty()) {
286 Consumers.push_back(std::make_unique<ReducedBMIGenerator>(
289 }
290
291 return std::make_unique<MultiplexConsumer>(std::move(Consumers));
292}
293
294std::unique_ptr<raw_pwrite_stream>
296 StringRef InFile) {
297 return CI.createDefaultOutputFile(/*Binary=*/true, InFile, "pcm");
298}
299
300std::unique_ptr<ASTConsumer>
301GenerateReducedModuleInterfaceAction::CreateASTConsumer(CompilerInstance &CI,
302 StringRef InFile) {
303 return std::make_unique<ReducedBMIGenerator>(CI.getPreprocessor(),
304 CI.getModuleCache(),
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);
315}
316
317std::unique_ptr<raw_pwrite_stream>
318GenerateHeaderUnitAction::CreateOutputFile(CompilerInstance &CI,
319 StringRef InFile) {
320 return CI.createDefaultOutputFile(/*Binary=*/true, InFile, "pcm");
321}
322
324}
325
326std::unique_ptr<ASTConsumer>
328 return std::make_unique<ASTConsumer>();
329}
330
331std::unique_ptr<ASTConsumer>
333 StringRef InFile) {
334 return std::make_unique<ASTConsumer>();
335}
336
337std::unique_ptr<ASTConsumer>
339 return std::make_unique<ASTConsumer>();
340}
341
345 const std::string &Sysroot = CI.getHeaderSearchOpts().Sysroot;
346 std::unique_ptr<ASTReader> Reader(new ASTReader(
349 Sysroot.empty() ? "" : Sysroot.c_str(),
351 /*AllowASTWithCompilerErrors*/ false,
352 /*AllowConfigurationMismatch*/ true,
353 /*ValidateSystemInputs*/ true));
354
355 Reader->ReadAST(getCurrentFile(),
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("name", fields.Name);
377 io.mapRequired("kind", fields.Kind);
378 io.mapRequired("event", fields.Event);
379 io.mapRequired("orig", fields.DefinitionLocation);
380 io.mapRequired("poi", 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>(llvm::outs(), TheSema, Inst);
398 }
399
400 void atTemplateEnd(const Sema &TheSema,
401 const CodeSynthesisContext &Inst) override {
402 displayTemplightEntry<false>(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(YO, Entry, true, 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>(Entity);
484
485 PrintingPolicy Policy = TheSema.Context.getPrintingPolicy();
486 // FIXME: Also ask for FullyQualifiedNames?
487 Policy.SuppressDefaultTemplateArgs = false;
488 NamedTemplate->getNameForDiagnostic(OS, Policy, 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>(Ctx);
495
496 if (const auto *Decl = dyn_cast<TagDecl>(NamedTemplate)) {
497 if (const auto *R = dyn_cast<RecordDecl>(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>(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, TheSema.getLangOpts(), true);
517 return;
518 }
519
520 if (const auto *Decl = dyn_cast<TemplateTypeParmDecl>(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, TheSema.getLangOpts(), true);
528 return;
529 }
530 }
531 }
532
533 if (const auto *Decl = dyn_cast<NonTypeTemplateParmDecl>(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, TheSema.getLangOpts(), true);
539 return;
540 }
541
542 if (const auto *Decl = dyn_cast<TemplateTemplateParmDecl>(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, TheSema.getLangOpts(), 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(Inst.Kind);
560 Entry.Event = BeginInstantiation ? "Begin" : "End";
561 llvm::raw_string_ostream OS(Entry.Name);
562 printEntryName(TheSema, Inst.Entity, OS);
563 const PresumedLoc DefLoc =
564 TheSema.getSourceManager().getPresumedLoc(Inst.Entity->getLocation());
565 if (!DefLoc.isInvalid())
566 Entry.DefinitionLocation = std::string(DefLoc.getFilename()) + ":" +
567 std::to_string(DefLoc.getLine()) + ":" +
568 std::to_string(DefLoc.getColumn());
569 const PresumedLoc PoiLoc =
570 TheSema.getSourceManager().getPresumedLoc(Inst.PointOfInstantiation);
571 if (!PoiLoc.isInvalid()) {
572 Entry.PointOfInstantiation = std::string(PoiLoc.getFilename()) + ":" +
573 std::to_string(PoiLoc.getLine()) + ":" +
574 std::to_string(PoiLoc.getColumn());
575 }
576 return Entry;
577 }
578};
579} // namespace
580
581std::unique_ptr<ASTConsumer>
583 return std::make_unique<ASTConsumer>();
584}
585
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, *this);
594
595 CI.getSema().TemplateInstCallbacks.push_back(
596 std::make_unique<DefaultTemplateInstCallback>());
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(2)
614 << "Generated by "
615 << (FullVersion == getClangFullRepositoryVersion()? "this"
616 : "a different")
617 << " Clang: " << FullVersion << "\n";
619 }
620
621 void ReadModuleName(StringRef ModuleName) override {
622 Out.indent(2) << "Module name: " << ModuleName << "\n";
623 }
624 void ReadModuleMapFile(StringRef ModuleMapPath) override {
625 Out.indent(2) << "Module map file: " << ModuleMapPath << "\n";
626 }
627
628 bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain,
629 bool AllowCompatibleDifferences) override {
630 Out.indent(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(4) << "Module features:\n";
644 for (StringRef Feature : LangOpts.ModuleFeatures)
645 Out.indent(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(2) << "Target options:\n";
654 Out.indent(4) << " Triple: " << TargetOpts.Triple << "\n";
655 Out.indent(4) << " CPU: " << TargetOpts.CPU << "\n";
656 Out.indent(4) << " TuneCPU: " << TargetOpts.TuneCPU << "\n";
657 Out.indent(4) << " ABI: " << TargetOpts.ABI << "\n";
658
659 if (!TargetOpts.FeaturesAsWritten.empty()) {
660 Out.indent(4) << "Target features:\n";
661 for (unsigned I = 0, N = TargetOpts.FeaturesAsWritten.size();
662 I != N; ++I) {
663 Out.indent(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(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(4) << "Diagnostic flags:\n";
681 for (const std::string &Warning : DiagOpts->Warnings)
682 Out.indent(6) << "-W" << Warning << "\n";
683 for (const std::string &Remark : DiagOpts->Remarks)
684 Out.indent(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(2) << "Header search options:\n";
693 Out.indent(4) << "System root [-isysroot=]: '" << HSOpts.Sysroot << "'\n";
694 Out.indent(4) << "Resource dir [ -resource-dir=]: '" << HSOpts.ResourceDir << "'\n";
695 Out.indent(4) << "Module Cache: '" << SpecificModuleCachePath << "'\n";
697 "Use builtin include directories [-nobuiltininc]");
699 "Use standard system include directories [-nostdinc]");
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(2) << "Header search paths:\n";
710 Out.indent(4) << "User entries:\n";
711 for (const auto &Entry : HSOpts.UserEntries)
712 Out.indent(6) << Entry.Path << "\n";
713 Out.indent(4) << "System header prefixes:\n";
714 for (const auto &Prefix : HSOpts.SystemHeaderPrefixes)
715 Out.indent(6) << Prefix.Prefix << "\n";
716 Out.indent(4) << "VFS overlay files:\n";
717 for (const auto &Overlay : HSOpts.VFSOverlayFiles)
718 Out.indent(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(2) << "Preprocessor options:\n";
727 "Uses compiler/target-specific predefines [-undef]");
729 "Uses detailed preprocessing record (for indexing)");
730
731 if (ReadMacros) {
732 Out.indent(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(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(2) << "Module file extension '"
752 << Metadata.BlockName << "' " << Metadata.MajorVersion
753 << "." << Metadata.MinorVersion;
754 if (!Metadata.UserInfo.empty()) {
755 Out << ": ";
756 Out.write_escaped(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(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(2) << "Imports module '" << ModuleName
809 << "': " << Filename.str() << "\n";
810 }
811#undef DUMP_BOOLEAN
812 };
813}
814
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.
819 return true;
820}
821
822static StringRef ModuleKindName(Module::ModuleKind MK) {
823 switch (MK) {
825 return "Module Map Module";
827 return "Interface Unit";
829 return "Implementation Unit";
831 return "Partition Interface";
833 return "Partition Implementation";
835 return "Header Unit";
837 return "Global Module Fragment";
839 return "Implicit Module Fragment";
841 return "Private Module Fragment";
842 }
843 llvm_unreachable("unknown module kind!");
844}
845
847 assert(isCurrentFileAST() && "dumping non-AST?");
848 // Set up the output file.
850 StringRef OutputFileName = CI.getFrontendOpts().OutputFile;
851 if (!OutputFileName.empty() && OutputFileName != "-") {
852 std::error_code EC;
853 OutputStream.reset(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(getCurrentFile());
861 StringRef Magic = (*Buffer)->getMemBufferRef().getBuffer();
862 bool IsRaw = Magic.starts_with("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
874 if (LO.CPlusPlusModules && !LO.CurrentModule.empty()) {
876 unsigned SubModuleCount = R->getTotalNumSubmodules();
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;
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(Kind) << " '" << Name << "'";
894 auto I = SubModMap.find(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(Idx);
905 if (!M)
906 continue;
907 if (M->Name == LO.CurrentModule) {
908 Primary = M;
909 Out << " " << ModuleKindName(M->Kind) << " '" << LO.CurrentModule
910 << "' is the Primary Module at index #" << Idx << "\n";
911 SubModMap.insert({M->Name, {Idx, M, M->Kind, M->Name, true}});
912 } else
913 SubModMap.insert({M->Name, {Idx, M, M->Kind, M->Name, 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 R->getPreprocessor().macros(),
940 [](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(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.
962 getCurrentFile(), FileMgr, CI.getModuleCache(),
964 /*FindModuleFileExtensions=*/true, Listener,
966}
967
968//===----------------------------------------------------------------------===//
969// Preprocessor Actions
970//===----------------------------------------------------------------------===//
971
975
976 // Start lexing the specified input file.
977 llvm::MemoryBufferRef FromFile = SM.getBufferOrFake(SM.getMainFileID());
978 Lexer RawLex(SM.getMainFileID(), FromFile, SM, PP.getLangOpts());
979 RawLex.SetKeepWhitespaceMode(true);
980
981 Token RawTok;
982 RawLex.LexFromRawLexer(RawTok);
983 while (RawTok.isNot(tok::eof)) {
984 PP.DumpToken(RawTok, true);
985 llvm::errs() << "\n";
986 RawLex.LexFromRawLexer(RawTok);
987 }
988}
989
992 // Start preprocessing the specified input file.
993 Token Tok;
995 do {
996 PP.Lex(Tok);
997 PP.DumpToken(Tok, true);
998 llvm::errs() << "\n";
999 } while (Tok.isNot(tok::eof));
1000}
1001
1004
1005 // Ignore unknown pragmas.
1006 PP.IgnorePragmas();
1007
1008 Token Tok;
1009 // Start parsing the specified input file.
1011 do {
1012 PP.Lex(Tok);
1013 } while (Tok.isNot(tok::eof));
1014}
1015
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(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 =
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(Input.getFile());
1074 (*OS) << "\"\n";
1075 }
1076 getCurrentModule()->print(*OS);
1077 (*OS) << "#pragma clang module contents\n";
1078 }
1079
1082}
1083
1085 switch (getCurrentFileKind().getLanguage()) {
1086 case Language::C:
1087 case Language::CXX:
1088 case Language::ObjC:
1089 case Language::ObjCXX:
1090 case Language::OpenCL:
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:
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
1111 auto Buffer = CI.getFileManager().getBufferForFile(getCurrentFile());
1112 if (Buffer) {
1113 unsigned Preamble =
1114 Lexer::ComputePreamble((*Buffer)->getBuffer(), CI.getLangOpts()).Size;
1115 llvm::outs().write((*Buffer)->getBufferStart(), Preamble);
1116 }
1117}
1118
1119void DumpCompilerOptionsAction::ExecuteAction() {
1121 std::unique_ptr<raw_ostream> OSP =
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 {
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(0, Str.size() - 2);
1147 }
1148 OS << "\n],\n";
1149
1150 OS << "\n\"extensions\" : [\n";
1151 {
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(0, Str.size() - 2);
1161 }
1162 OS << "\n]\n";
1163
1164 OS << "}";
1165}
1166
1170 llvm::MemoryBufferRef FromFile = SM.getBufferOrFake(SM.getMainFileID());
1171
1175 FromFile.getBuffer(), Tokens, Directives, &CI.getDiagnostics(),
1176 SM.getLocForStartOfFile(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!
1187 Token Tok;
1188 do {
1189 PP.Lex(Tok);
1190 } while (Tok.isNot(tok::eof));
1191 }
1192 return;
1193 }
1194 printDependencyDirectivesAsSource(FromFile.getBuffer(), Directives,
1195 llvm::outs());
1196}
1197
1198void GetDependenciesByModuleNameAction::ExecuteAction() {
1200 Preprocessor &PP = CI.getPreprocessor();
1202 FileID MainFileID = SM.getMainFileID();
1203 SourceLocation FileStart = SM.getLocForStartOfFile(MainFileID);
1205 IdentifierInfo *ModuleID = PP.getIdentifierInfo(ModuleName);
1206 Path.push_back(std::make_pair(ModuleID, FileStart));
1207 auto ModResult = CI.loadModule(FileStart, Path, Module::Hidden, false);
1208 PPCallbacks *CB = PP.getPPCallbacks();
1209 CB->moduleImport(SourceLocation(), Path, ModResult);
1210}
#define SM(sm)
Definition: Cuda.cpp:82
This is the interface for scanning header and source files to get the minimum necessary preprocessor ...
Defines the clang::FileManager interface and associated types.
StringRef Filename
Definition: Format.cpp:2972
#define DUMP_BOOLEAN(Value, Text)
static StringRef ModuleKindName(Module::ModuleKind MK)
Defines the clang::Module class, which describes a module in the source code.
Defines the clang::Preprocessor interface.
static std::string toString(const clang::SanitizerSet &Sanitizers)
Produce a string containing comma-separated names of sanitizers in Sanitizers set.
const clang::PrintingPolicy & getPrintingPolicy() const
Definition: ASTContext.h:697
std::unique_ptr< ASTConsumer > CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override
Create the AST consumer object for this action, if supported.
std::unique_ptr< ASTConsumer > CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override
Create the AST consumer object for this action, if supported.
void ExecuteAction() override
Implement the ExecuteAction interface by running Sema on the already-initialized AST consumer.
std::unique_ptr< ASTConsumer > CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override
Create the AST consumer object for this action, if supported.
Abstract interface for callback invocations by the ASTReader.
Definition: ASTReader.h:114
virtual bool ReadFullVersionInformation(StringRef FullVersion)
Receives the full Clang version information.
Definition: ASTReader.h:122
Reads an AST files chain containing the contents of a translation unit.
Definition: ASTReader.h:366
ModuleManager & getModuleManager()
Retrieve the module manager.
Definition: ASTReader.h:1764
@ ARR_ConfigurationMismatch
The client can handle an AST file that cannot load because it's compiled configuration doesn't match ...
Definition: ASTReader.h:1619
unsigned getTotalNumSubmodules() const
Returns the number of submodules known.
Definition: ASTReader.h:1859
Module * getModule(unsigned ID) override
Retrieve the module that corresponds to the given module ID.
Definition: ASTReader.cpp:9004
static bool readASTFileControlBlock(StringRef Filename, FileManager &FileMgr, const InMemoryModuleCache &ModuleCache, const PCHContainerReader &PCHContainerRdr, bool FindModuleFileExtensions, ASTReaderListener &Listener, bool ValidateDiagnosticOptions, unsigned ClientLoadCapabilities=ARR_ConfigurationMismatch|ARR_OutOfDate)
Read the control block for the named AST file.
Definition: ASTReader.cpp:5423
Preprocessor & getPreprocessor() const
Retrieve the preprocessor.
Definition: ASTReader.h:1767
const LangOptions & getLangOpts() const
Definition: ASTUnit.h:464
IntrusiveRefCntPtr< ASTReader > getASTReader() const
Definition: ASTUnit.cpp:761
std::unique_ptr< ASTConsumer > CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override
Create the AST consumer object for this action, if supported.
Abstract interface for a consumer of code-completion information.
CompilerInstance - Helper class for managing a single instance of the Clang compiler.
const PCHContainerReader & getPCHContainerReader() const
Return the appropriate PCHContainerReader depending on the current CodeGenOptions.
DiagnosticsEngine & getDiagnostics() const
Get the current diagnostics engine.
std::unique_ptr< raw_pwrite_stream > createDefaultOutputFile(bool Binary=true, StringRef BaseInput="", StringRef Extension="", bool RemoveFileOnSignal=true, bool CreateMissingDirectories=false, bool ForceUseTemporary=false)
Create the default output file (from the invocation's options) and add it to the list of tracked outp...
ModuleLoadResult loadModule(SourceLocation ImportLoc, ModuleIdPath Path, Module::NameVisibilityKind Visibility, bool IsInclusionDirective) override
Attempt to load the given module.
FileManager & getFileManager() const
Return the current file manager to the caller.
PreprocessorOutputOptions & getPreprocessorOutputOpts()
InMemoryModuleCache & getModuleCache() const
Preprocessor & getPreprocessor() const
Return the current preprocessor.
ASTContext & getASTContext() const
FrontendOptions & getFrontendOpts()
HeaderSearchOptions & getHeaderSearchOpts()
bool hasCodeCompletionConsumer() const
const PCHContainerWriter & getPCHContainerWriter() const
Return the appropriate PCHContainerWriter depending on the current CodeGenOptions.
PreprocessorOptions & getPreprocessorOpts()
void createCodeCompletionConsumer()
Create a code completion consumer using the invocation; note that this will cause the source manager ...
DiagnosticOptions & getDiagnosticOpts()
LangOptions & getLangOpts()
SourceManager & getSourceManager() const
Return the current source manager.
CodeCompleteConsumer & getCodeCompletionConsumer() const
void createSema(TranslationUnitKind TUKind, CodeCompleteConsumer *CompletionConsumer)
Create the Sema object to be used for parsing.
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:85
static Decl * castFromDeclContext(const DeclContext *)
Definition: DeclBase.cpp:1003
SourceLocation getLocation() const
Definition: DeclBase.h:444
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1547
bool hasErrorOccurred() const
Definition: Diagnostic.h:843
void setSuppressAllDiagnostics(bool Val)
Suppress all diagnostics, to silence the front end when we know that we don't want any more diagnosti...
Definition: Diagnostic.h:697
std::unique_ptr< ASTConsumer > CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override
Create the AST consumer object for this action, if supported.
void ExecuteAction() override
Implement the ExecuteAction interface by running Sema on the already-initialized AST consumer.
bool BeginInvocation(CompilerInstance &CI) override
Callback before starting processing a single input, giving the opportunity to modify the CompilerInvo...
void ExecuteAction() override
Callback to run the program action, using the initialized compiler instance.
void ExecuteAction() override
Callback to run the program action, using the initialized compiler instance.
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
llvm::ErrorOr< std::unique_ptr< llvm::MemoryBuffer > > getBufferForFile(FileEntryRef Entry, bool isVolatile=false, bool RequiresNullTerminator=true)
Open the specified file as a MemoryBuffer, returning a new MemoryBuffer if successful,...
Abstract base class for actions which can be performed by the frontend.
const FrontendInputFile & getCurrentInput() const
InputKind getCurrentFileKind() const
virtual bool shouldEraseOutputFiles()
Callback at the end of processing a single input, to determine if the output files should be erased o...
ASTUnit & getCurrentASTUnit() const
CompilerInstance & getCompilerInstance() const
Module * getCurrentModule() const
StringRef getCurrentFile() const
virtual bool BeginSourceFileAction(CompilerInstance &CI)
Callback at the start of processing a single input.
virtual TranslationUnitKind getTranslationUnitKind()
For AST-based actions, the kind of translation unit we're handling.
virtual bool hasCodeCompletionSupport() const
Does this action support use with code completion?
StringRef getCurrentFileOrBufferName() const
bool isCurrentFileAST() const
FrontendOptions - Options for controlling the behavior of the frontend.
unsigned BuildingImplicitModule
Whether we are performing an implicit module build.
unsigned AllowPCMWithCompilerErrors
Output (and read) PCM files regardless of compiler errors.
unsigned IncludeTimestamps
Whether timestamps should be written to the produced PCH file.
std::string ASTDumpFilter
If given, filter dumped AST Decl nodes by this substring.
unsigned ASTDumpLookups
Whether we include lookup table dumps in AST dumps.
ASTDumpOutputFormat ASTDumpFormat
Specifies the output format of the AST.
std::string OutputFile
The output file, if any.
unsigned GenReducedBMI
Whether to generate reduced BMI for C++20 named modules.
std::vector< std::shared_ptr< ModuleFileExtension > > ModuleFileExtensions
The list of module file extensions.
ParsedSourceLocation CodeCompletionAt
If given, enable code completion at the provided location.
std::string OriginalModuleMap
When the input is a module map, the original module map file from which that map was inferred,...
std::string ModuleOutputPath
Output Path for module output file.
unsigned ASTDumpDeclTypes
Whether we include declaration type dumps in AST dumps.
unsigned ASTDumpAll
Whether we deserialize all decls when forming AST dumps.
unsigned RelocatablePCH
When generating PCH files, instruct the AST writer to create relocatable PCH files.
unsigned ASTDumpDecls
Whether we include declaration dumps in AST dumps.
bool shouldEraseOutputFiles() override
Callback at the end of processing a single input, to determine if the output files should be erased o...
std::vector< std::unique_ptr< ASTConsumer > > CreateMultiplexConsumer(CompilerInstance &CI, StringRef InFile)
std::unique_ptr< ASTConsumer > CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override
Create the AST consumer object for this action, if supported.
bool BeginSourceFileAction(CompilerInstance &CI) override
Callback at the start of processing a single input.
std::unique_ptr< raw_pwrite_stream > CreateOutputFile(CompilerInstance &CI, StringRef InFile) override
std::unique_ptr< ASTConsumer > CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override
Create the AST consumer object for this action, if supported.
static std::unique_ptr< llvm::raw_pwrite_stream > CreateOutputFile(CompilerInstance &CI, StringRef InFile, std::string &OutputFile)
Creates file to write the PCH into and returns a stream to write it into.
bool BeginSourceFileAction(CompilerInstance &CI) override
Callback at the start of processing a single input.
static bool ComputeASTConsumerArguments(CompilerInstance &CI, std::string &Sysroot)
Compute the AST consumer arguments that will be used to create the PCHGenerator instance returned by ...
std::unique_ptr< ASTConsumer > CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override
Create the AST consumer object for this action, if supported.
bool shouldEraseOutputFiles() override
Callback at the end of processing a single input, to determine if the output files should be erased o...
HeaderSearchOptions - Helper class for storing options related to the initialization of the HeaderSea...
unsigned ModulesSkipHeaderSearchPaths
Whether to entirely skip writing header search paths.
std::vector< SystemHeaderPrefix > SystemHeaderPrefixes
User-specified system header prefixes.
std::string ModuleFormat
The module/pch container format.
std::string Sysroot
If non-empty, the directory to use as a "virtual system root" for include paths.
unsigned ModulesSkipDiagnosticOptions
Whether to entirely skip writing diagnostic options.
std::vector< std::string > VFSOverlayFiles
The set of user-provided virtual filesystem overlay files.
unsigned UseLibcxx
Use libc++ instead of the default libstdc++.
unsigned UseBuiltinIncludes
Include the compiler builtin includes.
unsigned UseStandardCXXIncludes
Include the system standard C++ library include search directories.
unsigned ModulesSkipPragmaDiagnosticMappings
Whether to entirely skip writing pragma diagnostic mappings.
std::vector< Entry > UserEntries
User specified include entries.
std::string ResourceDir
The directory which holds the compiler resource files (builtin includes, etc.).
unsigned UseStandardSystemIncludes
Include the system standard include search directories.
Encapsulates the information needed to find the file referenced by a #include or #include_next,...
Definition: HeaderSearch.h:247
std::string getCachedModuleFileName(Module *Module)
Retrieve the name of the cached module file that should be used to load the given module.
One of these records is kept for each identifier that is lexed.
@ CMK_HeaderUnit
Compiling a module header unit.
Definition: LangOptions.h:98
@ CMK_ModuleInterface
Compiling a C++ modules interface unit.
Definition: LangOptions.h:101
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:449
std::string CurrentModule
The name of the current module, of which the main source file is a part.
Definition: LangOptions.h:504
std::vector< std::string > ModuleFeatures
The names of any features to enable in module 'requires' decls in addition to the hard-coded list in ...
Definition: LangOptions.h:510
Lexer - This provides a simple interface that turns a text buffer into a stream of tokens.
Definition: Lexer.h:78
void SetKeepWhitespaceMode(bool Val)
SetKeepWhitespaceMode - This method lets clients enable or disable whitespace retention mode.
Definition: Lexer.h:254
bool LexFromRawLexer(Token &Result)
LexFromRawLexer - Lex a token from a designated raw lexer (one with no associated preprocessor object...
Definition: Lexer.h:236
static PreambleBounds ComputePreamble(StringRef Buffer, const LangOptions &LangOpts, unsigned MaxLines=0)
Compute the preamble of the given file.
Definition: Lexer.cpp:637
Describes a module or submodule.
Definition: Module.h:105
SmallVector< ExportDecl, 2 > Exports
The set of export declarations.
Definition: Module.h:414
@ Hidden
All of the names in this module are hidden.
Definition: Module.h:388
void print(raw_ostream &OS, unsigned Indent=0, bool Dump=false) const
Print the module map for this module to the given stream.
Definition: Module.cpp:482
ModuleKind Kind
The kind of this module.
Definition: Module.h:150
llvm::SmallSetVector< Module *, 2 > Imports
The set of modules imported by this module, and on which this module depends.
Definition: Module.h:401
std::string Name
The name of this module.
Definition: Module.h:108
llvm::iterator_range< submodule_iterator > submodules()
Definition: Module.h:782
@ ModuleImplementationUnit
This is a C++20 module implementation unit.
Definition: Module.h:128
@ ModuleMapModule
This is a module that was defined by a module map and built out of header files.
Definition: Module.h:119
@ ImplicitGlobalModuleFragment
This is an implicit fragment of the global module which contains only language linkage declarations (...
Definition: Module.h:146
@ ModulePartitionInterface
This is a C++20 module partition interface.
Definition: Module.h:131
@ ModuleInterfaceUnit
This is a C++20 module interface unit.
Definition: Module.h:125
@ ModuleHeaderUnit
This is a C++20 header unit.
Definition: Module.h:122
@ ModulePartitionImplementation
This is a C++20 module partition implementation.
Definition: Module.h:134
@ PrivateModuleFragment
This is the private module fragment within some C++ module.
Definition: Module.h:141
@ ExplicitGlobalModuleFragment
This is the explicit Global Module Fragment of a modular TU.
Definition: Module.h:138
This represents a decl that may have a name.
Definition: Decl.h:249
virtual void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const
Appends a human-readable name for this declaration into the given stream.
Definition: Decl.cpp:1826
virtual std::unique_ptr< ASTConsumer > CreatePCHContainerGenerator(CompilerInstance &CI, const std::string &MainFileName, const std::string &OutputFileName, std::unique_ptr< llvm::raw_pwrite_stream > OS, std::shared_ptr< PCHBuffer > Buffer) const =0
Return an ASTConsumer that can be chained with a PCHGenerator that produces a wrapper file format con...
This interface provides a way to observe the actions of the preprocessor as it does its thing.
Definition: PPCallbacks.h:35
virtual void moduleImport(SourceLocation ImportLoc, ModuleIdPath Path, const Module *Imported)
Callback invoked whenever there was an explicit module-import syntax.
Definition: PPCallbacks.h:180
void ExecuteAction() override
Callback to run the program action, using the initialized compiler instance.
PreprocessorOptions - This class is used for passing the various options used in preprocessor initial...
std::pair< unsigned, bool > PrecompiledPreambleBytes
If non-zero, the implicit PCH include is actually a precompiled preamble that covers this number of b...
bool DetailedRecord
Whether we should maintain a detailed record of all macro definitions and expansions.
bool UsePredefines
Initialize the preprocessor with the compiler and target specific predefines.
std::vector< std::pair< std::string, bool > > Macros
bool AllowPCHWithCompilerErrors
When true, a PCH with compiler errors will not be rejected.
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:128
void DumpToken(const Token &Tok, bool DumpFlags=false) const
Print the token to stderr, used for debugging.
void IgnorePragmas()
Install empty handlers for all pragmas (making them ignored).
Definition: Pragma.cpp:2195
PPCallbacks * getPPCallbacks() const
void Lex(Token &Result)
Lex the next token for this preprocessor.
void EnterMainSourceFile()
Enter the specified FileID as the main source file, which implicitly adds the builtin defines etc.
IdentifierInfo * getIdentifierInfo(StringRef Name) const
Return information about the specified preprocessor identifier token.
SourceManager & getSourceManager() const
llvm::iterator_range< macro_iterator > macros(bool IncludeExternalMacros=true) const
HeaderSearch & getHeaderSearchInfo() const
const LangOptions & getLangOpts() const
Represents an unpacked "presumed" location which can be presented to the user.
unsigned getColumn() const
Return the presumed column number of this location.
const char * getFilename() const
Return the presumed filename of this location.
unsigned getLine() const
Return the presumed line number of this location.
bool isInvalid() const
Return true if this object is invalid or uninitialized.
void ExecuteAction() override
Callback to run the program action, using the initialized compiler instance.
void ExecuteAction() override
Callback to run the program action, using the initialized compiler instance.
void ExecuteAction() override
Callback to run the program action, using the initialized compiler instance.
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:442
ASTContext & Context
Definition: Sema.h:845
const LangOptions & getLangOpts() const
Definition: Sema.h:506
std::vector< std::unique_ptr< TemplateInstantiationCallback > > TemplateInstCallbacks
The template instantiation callbacks to trace or track instantiations (objects can be chained).
Definition: Sema.h:10375
SourceManager & getSourceManager() const
Definition: Sema.h:511
Encodes a location in the source.
void print(raw_ostream &OS, const SourceManager &SM) const
This class handles loading and caching of source files into memory.
PresumedLoc getPresumedLoc(SourceLocation Loc, bool UseLineDirectives=true) const
Returns the "presumed" location of a SourceLocation specifies.
std::unique_ptr< ASTConsumer > CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override
Create the AST consumer object for this action, if supported.
Options for controlling the target.
Definition: TargetOptions.h:26
std::string Triple
The name of the target triple to compile for.
Definition: TargetOptions.h:29
std::string ABI
If given, the name of the target ABI to use.
Definition: TargetOptions.h:45
std::string TuneCPU
If given, the name of the target CPU to tune code for.
Definition: TargetOptions.h:39
std::string CPU
If given, the name of the target CPU to generate code for.
Definition: TargetOptions.h:36
std::vector< std::string > FeaturesAsWritten
The list of target specific features to enable or disable, as written on the command line.
Definition: TargetOptions.h:54
This is a base class for callbacks that will be notified at every template instantiation.
std::unique_ptr< ASTConsumer > CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override
Create the AST consumer object for this action, if supported.
void ExecuteAction() override
Implement the ExecuteAction interface by running Sema on the already-initialized AST consumer.
Token - This structure provides full information about a lexed token.
Definition: Token.h:36
bool isNot(tok::TokenKind K) const
Definition: Token.h:100
The base class of the type hierarchy.
Definition: Type.h:1607
std::unique_ptr< ASTConsumer > CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override
Create the AST consumer object for this action, if supported.
void ExecuteAction() override
Implement the ExecuteAction interface by running Sema on the already-initialized AST consumer.
Information about a module that has been loaded by the ASTReader.
Definition: ModuleFile.h:124
std::string ModuleName
The name of the module.
Definition: ModuleFile.h:142
ModuleFile & getPrimaryModule()
Returns the primary module associated with the manager, that is, the first module loaded.
Defines the clang::TargetInfo interface.
@ MK_PCH
File is a PCH file treated as such.
Definition: ModuleFile.h:50
@ MK_Preamble
File is a PCH file treated as the preamble.
Definition: ModuleFile.h:53
The JSON file list parser is used to communicate input to InstallAPI.
void atTemplateEnd(TemplateInstantiationCallbackPtrs &Callbacks, const Sema &TheSema, const Sema::CodeSynthesisContext &Inst)
void atTemplateBegin(TemplateInstantiationCallbackPtrs &Callbacks, const Sema &TheSema, const Sema::CodeSynthesisContext &Inst)
void printDependencyDirectivesAsSource(StringRef Source, ArrayRef< dependency_directives_scan::Directive > Directives, llvm::raw_ostream &OS)
Print the previously scanned dependency directives as minimized source text.
void initialize(TemplateInstantiationCallbackPtrs &Callbacks, const Sema &TheSema)
bool scanSourceForDependencyDirectives(StringRef Input, SmallVectorImpl< dependency_directives_scan::Token > &Tokens, SmallVectorImpl< dependency_directives_scan::Directive > &Directives, DiagnosticsEngine *Diags=nullptr, SourceLocation InputSourceLoc=SourceLocation())
Scan the input for the preprocessor directives that might have an effect on the dependencies for a co...
std::unique_ptr< ASTConsumer > CreateASTDeclNodeLister()
@ C
Languages that the frontend can parse and compile.
@ CIR
LLVM IR & CIR: we accept these so that we can run the optimizer on them, and compile them to assembly...
@ Asm
Assembly: we accept this only so that we can preprocess it.
void DoPrintPreprocessedInput(Preprocessor &PP, raw_ostream *OS, const PreprocessorOutputOptions &Opts)
DoPrintPreprocessedInput - Implement -E mode.
std::unique_ptr< ASTConsumer > CreateASTDumper(std::unique_ptr< raw_ostream > OS, StringRef FilterString, bool DumpDecls, bool Deserialize, bool DumpLookups, bool DumpDeclTypes, ASTDumpOutputFormat Format)
std::unique_ptr< ASTConsumer > CreateASTPrinter(std::unique_ptr< raw_ostream > OS, StringRef FilterString)
std::unique_ptr< ASTConsumer > CreateASTViewer()
@ None
Perform validation, don't disable it.
std::string getClangFullRepositoryVersion()
Retrieves the full repository version that is an amalgamation of the information in getClangRepositor...
Definition: Version.cpp:68
void finalize(TemplateInstantiationCallbackPtrs &Callbacks, const Sema &TheSema)
Diagnostic wrappers for TextAPI types for error reporting.
Definition: Dominators.h:30
Metadata for a module file extension.
unsigned MajorVersion
The major version of the extension data.
std::string UserInfo
A string containing additional user information that will be stored with the metadata.
std::string BlockName
The name used to identify this particular extension block within the resulting module file.
unsigned MinorVersion
The minor version of the extension data.
unsigned Size
Size of the preamble in bytes.
Definition: Lexer.h:62
Describes how types, statements, expressions, and declarations should be printed.
Definition: PrettyPrinter.h:57
unsigned SuppressDefaultTemplateArgs
When true, attempt to suppress template arguments that match the default argument for the parameter.
A context in which code is being synthesized (where a source location alone is not sufficient to iden...
Definition: Sema.h:9888
static void mapping(IO &io, TemplightEntry &fields)