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) {
275 std::vector<std::unique_ptr<ASTConsumer>> Consumers;
276
278 !CI.getFrontendOpts().ModuleOutputPath.empty()) {
279 Consumers.push_back(std::make_unique<ReducedBMIGenerator>(
282 }
283
284 Consumers.push_back(std::make_unique<CXX20ModulesGenerator>(
287
288 return std::make_unique<MultiplexConsumer>(std::move(Consumers));
289}
290
291std::unique_ptr<raw_pwrite_stream>
293 StringRef InFile) {
294 return CI.createDefaultOutputFile(/*Binary=*/true, InFile, "pcm");
295}
296
297std::unique_ptr<ASTConsumer>
298GenerateReducedModuleInterfaceAction::CreateASTConsumer(CompilerInstance &CI,
299 StringRef InFile) {
300 return std::make_unique<ReducedBMIGenerator>(CI.getPreprocessor(),
301 CI.getModuleCache(),
303}
304
305bool GenerateHeaderUnitAction::BeginSourceFileAction(CompilerInstance &CI) {
306 if (!CI.getLangOpts().CPlusPlusModules) {
307 CI.getDiagnostics().Report(diag::err_module_interface_requires_cpp_modules);
308 return false;
309 }
310 CI.getLangOpts().setCompilingModule(LangOptions::CMK_HeaderUnit);
312}
313
314std::unique_ptr<raw_pwrite_stream>
315GenerateHeaderUnitAction::CreateOutputFile(CompilerInstance &CI,
316 StringRef InFile) {
317 return CI.createDefaultOutputFile(/*Binary=*/true, InFile, "pcm");
318}
319
321}
322
323std::unique_ptr<ASTConsumer>
325 return std::make_unique<ASTConsumer>();
326}
327
328std::unique_ptr<ASTConsumer>
330 StringRef InFile) {
331 return std::make_unique<ASTConsumer>();
332}
333
334std::unique_ptr<ASTConsumer>
336 return std::make_unique<ASTConsumer>();
337}
338
342 const std::string &Sysroot = CI.getHeaderSearchOpts().Sysroot;
343 std::unique_ptr<ASTReader> Reader(new ASTReader(
346 Sysroot.empty() ? "" : Sysroot.c_str(),
348 /*AllowASTWithCompilerErrors*/ false,
349 /*AllowConfigurationMismatch*/ true,
350 /*ValidateSystemInputs*/ true));
351
352 Reader->ReadAST(getCurrentFile(),
357}
358
359namespace {
360struct TemplightEntry {
361 std::string Name;
362 std::string Kind;
363 std::string Event;
364 std::string DefinitionLocation;
365 std::string PointOfInstantiation;
366};
367} // namespace
368
369namespace llvm {
370namespace yaml {
371template <> struct MappingTraits<TemplightEntry> {
372 static void mapping(IO &io, TemplightEntry &fields) {
373 io.mapRequired("name", fields.Name);
374 io.mapRequired("kind", fields.Kind);
375 io.mapRequired("event", fields.Event);
376 io.mapRequired("orig", fields.DefinitionLocation);
377 io.mapRequired("poi", fields.PointOfInstantiation);
378 }
379};
380} // namespace yaml
381} // namespace llvm
382
383namespace {
384class DefaultTemplateInstCallback : public TemplateInstantiationCallback {
385 using CodeSynthesisContext = Sema::CodeSynthesisContext;
386
387public:
388 void initialize(const Sema &) override {}
389
390 void finalize(const Sema &) override {}
391
392 void atTemplateBegin(const Sema &TheSema,
393 const CodeSynthesisContext &Inst) override {
394 displayTemplightEntry<true>(llvm::outs(), TheSema, Inst);
395 }
396
397 void atTemplateEnd(const Sema &TheSema,
398 const CodeSynthesisContext &Inst) override {
399 displayTemplightEntry<false>(llvm::outs(), TheSema, Inst);
400 }
401
402private:
403 static std::string toString(CodeSynthesisContext::SynthesisKind Kind) {
404 switch (Kind) {
405 case CodeSynthesisContext::TemplateInstantiation:
406 return "TemplateInstantiation";
407 case CodeSynthesisContext::DefaultTemplateArgumentInstantiation:
408 return "DefaultTemplateArgumentInstantiation";
409 case CodeSynthesisContext::DefaultFunctionArgumentInstantiation:
410 return "DefaultFunctionArgumentInstantiation";
411 case CodeSynthesisContext::ExplicitTemplateArgumentSubstitution:
412 return "ExplicitTemplateArgumentSubstitution";
413 case CodeSynthesisContext::DeducedTemplateArgumentSubstitution:
414 return "DeducedTemplateArgumentSubstitution";
415 case CodeSynthesisContext::LambdaExpressionSubstitution:
416 return "LambdaExpressionSubstitution";
417 case CodeSynthesisContext::PriorTemplateArgumentSubstitution:
418 return "PriorTemplateArgumentSubstitution";
419 case CodeSynthesisContext::DefaultTemplateArgumentChecking:
420 return "DefaultTemplateArgumentChecking";
421 case CodeSynthesisContext::ExceptionSpecEvaluation:
422 return "ExceptionSpecEvaluation";
423 case CodeSynthesisContext::ExceptionSpecInstantiation:
424 return "ExceptionSpecInstantiation";
425 case CodeSynthesisContext::DeclaringSpecialMember:
426 return "DeclaringSpecialMember";
427 case CodeSynthesisContext::DeclaringImplicitEqualityComparison:
428 return "DeclaringImplicitEqualityComparison";
429 case CodeSynthesisContext::DefiningSynthesizedFunction:
430 return "DefiningSynthesizedFunction";
431 case CodeSynthesisContext::RewritingOperatorAsSpaceship:
432 return "RewritingOperatorAsSpaceship";
433 case CodeSynthesisContext::Memoization:
434 return "Memoization";
435 case CodeSynthesisContext::ConstraintsCheck:
436 return "ConstraintsCheck";
437 case CodeSynthesisContext::ConstraintSubstitution:
438 return "ConstraintSubstitution";
439 case CodeSynthesisContext::ConstraintNormalization:
440 return "ConstraintNormalization";
441 case CodeSynthesisContext::RequirementParameterInstantiation:
442 return "RequirementParameterInstantiation";
443 case CodeSynthesisContext::ParameterMappingSubstitution:
444 return "ParameterMappingSubstitution";
445 case CodeSynthesisContext::RequirementInstantiation:
446 return "RequirementInstantiation";
447 case CodeSynthesisContext::NestedRequirementConstraintsCheck:
448 return "NestedRequirementConstraintsCheck";
449 case CodeSynthesisContext::InitializingStructuredBinding:
450 return "InitializingStructuredBinding";
451 case CodeSynthesisContext::MarkingClassDllexported:
452 return "MarkingClassDllexported";
453 case CodeSynthesisContext::BuildingBuiltinDumpStructCall:
454 return "BuildingBuiltinDumpStructCall";
455 case CodeSynthesisContext::BuildingDeductionGuides:
456 return "BuildingDeductionGuides";
457 case CodeSynthesisContext::TypeAliasTemplateInstantiation:
458 return "TypeAliasTemplateInstantiation";
459 }
460 return "";
461 }
462
463 template <bool BeginInstantiation>
464 static void displayTemplightEntry(llvm::raw_ostream &Out, const Sema &TheSema,
465 const CodeSynthesisContext &Inst) {
466 std::string YAML;
467 {
468 llvm::raw_string_ostream OS(YAML);
469 llvm::yaml::Output YO(OS);
470 TemplightEntry Entry =
471 getTemplightEntry<BeginInstantiation>(TheSema, Inst);
472 llvm::yaml::EmptyContext Context;
473 llvm::yaml::yamlize(YO, Entry, true, Context);
474 }
475 Out << "---" << YAML << "\n";
476 }
477
478 static void printEntryName(const Sema &TheSema, const Decl *Entity,
479 llvm::raw_string_ostream &OS) {
480 auto *NamedTemplate = cast<NamedDecl>(Entity);
481
482 PrintingPolicy Policy = TheSema.Context.getPrintingPolicy();
483 // FIXME: Also ask for FullyQualifiedNames?
484 Policy.SuppressDefaultTemplateArgs = false;
485 NamedTemplate->getNameForDiagnostic(OS, Policy, true);
486
487 if (!OS.str().empty())
488 return;
489
490 Decl *Ctx = Decl::castFromDeclContext(NamedTemplate->getDeclContext());
491 NamedDecl *NamedCtx = dyn_cast_or_null<NamedDecl>(Ctx);
492
493 if (const auto *Decl = dyn_cast<TagDecl>(NamedTemplate)) {
494 if (const auto *R = dyn_cast<RecordDecl>(Decl)) {
495 if (R->isLambda()) {
496 OS << "lambda at ";
497 Decl->getLocation().print(OS, TheSema.getSourceManager());
498 return;
499 }
500 }
501 OS << "unnamed " << Decl->getKindName();
502 return;
503 }
504
505 assert(NamedCtx && "NamedCtx cannot be null");
506
507 if (const auto *Decl = dyn_cast<ParmVarDecl>(NamedTemplate)) {
508 OS << "unnamed function parameter " << Decl->getFunctionScopeIndex()
509 << " ";
510 if (Decl->getFunctionScopeDepth() > 0)
511 OS << "(at depth " << Decl->getFunctionScopeDepth() << ") ";
512 OS << "of ";
513 NamedCtx->getNameForDiagnostic(OS, TheSema.getLangOpts(), true);
514 return;
515 }
516
517 if (const auto *Decl = dyn_cast<TemplateTypeParmDecl>(NamedTemplate)) {
518 if (const Type *Ty = Decl->getTypeForDecl()) {
519 if (const auto *TTPT = dyn_cast_or_null<TemplateTypeParmType>(Ty)) {
520 OS << "unnamed template type parameter " << TTPT->getIndex() << " ";
521 if (TTPT->getDepth() > 0)
522 OS << "(at depth " << TTPT->getDepth() << ") ";
523 OS << "of ";
524 NamedCtx->getNameForDiagnostic(OS, TheSema.getLangOpts(), true);
525 return;
526 }
527 }
528 }
529
530 if (const auto *Decl = dyn_cast<NonTypeTemplateParmDecl>(NamedTemplate)) {
531 OS << "unnamed template non-type parameter " << Decl->getIndex() << " ";
532 if (Decl->getDepth() > 0)
533 OS << "(at depth " << Decl->getDepth() << ") ";
534 OS << "of ";
535 NamedCtx->getNameForDiagnostic(OS, TheSema.getLangOpts(), true);
536 return;
537 }
538
539 if (const auto *Decl = dyn_cast<TemplateTemplateParmDecl>(NamedTemplate)) {
540 OS << "unnamed template template parameter " << Decl->getIndex() << " ";
541 if (Decl->getDepth() > 0)
542 OS << "(at depth " << Decl->getDepth() << ") ";
543 OS << "of ";
544 NamedCtx->getNameForDiagnostic(OS, TheSema.getLangOpts(), true);
545 return;
546 }
547
548 llvm_unreachable("Failed to retrieve a name for this entry!");
549 OS << "unnamed identifier";
550 }
551
552 template <bool BeginInstantiation>
553 static TemplightEntry getTemplightEntry(const Sema &TheSema,
554 const CodeSynthesisContext &Inst) {
555 TemplightEntry Entry;
556 Entry.Kind = toString(Inst.Kind);
557 Entry.Event = BeginInstantiation ? "Begin" : "End";
558 llvm::raw_string_ostream OS(Entry.Name);
559 printEntryName(TheSema, Inst.Entity, OS);
560 const PresumedLoc DefLoc =
561 TheSema.getSourceManager().getPresumedLoc(Inst.Entity->getLocation());
562 if (!DefLoc.isInvalid())
563 Entry.DefinitionLocation = std::string(DefLoc.getFilename()) + ":" +
564 std::to_string(DefLoc.getLine()) + ":" +
565 std::to_string(DefLoc.getColumn());
566 const PresumedLoc PoiLoc =
567 TheSema.getSourceManager().getPresumedLoc(Inst.PointOfInstantiation);
568 if (!PoiLoc.isInvalid()) {
569 Entry.PointOfInstantiation = std::string(PoiLoc.getFilename()) + ":" +
570 std::to_string(PoiLoc.getLine()) + ":" +
571 std::to_string(PoiLoc.getColumn());
572 }
573 return Entry;
574 }
575};
576} // namespace
577
578std::unique_ptr<ASTConsumer>
580 return std::make_unique<ASTConsumer>();
581}
582
585
586 // This part is normally done by ASTFrontEndAction, but needs to happen
587 // before Templight observers can be created
588 // FIXME: Move the truncation aspect of this into Sema, we delayed this till
589 // here so the source manager would be initialized.
590 EnsureSemaIsCreated(CI, *this);
591
592 CI.getSema().TemplateInstCallbacks.push_back(
593 std::make_unique<DefaultTemplateInstCallback>());
595}
596
597namespace {
598 /// AST reader listener that dumps module information for a module
599 /// file.
600 class DumpModuleInfoListener : public ASTReaderListener {
601 llvm::raw_ostream &Out;
602
603 public:
604 DumpModuleInfoListener(llvm::raw_ostream &Out) : Out(Out) { }
605
606#define DUMP_BOOLEAN(Value, Text) \
607 Out.indent(4) << Text << ": " << (Value? "Yes" : "No") << "\n"
608
609 bool ReadFullVersionInformation(StringRef FullVersion) override {
610 Out.indent(2)
611 << "Generated by "
612 << (FullVersion == getClangFullRepositoryVersion()? "this"
613 : "a different")
614 << " Clang: " << FullVersion << "\n";
616 }
617
618 void ReadModuleName(StringRef ModuleName) override {
619 Out.indent(2) << "Module name: " << ModuleName << "\n";
620 }
621 void ReadModuleMapFile(StringRef ModuleMapPath) override {
622 Out.indent(2) << "Module map file: " << ModuleMapPath << "\n";
623 }
624
625 bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain,
626 bool AllowCompatibleDifferences) override {
627 Out.indent(2) << "Language options:\n";
628#define LANGOPT(Name, Bits, Default, Description) \
629 DUMP_BOOLEAN(LangOpts.Name, Description);
630#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
631 Out.indent(4) << Description << ": " \
632 << static_cast<unsigned>(LangOpts.get##Name()) << "\n";
633#define VALUE_LANGOPT(Name, Bits, Default, Description) \
634 Out.indent(4) << Description << ": " << LangOpts.Name << "\n";
635#define BENIGN_LANGOPT(Name, Bits, Default, Description)
636#define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
637#include "clang/Basic/LangOptions.def"
638
639 if (!LangOpts.ModuleFeatures.empty()) {
640 Out.indent(4) << "Module features:\n";
641 for (StringRef Feature : LangOpts.ModuleFeatures)
642 Out.indent(6) << Feature << "\n";
643 }
644
645 return false;
646 }
647
648 bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain,
649 bool AllowCompatibleDifferences) override {
650 Out.indent(2) << "Target options:\n";
651 Out.indent(4) << " Triple: " << TargetOpts.Triple << "\n";
652 Out.indent(4) << " CPU: " << TargetOpts.CPU << "\n";
653 Out.indent(4) << " TuneCPU: " << TargetOpts.TuneCPU << "\n";
654 Out.indent(4) << " ABI: " << TargetOpts.ABI << "\n";
655
656 if (!TargetOpts.FeaturesAsWritten.empty()) {
657 Out.indent(4) << "Target features:\n";
658 for (unsigned I = 0, N = TargetOpts.FeaturesAsWritten.size();
659 I != N; ++I) {
660 Out.indent(6) << TargetOpts.FeaturesAsWritten[I] << "\n";
661 }
662 }
663
664 return false;
665 }
666
667 bool ReadDiagnosticOptions(IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts,
668 bool Complain) override {
669 Out.indent(2) << "Diagnostic options:\n";
670#define DIAGOPT(Name, Bits, Default) DUMP_BOOLEAN(DiagOpts->Name, #Name);
671#define ENUM_DIAGOPT(Name, Type, Bits, Default) \
672 Out.indent(4) << #Name << ": " << DiagOpts->get##Name() << "\n";
673#define VALUE_DIAGOPT(Name, Bits, Default) \
674 Out.indent(4) << #Name << ": " << DiagOpts->Name << "\n";
675#include "clang/Basic/DiagnosticOptions.def"
676
677 Out.indent(4) << "Diagnostic flags:\n";
678 for (const std::string &Warning : DiagOpts->Warnings)
679 Out.indent(6) << "-W" << Warning << "\n";
680 for (const std::string &Remark : DiagOpts->Remarks)
681 Out.indent(6) << "-R" << Remark << "\n";
682
683 return false;
684 }
685
686 bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
687 StringRef SpecificModuleCachePath,
688 bool Complain) override {
689 Out.indent(2) << "Header search options:\n";
690 Out.indent(4) << "System root [-isysroot=]: '" << HSOpts.Sysroot << "'\n";
691 Out.indent(4) << "Resource dir [ -resource-dir=]: '" << HSOpts.ResourceDir << "'\n";
692 Out.indent(4) << "Module Cache: '" << SpecificModuleCachePath << "'\n";
694 "Use builtin include directories [-nobuiltininc]");
696 "Use standard system include directories [-nostdinc]");
698 "Use standard C++ include directories [-nostdinc++]");
699 DUMP_BOOLEAN(HSOpts.UseLibcxx,
700 "Use libc++ (rather than libstdc++) [-stdlib=]");
701 return false;
702 }
703
704 bool ReadHeaderSearchPaths(const HeaderSearchOptions &HSOpts,
705 bool Complain) override {
706 Out.indent(2) << "Header search paths:\n";
707 Out.indent(4) << "User entries:\n";
708 for (const auto &Entry : HSOpts.UserEntries)
709 Out.indent(6) << Entry.Path << "\n";
710 Out.indent(4) << "System header prefixes:\n";
711 for (const auto &Prefix : HSOpts.SystemHeaderPrefixes)
712 Out.indent(6) << Prefix.Prefix << "\n";
713 Out.indent(4) << "VFS overlay files:\n";
714 for (const auto &Overlay : HSOpts.VFSOverlayFiles)
715 Out.indent(6) << Overlay << "\n";
716 return false;
717 }
718
719 bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
720 bool ReadMacros, bool Complain,
721 std::string &SuggestedPredefines) override {
722 Out.indent(2) << "Preprocessor options:\n";
724 "Uses compiler/target-specific predefines [-undef]");
726 "Uses detailed preprocessing record (for indexing)");
727
728 if (ReadMacros) {
729 Out.indent(4) << "Predefined macros:\n";
730 }
731
732 for (std::vector<std::pair<std::string, bool/*isUndef*/> >::const_iterator
733 I = PPOpts.Macros.begin(), IEnd = PPOpts.Macros.end();
734 I != IEnd; ++I) {
735 Out.indent(6);
736 if (I->second)
737 Out << "-U";
738 else
739 Out << "-D";
740 Out << I->first << "\n";
741 }
742 return false;
743 }
744
745 /// Indicates that a particular module file extension has been read.
746 void readModuleFileExtension(
747 const ModuleFileExtensionMetadata &Metadata) override {
748 Out.indent(2) << "Module file extension '"
749 << Metadata.BlockName << "' " << Metadata.MajorVersion
750 << "." << Metadata.MinorVersion;
751 if (!Metadata.UserInfo.empty()) {
752 Out << ": ";
753 Out.write_escaped(Metadata.UserInfo);
754 }
755
756 Out << "\n";
757 }
758
759 /// Tells the \c ASTReaderListener that we want to receive the
760 /// input files of the AST file via \c visitInputFile.
761 bool needsInputFileVisitation() override { return true; }
762
763 /// Tells the \c ASTReaderListener that we want to receive the
764 /// input files of the AST file via \c visitInputFile.
765 bool needsSystemInputFileVisitation() override { return true; }
766
767 /// Indicates that the AST file contains particular input file.
768 ///
769 /// \returns true to continue receiving the next input file, false to stop.
770 bool visitInputFile(StringRef Filename, bool isSystem,
771 bool isOverridden, bool isExplicitModule) override {
772
773 Out.indent(2) << "Input file: " << Filename;
774
775 if (isSystem || isOverridden || isExplicitModule) {
776 Out << " [";
777 if (isSystem) {
778 Out << "System";
779 if (isOverridden || isExplicitModule)
780 Out << ", ";
781 }
782 if (isOverridden) {
783 Out << "Overridden";
784 if (isExplicitModule)
785 Out << ", ";
786 }
787 if (isExplicitModule)
788 Out << "ExplicitModule";
789
790 Out << "]";
791 }
792
793 Out << "\n";
794
795 return true;
796 }
797
798 /// Returns true if this \c ASTReaderListener wants to receive the
799 /// imports of the AST file via \c visitImport, false otherwise.
800 bool needsImportVisitation() const override { return true; }
801
802 /// If needsImportVisitation returns \c true, this is called for each
803 /// AST file imported by this AST file.
804 void visitImport(StringRef ModuleName, StringRef Filename) override {
805 Out.indent(2) << "Imports module '" << ModuleName
806 << "': " << Filename.str() << "\n";
807 }
808#undef DUMP_BOOLEAN
809 };
810}
811
813 // The Object file reader also supports raw ast files and there is no point in
814 // being strict about the module file format in -module-file-info mode.
816 return true;
817}
818
819static StringRef ModuleKindName(Module::ModuleKind MK) {
820 switch (MK) {
822 return "Module Map Module";
824 return "Interface Unit";
826 return "Implementation Unit";
828 return "Partition Interface";
830 return "Partition Implementation";
832 return "Header Unit";
834 return "Global Module Fragment";
836 return "Implicit Module Fragment";
838 return "Private Module Fragment";
839 }
840 llvm_unreachable("unknown module kind!");
841}
842
845
846 // Don't process files of type other than module to avoid crash
847 if (!isCurrentFileAST()) {
848 CI.getDiagnostics().Report(diag::err_file_is_not_module)
849 << getCurrentFile();
850 return;
851 }
852
853 // Set up the output file.
854 StringRef OutputFileName = CI.getFrontendOpts().OutputFile;
855 if (!OutputFileName.empty() && OutputFileName != "-") {
856 std::error_code EC;
857 OutputStream.reset(new llvm::raw_fd_ostream(
858 OutputFileName.str(), EC, llvm::sys::fs::OF_TextWithCRLF));
859 }
860 llvm::raw_ostream &Out = OutputStream ? *OutputStream : llvm::outs();
861
862 Out << "Information for module file '" << getCurrentFile() << "':\n";
863 auto &FileMgr = CI.getFileManager();
864 auto Buffer = FileMgr.getBufferForFile(getCurrentFile());
865 StringRef Magic = (*Buffer)->getMemBufferRef().getBuffer();
866 bool IsRaw = Magic.starts_with("CPCH");
867 Out << " Module format: " << (IsRaw ? "raw" : "obj") << "\n";
868
869 Preprocessor &PP = CI.getPreprocessor();
870 DumpModuleInfoListener Listener(Out);
871 HeaderSearchOptions &HSOpts = PP.getHeaderSearchInfo().getHeaderSearchOpts();
872
873 // The FrontendAction::BeginSourceFile () method loads the AST so that much
874 // of the information is already available and modules should have been
875 // loaded.
876
878 if (LO.CPlusPlusModules && !LO.CurrentModule.empty()) {
880 unsigned SubModuleCount = R->getTotalNumSubmodules();
882 Out << " ====== C++20 Module structure ======\n";
883
884 if (MF.ModuleName != LO.CurrentModule)
885 Out << " Mismatched module names : " << MF.ModuleName << " and "
886 << LO.CurrentModule << "\n";
887
888 struct SubModInfo {
889 unsigned Idx;
890 Module *Mod;
892 std::string &Name;
893 bool Seen;
894 };
895 std::map<std::string, SubModInfo> SubModMap;
896 auto PrintSubMapEntry = [&](std::string Name, Module::ModuleKind Kind) {
897 Out << " " << ModuleKindName(Kind) << " '" << Name << "'";
898 auto I = SubModMap.find(Name);
899 if (I == SubModMap.end())
900 Out << " was not found in the sub modules!\n";
901 else {
902 I->second.Seen = true;
903 Out << " is at index #" << I->second.Idx << "\n";
904 }
905 };
906 Module *Primary = nullptr;
907 for (unsigned Idx = 0; Idx <= SubModuleCount; ++Idx) {
908 Module *M = R->getModule(Idx);
909 if (!M)
910 continue;
911 if (M->Name == LO.CurrentModule) {
912 Primary = M;
913 Out << " " << ModuleKindName(M->Kind) << " '" << LO.CurrentModule
914 << "' is the Primary Module at index #" << Idx << "\n";
915 SubModMap.insert({M->Name, {Idx, M, M->Kind, M->Name, true}});
916 } else
917 SubModMap.insert({M->Name, {Idx, M, M->Kind, M->Name, false}});
918 }
919 if (Primary) {
920 if (!Primary->submodules().empty())
921 Out << " Sub Modules:\n";
922 for (auto *MI : Primary->submodules()) {
923 PrintSubMapEntry(MI->Name, MI->Kind);
924 }
925 if (!Primary->Imports.empty())
926 Out << " Imports:\n";
927 for (auto *IMP : Primary->Imports) {
928 PrintSubMapEntry(IMP->Name, IMP->Kind);
929 }
930 if (!Primary->Exports.empty())
931 Out << " Exports:\n";
932 for (unsigned MN = 0, N = Primary->Exports.size(); MN != N; ++MN) {
933 if (Module *M = Primary->Exports[MN].getPointer()) {
934 PrintSubMapEntry(M->Name, M->Kind);
935 }
936 }
937 }
938
939 // Emit the macro definitions in the module file so that we can know how
940 // much definitions in the module file quickly.
941 // TODO: Emit the macro definition bodies completely.
942 if (auto FilteredMacros = llvm::make_filter_range(
943 R->getPreprocessor().macros(),
944 [](const auto &Macro) { return Macro.first->isFromAST(); });
945 !FilteredMacros.empty()) {
946 Out << " Macro Definitions:\n";
947 for (/*<IdentifierInfo *, MacroState> pair*/ const auto &Macro :
948 FilteredMacros)
949 Out << " " << Macro.first->getName() << "\n";
950 }
951
952 // Now let's print out any modules we did not see as part of the Primary.
953 for (const auto &SM : SubModMap) {
954 if (!SM.second.Seen && SM.second.Mod) {
955 Out << " " << ModuleKindName(SM.second.Kind) << " '" << SM.first
956 << "' at index #" << SM.second.Idx
957 << " has no direct reference in the Primary\n";
958 }
959 }
960 Out << " ====== ======\n";
961 }
962
963 // The reminder of the output is produced from the listener as the AST
964 // FileCcontrolBlock is (re-)parsed.
966 getCurrentFile(), FileMgr, CI.getModuleCache(),
968 /*FindModuleFileExtensions=*/true, Listener,
970}
971
972//===----------------------------------------------------------------------===//
973// Preprocessor Actions
974//===----------------------------------------------------------------------===//
975
979
980 // Start lexing the specified input file.
981 llvm::MemoryBufferRef FromFile = SM.getBufferOrFake(SM.getMainFileID());
982 Lexer RawLex(SM.getMainFileID(), FromFile, SM, PP.getLangOpts());
983 RawLex.SetKeepWhitespaceMode(true);
984
985 Token RawTok;
986 RawLex.LexFromRawLexer(RawTok);
987 while (RawTok.isNot(tok::eof)) {
988 PP.DumpToken(RawTok, true);
989 llvm::errs() << "\n";
990 RawLex.LexFromRawLexer(RawTok);
991 }
992}
993
996 // Start preprocessing the specified input file.
997 Token Tok;
999 do {
1000 PP.Lex(Tok);
1001 PP.DumpToken(Tok, true);
1002 llvm::errs() << "\n";
1003 } while (Tok.isNot(tok::eof));
1004}
1005
1008
1009 // Ignore unknown pragmas.
1010 PP.IgnorePragmas();
1011
1012 Token Tok;
1013 // Start parsing the specified input file.
1015 do {
1016 PP.Lex(Tok);
1017 } while (Tok.isNot(tok::eof));
1018}
1019
1022 // Output file may need to be set to 'Binary', to avoid converting Unix style
1023 // line feeds (<LF>) to Microsoft style line feeds (<CR><LF>) on Windows.
1024 //
1025 // Look to see what type of line endings the file uses. If there's a
1026 // CRLF, then we won't open the file up in binary mode. If there is
1027 // just an LF or CR, then we will open the file up in binary mode.
1028 // In this fashion, the output format should match the input format, unless
1029 // the input format has inconsistent line endings.
1030 //
1031 // This should be a relatively fast operation since most files won't have
1032 // all of their source code on a single line. However, that is still a
1033 // concern, so if we scan for too long, we'll just assume the file should
1034 // be opened in binary mode.
1035
1036 bool BinaryMode = false;
1037 if (llvm::Triple(LLVM_HOST_TRIPLE).isOSWindows()) {
1038 BinaryMode = true;
1039 const SourceManager &SM = CI.getSourceManager();
1040 if (std::optional<llvm::MemoryBufferRef> Buffer =
1041 SM.getBufferOrNone(SM.getMainFileID())) {
1042 const char *cur = Buffer->getBufferStart();
1043 const char *end = Buffer->getBufferEnd();
1044 const char *next = (cur != end) ? cur + 1 : end;
1045
1046 // Limit ourselves to only scanning 256 characters into the source
1047 // file. This is mostly a check in case the file has no
1048 // newlines whatsoever.
1049 if (end - cur > 256)
1050 end = cur + 256;
1051
1052 while (next < end) {
1053 if (*cur == 0x0D) { // CR
1054 if (*next == 0x0A) // CRLF
1055 BinaryMode = false;
1056
1057 break;
1058 } else if (*cur == 0x0A) // LF
1059 break;
1060
1061 ++cur;
1062 ++next;
1063 }
1064 }
1065 }
1066
1067 std::unique_ptr<raw_ostream> OS =
1069 if (!OS) return;
1070
1071 // If we're preprocessing a module map, start by dumping the contents of the
1072 // module itself before switching to the input buffer.
1073 auto &Input = getCurrentInput();
1074 if (Input.getKind().getFormat() == InputKind::ModuleMap) {
1075 if (Input.isFile()) {
1076 (*OS) << "# 1 \"";
1077 OS->write_escaped(Input.getFile());
1078 (*OS) << "\"\n";
1079 }
1080 getCurrentModule()->print(*OS);
1081 (*OS) << "#pragma clang module contents\n";
1082 }
1083
1086}
1087
1089 switch (getCurrentFileKind().getLanguage()) {
1090 case Language::C:
1091 case Language::CXX:
1092 case Language::ObjC:
1093 case Language::ObjCXX:
1094 case Language::OpenCL:
1096 case Language::CUDA:
1097 case Language::HIP:
1098 case Language::HLSL:
1099 case Language::CIR:
1100 break;
1101
1102 case Language::Unknown:
1103 case Language::Asm:
1104 case Language::LLVM_IR:
1106 // We can't do anything with these.
1107 return;
1108 }
1109
1110 // We don't expect to find any #include directives in a preprocessed input.
1111 if (getCurrentFileKind().isPreprocessed())
1112 return;
1113
1115 auto Buffer = CI.getFileManager().getBufferForFile(getCurrentFile());
1116 if (Buffer) {
1117 unsigned Preamble =
1118 Lexer::ComputePreamble((*Buffer)->getBuffer(), CI.getLangOpts()).Size;
1119 llvm::outs().write((*Buffer)->getBufferStart(), Preamble);
1120 }
1121}
1122
1123void DumpCompilerOptionsAction::ExecuteAction() {
1125 std::unique_ptr<raw_ostream> OSP =
1127 if (!OSP)
1128 return;
1129
1130 raw_ostream &OS = *OSP;
1131 const Preprocessor &PP = CI.getPreprocessor();
1132 const LangOptions &LangOpts = PP.getLangOpts();
1133
1134 // FIXME: Rather than manually format the JSON (which is awkward due to
1135 // needing to remove trailing commas), this should make use of a JSON library.
1136 // FIXME: Instead of printing enums as an integral value and specifying the
1137 // type as a separate field, use introspection to print the enumerator.
1138
1139 OS << "{\n";
1140 OS << "\n\"features\" : [\n";
1141 {
1143#define FEATURE(Name, Predicate) \
1144 ("\t{\"" #Name "\" : " + llvm::Twine(Predicate ? "true" : "false") + "},\n") \
1145 .toVector(Str);
1146#include "clang/Basic/Features.def"
1147#undef FEATURE
1148 // Remove the newline and comma from the last entry to ensure this remains
1149 // valid JSON.
1150 OS << Str.substr(0, Str.size() - 2);
1151 }
1152 OS << "\n],\n";
1153
1154 OS << "\n\"extensions\" : [\n";
1155 {
1157#define EXTENSION(Name, Predicate) \
1158 ("\t{\"" #Name "\" : " + llvm::Twine(Predicate ? "true" : "false") + "},\n") \
1159 .toVector(Str);
1160#include "clang/Basic/Features.def"
1161#undef EXTENSION
1162 // Remove the newline and comma from the last entry to ensure this remains
1163 // valid JSON.
1164 OS << Str.substr(0, Str.size() - 2);
1165 }
1166 OS << "\n]\n";
1167
1168 OS << "}";
1169}
1170
1174 llvm::MemoryBufferRef FromFile = SM.getBufferOrFake(SM.getMainFileID());
1175
1179 FromFile.getBuffer(), Tokens, Directives, &CI.getDiagnostics(),
1180 SM.getLocForStartOfFile(SM.getMainFileID()))) {
1181 assert(CI.getDiagnostics().hasErrorOccurred() &&
1182 "no errors reported for failure");
1183
1184 // Preprocess the source when verifying the diagnostics to capture the
1185 // 'expected' comments.
1186 if (CI.getDiagnosticOpts().VerifyDiagnostics) {
1187 // Make sure we don't emit new diagnostics!
1191 Token Tok;
1192 do {
1193 PP.Lex(Tok);
1194 } while (Tok.isNot(tok::eof));
1195 }
1196 return;
1197 }
1198 printDependencyDirectivesAsSource(FromFile.getBuffer(), Directives,
1199 llvm::outs());
1200}
1201
1202void GetDependenciesByModuleNameAction::ExecuteAction() {
1204 Preprocessor &PP = CI.getPreprocessor();
1206 FileID MainFileID = SM.getMainFileID();
1207 SourceLocation FileStart = SM.getLocForStartOfFile(MainFileID);
1209 IdentifierInfo *ModuleID = PP.getIdentifierInfo(ModuleName);
1210 Path.push_back(std::make_pair(ModuleID, FileStart));
1211 auto ModResult = CI.loadModule(FileStart, Path, Module::Hidden, false);
1212 PPCallbacks *CB = PP.getPPCallbacks();
1213 CB->moduleImport(SourceLocation(), Path, ModResult);
1214}
#define SM(sm)
Definition: Cuda.cpp:83
enum clang::sema::@1650::IndirectLocalPathEntry::EntryKind Kind
IndirectLocalPath & Path
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:2989
#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:712
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:1767
@ ARR_ConfigurationMismatch
The client can handle an AST file that cannot load because it's compiled configuration doesn't match ...
Definition: ASTReader.h:1622
unsigned getTotalNumSubmodules() const
Returns the number of submodules known.
Definition: ASTReader.h:1863
Module * getModule(unsigned ID) override
Retrieve the module that corresponds to the given module ID.
Definition: ASTReader.cpp:9066
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:5395
Preprocessor & getPreprocessor() const
Retrieve the preprocessor.
Definition: ASTReader.h:1771
const LangOptions & getLangOpts() const
Definition: ASTUnit.h:464
IntrusiveRefCntPtr< ASTReader > getASTReader() const
Definition: ASTUnit.cpp:762
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:86
static Decl * castFromDeclContext(const DeclContext *)
Definition: DeclBase.cpp:1042
SourceLocation getLocation() const
Definition: DeclBase.h:445
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, std::optional< int64_t > MaybeLimit=std::nullopt)
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...
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.
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.
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:249
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:105
@ CMK_ModuleInterface
Compiling a C++ modules interface unit.
Definition: LangOptions.h:108
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:461
std::string CurrentModule
The name of the current module, of which the main source file is a part.
Definition: LangOptions.h:516
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:522
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:415
@ Hidden
All of the names in this module are hidden.
Definition: Module.h:389
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:402
std::string Name
The name of this module.
Definition: Module.h:108
llvm::iterator_range< submodule_iterator > submodules()
Definition: Module.h:783
@ 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:1811
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:36
virtual void moduleImport(SourceLocation ImportLoc, ModuleIdPath Path, const Module *Imported)
Callback invoked whenever there was an explicit module-import syntax.
Definition: PPCallbacks.h:209
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:137
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:2196
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:535
ASTContext & Context
Definition: Sema.h:1002
const LangOptions & getLangOpts() const
Definition: Sema.h:593
std::vector< std::unique_ptr< TemplateInstantiationCallback > > TemplateInstCallbacks
The template instantiation callbacks to trace or track instantiations (objects can be chained).
Definition: Sema.h:13170
SourceManager & getSourceManager() const
Definition: Sema.h:598
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:1829
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:12652
static void mapping(IO &io, TemplightEntry &fields)