clang 20.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/Config/llvm-config.h" // for LLVM_HOST_TRIPLE
30#include "llvm/Support/ErrorHandling.h"
31#include "llvm/Support/FileSystem.h"
32#include "llvm/Support/MemoryBuffer.h"
33#include "llvm/Support/Path.h"
34#include "llvm/Support/YAMLTraits.h"
35#include "llvm/Support/raw_ostream.h"
36#include <memory>
37#include <optional>
38#include <system_error>
39
40using namespace clang;
41
42namespace {
43CodeCompleteConsumer *GetCodeCompletionConsumer(CompilerInstance &CI) {
45 : nullptr;
46}
47
48void EnsureSemaIsCreated(CompilerInstance &CI, FrontendAction &Action) {
49 if (Action.hasCodeCompletionSupport() &&
52
53 if (!CI.hasSema())
55 GetCodeCompletionConsumer(CI));
56}
57} // namespace
58
59//===----------------------------------------------------------------------===//
60// Custom Actions
61//===----------------------------------------------------------------------===//
62
63std::unique_ptr<ASTConsumer>
64InitOnlyAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
65 return std::make_unique<ASTConsumer>();
66}
67
68void InitOnlyAction::ExecuteAction() {
69}
70
71// Basically PreprocessOnlyAction::ExecuteAction.
72void ReadPCHAndPreprocessAction::ExecuteAction() {
74
75 // Ignore unknown pragmas.
76 PP.IgnorePragmas();
77
78 Token Tok;
79 // Start parsing the specified input file.
81 do {
82 PP.Lex(Tok);
83 } while (Tok.isNot(tok::eof));
84}
85
86std::unique_ptr<ASTConsumer>
87ReadPCHAndPreprocessAction::CreateASTConsumer(CompilerInstance &CI,
88 StringRef InFile) {
89 return std::make_unique<ASTConsumer>();
90}
91
92//===----------------------------------------------------------------------===//
93// AST Consumer Actions
94//===----------------------------------------------------------------------===//
95
96std::unique_ptr<ASTConsumer>
98 if (std::unique_ptr<raw_ostream> OS =
99 CI.createDefaultOutputFile(false, InFile))
100 return CreateASTPrinter(std::move(OS), CI.getFrontendOpts().ASTDumpFilter);
101 return nullptr;
102}
103
104std::unique_ptr<ASTConsumer>
106 const FrontendOptions &Opts = CI.getFrontendOpts();
107 return CreateASTDumper(nullptr /*Dump to stdout.*/, Opts.ASTDumpFilter,
108 Opts.ASTDumpDecls, Opts.ASTDumpAll,
110 Opts.ASTDumpFormat);
111}
112
113std::unique_ptr<ASTConsumer>
116}
117
118std::unique_ptr<ASTConsumer>
120 return CreateASTViewer();
121}
122
123std::unique_ptr<ASTConsumer>
125 std::string Sysroot;
126 if (!ComputeASTConsumerArguments(CI, /*ref*/ Sysroot))
127 return nullptr;
128
129 std::string OutputFile;
130 std::unique_ptr<raw_pwrite_stream> OS =
131 CreateOutputFile(CI, InFile, /*ref*/ OutputFile);
132 if (!OS)
133 return nullptr;
134
136 Sysroot.clear();
137
138 const auto &FrontendOpts = CI.getFrontendOpts();
139 auto Buffer = std::make_shared<PCHBuffer>();
140 std::vector<std::unique_ptr<ASTConsumer>> Consumers;
141 Consumers.push_back(std::make_unique<PCHGenerator>(
142 CI.getPreprocessor(), CI.getModuleCache(), OutputFile, Sysroot, Buffer,
143 FrontendOpts.ModuleFileExtensions,
145 FrontendOpts.IncludeTimestamps, FrontendOpts.BuildingImplicitModule,
146 +CI.getLangOpts().CacheGeneratedPCH));
147 Consumers.push_back(CI.getPCHContainerWriter().CreatePCHContainerGenerator(
148 CI, std::string(InFile), OutputFile, std::move(OS), Buffer));
149
150 return std::make_unique<MultiplexConsumer>(std::move(Consumers));
151}
152
154 std::string &Sysroot) {
155 Sysroot = CI.getHeaderSearchOpts().Sysroot;
156 if (CI.getFrontendOpts().RelocatablePCH && Sysroot.empty()) {
157 CI.getDiagnostics().Report(diag::err_relocatable_without_isysroot);
158 return false;
159 }
160
161 return true;
162}
163
164std::unique_ptr<llvm::raw_pwrite_stream>
166 std::string &OutputFile) {
167 // Because this is exposed via libclang we must disable RemoveFileOnSignal.
168 std::unique_ptr<raw_pwrite_stream> OS = CI.createDefaultOutputFile(
169 /*Binary=*/true, InFile, /*Extension=*/"", /*RemoveFileOnSignal=*/false);
170 if (!OS)
171 return nullptr;
172
173 OutputFile = CI.getFrontendOpts().OutputFile;
174 return OS;
175}
176
178 if (getCompilerInstance().getPreprocessorOpts().AllowPCHWithCompilerErrors)
179 return false;
181}
182
184 CI.getLangOpts().CompilingPCH = true;
185 return true;
186}
187
188std::vector<std::unique_ptr<ASTConsumer>>
190 StringRef InFile) {
191 std::unique_ptr<raw_pwrite_stream> OS = CreateOutputFile(CI, InFile);
192 if (!OS)
193 return {};
194
195 std::string OutputFile = CI.getFrontendOpts().OutputFile;
196 std::string Sysroot;
197
198 auto Buffer = std::make_shared<PCHBuffer>();
199 std::vector<std::unique_ptr<ASTConsumer>> Consumers;
200
201 Consumers.push_back(std::make_unique<PCHGenerator>(
202 CI.getPreprocessor(), CI.getModuleCache(), OutputFile, Sysroot, Buffer,
204 /*AllowASTWithErrors=*/
206 /*IncludeTimestamps=*/
209 /*BuildingImplicitModule=*/+CI.getFrontendOpts().BuildingImplicitModule,
210 /*ShouldCacheASTInMemory=*/
212 Consumers.push_back(CI.getPCHContainerWriter().CreatePCHContainerGenerator(
213 CI, std::string(InFile), OutputFile, std::move(OS), Buffer));
214 return Consumers;
215}
216
217std::unique_ptr<ASTConsumer>
219 StringRef InFile) {
220 std::vector<std::unique_ptr<ASTConsumer>> Consumers =
221 CreateMultiplexConsumer(CI, InFile);
222 if (Consumers.empty())
223 return nullptr;
224
225 return std::make_unique<MultiplexConsumer>(std::move(Consumers));
226}
227
231}
232
233bool GenerateModuleFromModuleMapAction::BeginSourceFileAction(
234 CompilerInstance &CI) {
235 if (!CI.getLangOpts().Modules) {
236 CI.getDiagnostics().Report(diag::err_module_build_requires_fmodules);
237 return false;
238 }
239
241}
242
243std::unique_ptr<raw_pwrite_stream>
244GenerateModuleFromModuleMapAction::CreateOutputFile(CompilerInstance &CI,
245 StringRef InFile) {
246 // If no output file was provided, figure out where this module would go
247 // in the module cache.
248 if (CI.getFrontendOpts().OutputFile.empty()) {
249 StringRef ModuleMapFile = CI.getFrontendOpts().OriginalModuleMap;
250 if (ModuleMapFile.empty())
251 ModuleMapFile = InFile;
252
256 ModuleMapFile);
257 }
258
259 // Because this is exposed via libclang we must disable RemoveFileOnSignal.
260 return CI.createDefaultOutputFile(/*Binary=*/true, InFile, /*Extension=*/"",
261 /*RemoveFileOnSignal=*/false,
262 /*CreateMissingDirectories=*/true,
263 /*ForceUseTemporary=*/true);
264}
265
267 CompilerInstance &CI) {
268 CI.getLangOpts().setCompilingModule(LangOptions::CMK_ModuleInterface);
269
271}
272
273std::unique_ptr<ASTConsumer>
275 StringRef InFile) {
276 std::vector<std::unique_ptr<ASTConsumer>> Consumers;
277
279 !CI.getFrontendOpts().ModuleOutputPath.empty()) {
280 Consumers.push_back(std::make_unique<ReducedBMIGenerator>(
284 }
285
286 Consumers.push_back(std::make_unique<CXX20ModulesGenerator>(
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 case CodeSynthesisContext::PartialOrderingTTP:
463 return "PartialOrderingTTP";
464 }
465 return "";
466 }
467
468 template <bool BeginInstantiation>
469 static void displayTemplightEntry(llvm::raw_ostream &Out, const Sema &TheSema,
470 const CodeSynthesisContext &Inst) {
471 std::string YAML;
472 {
473 llvm::raw_string_ostream OS(YAML);
474 llvm::yaml::Output YO(OS);
475 TemplightEntry Entry =
476 getTemplightEntry<BeginInstantiation>(TheSema, Inst);
477 llvm::yaml::EmptyContext Context;
478 llvm::yaml::yamlize(YO, Entry, true, Context);
479 }
480 Out << "---" << YAML << "\n";
481 }
482
483 static void printEntryName(const Sema &TheSema, const Decl *Entity,
484 llvm::raw_string_ostream &OS) {
485 auto *NamedTemplate = cast<NamedDecl>(Entity);
486
487 PrintingPolicy Policy = TheSema.Context.getPrintingPolicy();
488 // FIXME: Also ask for FullyQualifiedNames?
489 Policy.SuppressDefaultTemplateArgs = false;
490 NamedTemplate->getNameForDiagnostic(OS, Policy, true);
491
492 if (!OS.str().empty())
493 return;
494
495 Decl *Ctx = Decl::castFromDeclContext(NamedTemplate->getDeclContext());
496 NamedDecl *NamedCtx = dyn_cast_or_null<NamedDecl>(Ctx);
497
498 if (const auto *Decl = dyn_cast<TagDecl>(NamedTemplate)) {
499 if (const auto *R = dyn_cast<RecordDecl>(Decl)) {
500 if (R->isLambda()) {
501 OS << "lambda at ";
502 Decl->getLocation().print(OS, TheSema.getSourceManager());
503 return;
504 }
505 }
506 OS << "unnamed " << Decl->getKindName();
507 return;
508 }
509
510 assert(NamedCtx && "NamedCtx cannot be null");
511
512 if (const auto *Decl = dyn_cast<ParmVarDecl>(NamedTemplate)) {
513 OS << "unnamed function parameter " << Decl->getFunctionScopeIndex()
514 << " ";
515 if (Decl->getFunctionScopeDepth() > 0)
516 OS << "(at depth " << Decl->getFunctionScopeDepth() << ") ";
517 OS << "of ";
518 NamedCtx->getNameForDiagnostic(OS, TheSema.getLangOpts(), true);
519 return;
520 }
521
522 if (const auto *Decl = dyn_cast<TemplateTypeParmDecl>(NamedTemplate)) {
523 if (const Type *Ty = Decl->getTypeForDecl()) {
524 if (const auto *TTPT = dyn_cast_or_null<TemplateTypeParmType>(Ty)) {
525 OS << "unnamed template type parameter " << TTPT->getIndex() << " ";
526 if (TTPT->getDepth() > 0)
527 OS << "(at depth " << TTPT->getDepth() << ") ";
528 OS << "of ";
529 NamedCtx->getNameForDiagnostic(OS, TheSema.getLangOpts(), true);
530 return;
531 }
532 }
533 }
534
535 if (const auto *Decl = dyn_cast<NonTypeTemplateParmDecl>(NamedTemplate)) {
536 OS << "unnamed template non-type parameter " << Decl->getIndex() << " ";
537 if (Decl->getDepth() > 0)
538 OS << "(at depth " << Decl->getDepth() << ") ";
539 OS << "of ";
540 NamedCtx->getNameForDiagnostic(OS, TheSema.getLangOpts(), true);
541 return;
542 }
543
544 if (const auto *Decl = dyn_cast<TemplateTemplateParmDecl>(NamedTemplate)) {
545 OS << "unnamed template template parameter " << Decl->getIndex() << " ";
546 if (Decl->getDepth() > 0)
547 OS << "(at depth " << Decl->getDepth() << ") ";
548 OS << "of ";
549 NamedCtx->getNameForDiagnostic(OS, TheSema.getLangOpts(), true);
550 return;
551 }
552
553 llvm_unreachable("Failed to retrieve a name for this entry!");
554 OS << "unnamed identifier";
555 }
556
557 template <bool BeginInstantiation>
558 static TemplightEntry getTemplightEntry(const Sema &TheSema,
559 const CodeSynthesisContext &Inst) {
560 TemplightEntry Entry;
561 Entry.Kind = toString(Inst.Kind);
562 Entry.Event = BeginInstantiation ? "Begin" : "End";
563 llvm::raw_string_ostream OS(Entry.Name);
564 printEntryName(TheSema, Inst.Entity, OS);
565 const PresumedLoc DefLoc =
566 TheSema.getSourceManager().getPresumedLoc(Inst.Entity->getLocation());
567 if (!DefLoc.isInvalid())
568 Entry.DefinitionLocation = std::string(DefLoc.getFilename()) + ":" +
569 std::to_string(DefLoc.getLine()) + ":" +
570 std::to_string(DefLoc.getColumn());
571 const PresumedLoc PoiLoc =
572 TheSema.getSourceManager().getPresumedLoc(Inst.PointOfInstantiation);
573 if (!PoiLoc.isInvalid()) {
574 Entry.PointOfInstantiation = std::string(PoiLoc.getFilename()) + ":" +
575 std::to_string(PoiLoc.getLine()) + ":" +
576 std::to_string(PoiLoc.getColumn());
577 }
578 return Entry;
579 }
580};
581} // namespace
582
583std::unique_ptr<ASTConsumer>
585 return std::make_unique<ASTConsumer>();
586}
587
590
591 // This part is normally done by ASTFrontEndAction, but needs to happen
592 // before Templight observers can be created
593 // FIXME: Move the truncation aspect of this into Sema, we delayed this till
594 // here so the source manager would be initialized.
595 EnsureSemaIsCreated(CI, *this);
596
597 CI.getSema().TemplateInstCallbacks.push_back(
598 std::make_unique<DefaultTemplateInstCallback>());
600}
601
602namespace {
603 /// AST reader listener that dumps module information for a module
604 /// file.
605 class DumpModuleInfoListener : public ASTReaderListener {
606 llvm::raw_ostream &Out;
607
608 public:
609 DumpModuleInfoListener(llvm::raw_ostream &Out) : Out(Out) { }
610
611#define DUMP_BOOLEAN(Value, Text) \
612 Out.indent(4) << Text << ": " << (Value? "Yes" : "No") << "\n"
613
614 bool ReadFullVersionInformation(StringRef FullVersion) override {
615 Out.indent(2)
616 << "Generated by "
617 << (FullVersion == getClangFullRepositoryVersion()? "this"
618 : "a different")
619 << " Clang: " << FullVersion << "\n";
621 }
622
623 void ReadModuleName(StringRef ModuleName) override {
624 Out.indent(2) << "Module name: " << ModuleName << "\n";
625 }
626 void ReadModuleMapFile(StringRef ModuleMapPath) override {
627 Out.indent(2) << "Module map file: " << ModuleMapPath << "\n";
628 }
629
630 bool ReadLanguageOptions(const LangOptions &LangOpts,
631 StringRef ModuleFilename, bool Complain,
632 bool AllowCompatibleDifferences) override {
633 Out.indent(2) << "Language options:\n";
634#define LANGOPT(Name, Bits, Default, Description) \
635 DUMP_BOOLEAN(LangOpts.Name, Description);
636#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
637 Out.indent(4) << Description << ": " \
638 << static_cast<unsigned>(LangOpts.get##Name()) << "\n";
639#define VALUE_LANGOPT(Name, Bits, Default, Description) \
640 Out.indent(4) << Description << ": " << LangOpts.Name << "\n";
641#define BENIGN_LANGOPT(Name, Bits, Default, Description)
642#define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
643#include "clang/Basic/LangOptions.def"
644
645 if (!LangOpts.ModuleFeatures.empty()) {
646 Out.indent(4) << "Module features:\n";
647 for (StringRef Feature : LangOpts.ModuleFeatures)
648 Out.indent(6) << Feature << "\n";
649 }
650
651 return false;
652 }
653
654 bool ReadTargetOptions(const TargetOptions &TargetOpts,
655 StringRef ModuleFilename, bool Complain,
656 bool AllowCompatibleDifferences) override {
657 Out.indent(2) << "Target options:\n";
658 Out.indent(4) << " Triple: " << TargetOpts.Triple << "\n";
659 Out.indent(4) << " CPU: " << TargetOpts.CPU << "\n";
660 Out.indent(4) << " TuneCPU: " << TargetOpts.TuneCPU << "\n";
661 Out.indent(4) << " ABI: " << TargetOpts.ABI << "\n";
662
663 if (!TargetOpts.FeaturesAsWritten.empty()) {
664 Out.indent(4) << "Target features:\n";
665 for (unsigned I = 0, N = TargetOpts.FeaturesAsWritten.size();
666 I != N; ++I) {
667 Out.indent(6) << TargetOpts.FeaturesAsWritten[I] << "\n";
668 }
669 }
670
671 return false;
672 }
673
674 bool ReadDiagnosticOptions(IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts,
675 StringRef ModuleFilename,
676 bool Complain) override {
677 Out.indent(2) << "Diagnostic options:\n";
678#define DIAGOPT(Name, Bits, Default) DUMP_BOOLEAN(DiagOpts->Name, #Name);
679#define ENUM_DIAGOPT(Name, Type, Bits, Default) \
680 Out.indent(4) << #Name << ": " << DiagOpts->get##Name() << "\n";
681#define VALUE_DIAGOPT(Name, Bits, Default) \
682 Out.indent(4) << #Name << ": " << DiagOpts->Name << "\n";
683#include "clang/Basic/DiagnosticOptions.def"
684
685 Out.indent(4) << "Diagnostic flags:\n";
686 for (const std::string &Warning : DiagOpts->Warnings)
687 Out.indent(6) << "-W" << Warning << "\n";
688 for (const std::string &Remark : DiagOpts->Remarks)
689 Out.indent(6) << "-R" << Remark << "\n";
690
691 return false;
692 }
693
694 bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
695 StringRef ModuleFilename,
696 StringRef SpecificModuleCachePath,
697 bool Complain) override {
698 Out.indent(2) << "Header search options:\n";
699 Out.indent(4) << "System root [-isysroot=]: '" << HSOpts.Sysroot << "'\n";
700 Out.indent(4) << "Resource dir [ -resource-dir=]: '" << HSOpts.ResourceDir << "'\n";
701 Out.indent(4) << "Module Cache: '" << SpecificModuleCachePath << "'\n";
703 "Use builtin include directories [-nobuiltininc]");
705 "Use standard system include directories [-nostdinc]");
707 "Use standard C++ include directories [-nostdinc++]");
708 DUMP_BOOLEAN(HSOpts.UseLibcxx,
709 "Use libc++ (rather than libstdc++) [-stdlib=]");
710 return false;
711 }
712
713 bool ReadHeaderSearchPaths(const HeaderSearchOptions &HSOpts,
714 bool Complain) override {
715 Out.indent(2) << "Header search paths:\n";
716 Out.indent(4) << "User entries:\n";
717 for (const auto &Entry : HSOpts.UserEntries)
718 Out.indent(6) << Entry.Path << "\n";
719 Out.indent(4) << "System header prefixes:\n";
720 for (const auto &Prefix : HSOpts.SystemHeaderPrefixes)
721 Out.indent(6) << Prefix.Prefix << "\n";
722 Out.indent(4) << "VFS overlay files:\n";
723 for (const auto &Overlay : HSOpts.VFSOverlayFiles)
724 Out.indent(6) << Overlay << "\n";
725 return false;
726 }
727
728 bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
729 StringRef ModuleFilename, bool ReadMacros,
730 bool Complain,
731 std::string &SuggestedPredefines) override {
732 Out.indent(2) << "Preprocessor options:\n";
734 "Uses compiler/target-specific predefines [-undef]");
736 "Uses detailed preprocessing record (for indexing)");
737
738 if (ReadMacros) {
739 Out.indent(4) << "Predefined macros:\n";
740 }
741
742 for (std::vector<std::pair<std::string, bool/*isUndef*/> >::const_iterator
743 I = PPOpts.Macros.begin(), IEnd = PPOpts.Macros.end();
744 I != IEnd; ++I) {
745 Out.indent(6);
746 if (I->second)
747 Out << "-U";
748 else
749 Out << "-D";
750 Out << I->first << "\n";
751 }
752 return false;
753 }
754
755 /// Indicates that a particular module file extension has been read.
756 void readModuleFileExtension(
757 const ModuleFileExtensionMetadata &Metadata) override {
758 Out.indent(2) << "Module file extension '"
759 << Metadata.BlockName << "' " << Metadata.MajorVersion
760 << "." << Metadata.MinorVersion;
761 if (!Metadata.UserInfo.empty()) {
762 Out << ": ";
763 Out.write_escaped(Metadata.UserInfo);
764 }
765
766 Out << "\n";
767 }
768
769 /// Tells the \c ASTReaderListener that we want to receive the
770 /// input files of the AST file via \c visitInputFile.
771 bool needsInputFileVisitation() override { return true; }
772
773 /// Tells the \c ASTReaderListener that we want to receive the
774 /// input files of the AST file via \c visitInputFile.
775 bool needsSystemInputFileVisitation() override { return true; }
776
777 /// Indicates that the AST file contains particular input file.
778 ///
779 /// \returns true to continue receiving the next input file, false to stop.
780 bool visitInputFile(StringRef Filename, bool isSystem,
781 bool isOverridden, bool isExplicitModule) override {
782
783 Out.indent(2) << "Input file: " << Filename;
784
785 if (isSystem || isOverridden || isExplicitModule) {
786 Out << " [";
787 if (isSystem) {
788 Out << "System";
789 if (isOverridden || isExplicitModule)
790 Out << ", ";
791 }
792 if (isOverridden) {
793 Out << "Overridden";
794 if (isExplicitModule)
795 Out << ", ";
796 }
797 if (isExplicitModule)
798 Out << "ExplicitModule";
799
800 Out << "]";
801 }
802
803 Out << "\n";
804
805 return true;
806 }
807
808 /// Returns true if this \c ASTReaderListener wants to receive the
809 /// imports of the AST file via \c visitImport, false otherwise.
810 bool needsImportVisitation() const override { return true; }
811
812 /// If needsImportVisitation returns \c true, this is called for each
813 /// AST file imported by this AST file.
814 void visitImport(StringRef ModuleName, StringRef Filename) override {
815 Out.indent(2) << "Imports module '" << ModuleName
816 << "': " << Filename.str() << "\n";
817 }
818#undef DUMP_BOOLEAN
819 };
820}
821
823 // The Object file reader also supports raw ast files and there is no point in
824 // being strict about the module file format in -module-file-info mode.
826 return true;
827}
828
829static StringRef ModuleKindName(Module::ModuleKind MK) {
830 switch (MK) {
832 return "Module Map Module";
834 return "Interface Unit";
836 return "Implementation Unit";
838 return "Partition Interface";
840 return "Partition Implementation";
842 return "Header Unit";
844 return "Global Module Fragment";
846 return "Implicit Module Fragment";
848 return "Private Module Fragment";
849 }
850 llvm_unreachable("unknown module kind!");
851}
852
855
856 // Don't process files of type other than module to avoid crash
857 if (!isCurrentFileAST()) {
858 CI.getDiagnostics().Report(diag::err_file_is_not_module)
859 << getCurrentFile();
860 return;
861 }
862
863 // Set up the output file.
864 StringRef OutputFileName = CI.getFrontendOpts().OutputFile;
865 if (!OutputFileName.empty() && OutputFileName != "-") {
866 std::error_code EC;
867 OutputStream.reset(new llvm::raw_fd_ostream(
868 OutputFileName.str(), EC, llvm::sys::fs::OF_TextWithCRLF));
869 }
870 llvm::raw_ostream &Out = OutputStream ? *OutputStream : llvm::outs();
871
872 Out << "Information for module file '" << getCurrentFile() << "':\n";
873 auto &FileMgr = CI.getFileManager();
874 auto Buffer = FileMgr.getBufferForFile(getCurrentFile());
875 StringRef Magic = (*Buffer)->getMemBufferRef().getBuffer();
876 bool IsRaw = Magic.starts_with("CPCH");
877 Out << " Module format: " << (IsRaw ? "raw" : "obj") << "\n";
878
879 Preprocessor &PP = CI.getPreprocessor();
880 DumpModuleInfoListener Listener(Out);
881 HeaderSearchOptions &HSOpts = PP.getHeaderSearchInfo().getHeaderSearchOpts();
882
883 // The FrontendAction::BeginSourceFile () method loads the AST so that much
884 // of the information is already available and modules should have been
885 // loaded.
886
888 if (LO.CPlusPlusModules && !LO.CurrentModule.empty()) {
890 unsigned SubModuleCount = R->getTotalNumSubmodules();
892 Out << " ====== C++20 Module structure ======\n";
893
894 if (MF.ModuleName != LO.CurrentModule)
895 Out << " Mismatched module names : " << MF.ModuleName << " and "
896 << LO.CurrentModule << "\n";
897
898 struct SubModInfo {
899 unsigned Idx;
900 Module *Mod;
902 std::string &Name;
903 bool Seen;
904 };
905 std::map<std::string, SubModInfo> SubModMap;
906 auto PrintSubMapEntry = [&](std::string Name, Module::ModuleKind Kind) {
907 Out << " " << ModuleKindName(Kind) << " '" << Name << "'";
908 auto I = SubModMap.find(Name);
909 if (I == SubModMap.end())
910 Out << " was not found in the sub modules!\n";
911 else {
912 I->second.Seen = true;
913 Out << " is at index #" << I->second.Idx << "\n";
914 }
915 };
916 Module *Primary = nullptr;
917 for (unsigned Idx = 0; Idx <= SubModuleCount; ++Idx) {
918 Module *M = R->getModule(Idx);
919 if (!M)
920 continue;
921 if (M->Name == LO.CurrentModule) {
922 Primary = M;
923 Out << " " << ModuleKindName(M->Kind) << " '" << LO.CurrentModule
924 << "' is the Primary Module at index #" << Idx << "\n";
925 SubModMap.insert({M->Name, {Idx, M, M->Kind, M->Name, true}});
926 } else
927 SubModMap.insert({M->Name, {Idx, M, M->Kind, M->Name, false}});
928 }
929 if (Primary) {
930 if (!Primary->submodules().empty())
931 Out << " Sub Modules:\n";
932 for (auto *MI : Primary->submodules()) {
933 PrintSubMapEntry(MI->Name, MI->Kind);
934 }
935 if (!Primary->Imports.empty())
936 Out << " Imports:\n";
937 for (auto *IMP : Primary->Imports) {
938 PrintSubMapEntry(IMP->Name, IMP->Kind);
939 }
940 if (!Primary->Exports.empty())
941 Out << " Exports:\n";
942 for (unsigned MN = 0, N = Primary->Exports.size(); MN != N; ++MN) {
943 if (Module *M = Primary->Exports[MN].getPointer()) {
944 PrintSubMapEntry(M->Name, M->Kind);
945 }
946 }
947 }
948
949 // Emit the macro definitions in the module file so that we can know how
950 // much definitions in the module file quickly.
951 // TODO: Emit the macro definition bodies completely.
952 if (auto FilteredMacros = llvm::make_filter_range(
953 R->getPreprocessor().macros(),
954 [](const auto &Macro) { return Macro.first->isFromAST(); });
955 !FilteredMacros.empty()) {
956 Out << " Macro Definitions:\n";
957 for (/*<IdentifierInfo *, MacroState> pair*/ const auto &Macro :
958 FilteredMacros)
959 Out << " " << Macro.first->getName() << "\n";
960 }
961
962 // Now let's print out any modules we did not see as part of the Primary.
963 for (const auto &SM : SubModMap) {
964 if (!SM.second.Seen && SM.second.Mod) {
965 Out << " " << ModuleKindName(SM.second.Kind) << " '" << SM.first
966 << "' at index #" << SM.second.Idx
967 << " has no direct reference in the Primary\n";
968 }
969 }
970 Out << " ====== ======\n";
971 }
972
973 // The reminder of the output is produced from the listener as the AST
974 // FileCcontrolBlock is (re-)parsed.
976 getCurrentFile(), FileMgr, CI.getModuleCache(),
978 /*FindModuleFileExtensions=*/true, Listener,
980}
981
982//===----------------------------------------------------------------------===//
983// Preprocessor Actions
984//===----------------------------------------------------------------------===//
985
989
990 // Start lexing the specified input file.
991 llvm::MemoryBufferRef FromFile = SM.getBufferOrFake(SM.getMainFileID());
992 Lexer RawLex(SM.getMainFileID(), FromFile, SM, PP.getLangOpts());
993 RawLex.SetKeepWhitespaceMode(true);
994
995 Token RawTok;
996 RawLex.LexFromRawLexer(RawTok);
997 while (RawTok.isNot(tok::eof)) {
998 PP.DumpToken(RawTok, true);
999 llvm::errs() << "\n";
1000 RawLex.LexFromRawLexer(RawTok);
1001 }
1002}
1003
1006 // Start preprocessing the specified input file.
1007 Token Tok;
1009 do {
1010 PP.Lex(Tok);
1011 PP.DumpToken(Tok, true);
1012 llvm::errs() << "\n";
1013 } while (Tok.isNot(tok::eof));
1014}
1015
1018
1019 // Ignore unknown pragmas.
1020 PP.IgnorePragmas();
1021
1022 Token Tok;
1023 // Start parsing the specified input file.
1025 do {
1026 PP.Lex(Tok);
1027 } while (Tok.isNot(tok::eof));
1028}
1029
1032 // Output file may need to be set to 'Binary', to avoid converting Unix style
1033 // line feeds (<LF>) to Microsoft style line feeds (<CR><LF>) on Windows.
1034 //
1035 // Look to see what type of line endings the file uses. If there's a
1036 // CRLF, then we won't open the file up in binary mode. If there is
1037 // just an LF or CR, then we will open the file up in binary mode.
1038 // In this fashion, the output format should match the input format, unless
1039 // the input format has inconsistent line endings.
1040 //
1041 // This should be a relatively fast operation since most files won't have
1042 // all of their source code on a single line. However, that is still a
1043 // concern, so if we scan for too long, we'll just assume the file should
1044 // be opened in binary mode.
1045
1046 bool BinaryMode = false;
1047 if (llvm::Triple(LLVM_HOST_TRIPLE).isOSWindows()) {
1048 BinaryMode = true;
1049 const SourceManager &SM = CI.getSourceManager();
1050 if (std::optional<llvm::MemoryBufferRef> Buffer =
1051 SM.getBufferOrNone(SM.getMainFileID())) {
1052 const char *cur = Buffer->getBufferStart();
1053 const char *end = Buffer->getBufferEnd();
1054 const char *next = (cur != end) ? cur + 1 : end;
1055
1056 // Limit ourselves to only scanning 256 characters into the source
1057 // file. This is mostly a check in case the file has no
1058 // newlines whatsoever.
1059 if (end - cur > 256)
1060 end = cur + 256;
1061
1062 while (next < end) {
1063 if (*cur == 0x0D) { // CR
1064 if (*next == 0x0A) // CRLF
1065 BinaryMode = false;
1066
1067 break;
1068 } else if (*cur == 0x0A) // LF
1069 break;
1070
1071 ++cur;
1072 ++next;
1073 }
1074 }
1075 }
1076
1077 std::unique_ptr<raw_ostream> OS =
1079 if (!OS) return;
1080
1081 // If we're preprocessing a module map, start by dumping the contents of the
1082 // module itself before switching to the input buffer.
1083 auto &Input = getCurrentInput();
1084 if (Input.getKind().getFormat() == InputKind::ModuleMap) {
1085 if (Input.isFile()) {
1086 (*OS) << "# 1 \"";
1087 OS->write_escaped(Input.getFile());
1088 (*OS) << "\"\n";
1089 }
1090 getCurrentModule()->print(*OS);
1091 (*OS) << "#pragma clang module contents\n";
1092 }
1093
1096}
1097
1099 switch (getCurrentFileKind().getLanguage()) {
1100 case Language::C:
1101 case Language::CXX:
1102 case Language::ObjC:
1103 case Language::ObjCXX:
1104 case Language::OpenCL:
1106 case Language::CUDA:
1107 case Language::HIP:
1108 case Language::HLSL:
1109 case Language::CIR:
1110 break;
1111
1112 case Language::Unknown:
1113 case Language::Asm:
1114 case Language::LLVM_IR:
1115 // We can't do anything with these.
1116 return;
1117 }
1118
1119 // We don't expect to find any #include directives in a preprocessed input.
1120 if (getCurrentFileKind().isPreprocessed())
1121 return;
1122
1124 auto Buffer = CI.getFileManager().getBufferForFile(getCurrentFile());
1125 if (Buffer) {
1126 unsigned Preamble =
1127 Lexer::ComputePreamble((*Buffer)->getBuffer(), CI.getLangOpts()).Size;
1128 llvm::outs().write((*Buffer)->getBufferStart(), Preamble);
1129 }
1130}
1131
1132void DumpCompilerOptionsAction::ExecuteAction() {
1134 std::unique_ptr<raw_ostream> OSP =
1136 if (!OSP)
1137 return;
1138
1139 raw_ostream &OS = *OSP;
1140 const Preprocessor &PP = CI.getPreprocessor();
1141 const LangOptions &LangOpts = PP.getLangOpts();
1142
1143 // FIXME: Rather than manually format the JSON (which is awkward due to
1144 // needing to remove trailing commas), this should make use of a JSON library.
1145 // FIXME: Instead of printing enums as an integral value and specifying the
1146 // type as a separate field, use introspection to print the enumerator.
1147
1148 OS << "{\n";
1149 OS << "\n\"features\" : [\n";
1150 {
1152#define FEATURE(Name, Predicate) \
1153 ("\t{\"" #Name "\" : " + llvm::Twine(Predicate ? "true" : "false") + "},\n") \
1154 .toVector(Str);
1155#include "clang/Basic/Features.def"
1156#undef FEATURE
1157 // Remove the newline and comma from the last entry to ensure this remains
1158 // valid JSON.
1159 OS << Str.substr(0, Str.size() - 2);
1160 }
1161 OS << "\n],\n";
1162
1163 OS << "\n\"extensions\" : [\n";
1164 {
1166#define EXTENSION(Name, Predicate) \
1167 ("\t{\"" #Name "\" : " + llvm::Twine(Predicate ? "true" : "false") + "},\n") \
1168 .toVector(Str);
1169#include "clang/Basic/Features.def"
1170#undef EXTENSION
1171 // Remove the newline and comma from the last entry to ensure this remains
1172 // valid JSON.
1173 OS << Str.substr(0, Str.size() - 2);
1174 }
1175 OS << "\n]\n";
1176
1177 OS << "}";
1178}
1179
1183 llvm::MemoryBufferRef FromFile = SM.getBufferOrFake(SM.getMainFileID());
1184
1188 FromFile.getBuffer(), Tokens, Directives, &CI.getDiagnostics(),
1189 SM.getLocForStartOfFile(SM.getMainFileID()))) {
1190 assert(CI.getDiagnostics().hasErrorOccurred() &&
1191 "no errors reported for failure");
1192
1193 // Preprocess the source when verifying the diagnostics to capture the
1194 // 'expected' comments.
1195 if (CI.getDiagnosticOpts().VerifyDiagnostics) {
1196 // Make sure we don't emit new diagnostics!
1200 Token Tok;
1201 do {
1202 PP.Lex(Tok);
1203 } while (Tok.isNot(tok::eof));
1204 }
1205 return;
1206 }
1207 printDependencyDirectivesAsSource(FromFile.getBuffer(), Directives,
1208 llvm::outs());
1209}
1210
1211void GetDependenciesByModuleNameAction::ExecuteAction() {
1213 Preprocessor &PP = CI.getPreprocessor();
1215 FileID MainFileID = SM.getMainFileID();
1216 SourceLocation FileStart = SM.getLocForStartOfFile(MainFileID);
1218 IdentifierInfo *ModuleID = PP.getIdentifierInfo(ModuleName);
1219 Path.push_back(std::make_pair(ModuleID, FileStart));
1220 auto ModResult = CI.loadModule(FileStart, Path, Module::Hidden, false);
1221 PPCallbacks *CB = PP.getPPCallbacks();
1222 CB->moduleImport(SourceLocation(), Path, ModResult);
1223}
#define SM(sm)
Definition: Cuda.cpp:85
IndirectLocalPath & Path
enum clang::sema::@1727::IndirectLocalPathEntry::EntryKind Kind
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:3056
#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:733
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:116
virtual bool ReadFullVersionInformation(StringRef FullVersion)
Receives the full Clang version information.
Definition: ASTReader.h:124
Reads an AST files chain containing the contents of a translation unit.
Definition: ASTReader.h:384
ModuleManager & getModuleManager()
Retrieve the module manager.
Definition: ASTReader.h:1934
@ ARR_ConfigurationMismatch
The client can handle an AST file that cannot load because it's compiled configuration doesn't match ...
Definition: ASTReader.h:1789
unsigned getTotalNumSubmodules() const
Returns the number of submodules known.
Definition: ASTReader.h:2030
Module * getModule(unsigned ID) override
Retrieve the module that corresponds to the given module ID.
Definition: ASTReader.cpp:9608
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:5651
Preprocessor & getPreprocessor() const
Retrieve the preprocessor.
Definition: ASTReader.h:1938
const LangOptions & getLangOpts() const
Definition: ASTUnit.h:464
IntrusiveRefCntPtr< ASTReader > getASTReader() const
Definition: ASTUnit.cpp:766
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:1047
SourceLocation getLocation() const
Definition: DeclBase.h:442
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1493
bool hasErrorOccurred() const
Definition: Diagnostic.h:866
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:720
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, bool IsText=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...
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:237
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:107
@ CMK_ModuleInterface
Compiling a C++ modules interface unit.
Definition: LangOptions.h:110
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:500
std::string CurrentModule
The name of the current module, of which the main source file is a part.
Definition: LangOptions.h:555
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:561
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:636
Describes a module or submodule.
Definition: Module.h:115
SmallVector< ExportDecl, 2 > Exports
The set of export declarations.
Definition: Module.h:442
@ Hidden
All of the names in this module are hidden.
Definition: Module.h:416
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:465
ModuleKind Kind
The kind of this module.
Definition: Module.h:160
llvm::SmallSetVector< Module *, 2 > Imports
The set of modules imported by this module, and on which this module depends.
Definition: Module.h:429
std::string Name
The name of this module.
Definition: Module.h:118
llvm::iterator_range< submodule_iterator > submodules()
Definition: Module.h:809
@ ModuleImplementationUnit
This is a C++20 module implementation unit.
Definition: Module.h:138
@ ModuleMapModule
This is a module that was defined by a module map and built out of header files.
Definition: Module.h:129
@ ImplicitGlobalModuleFragment
This is an implicit fragment of the global module which contains only language linkage declarations (...
Definition: Module.h:156
@ ModulePartitionInterface
This is a C++20 module partition interface.
Definition: Module.h:141
@ ModuleInterfaceUnit
This is a C++20 module interface unit.
Definition: Module.h:135
@ ModuleHeaderUnit
This is a C++20 header unit.
Definition: Module.h:132
@ ModulePartitionImplementation
This is a C++20 module partition implementation.
Definition: Module.h:144
@ PrivateModuleFragment
This is the private module fragment within some C++ module.
Definition: Module.h:151
@ ExplicitGlobalModuleFragment
This is the explicit Global Module Fragment of a modular TU.
Definition: Module.h:148
This represents a decl that may have a name.
Definition: Decl.h:253
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:1818
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:138
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:2193
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:465
ASTContext & Context
Definition: Sema.h:910
const LangOptions & getLangOpts() const
Definition: Sema.h:526
std::vector< std::unique_ptr< TemplateInstantiationCallback > > TemplateInstCallbacks
The template instantiation callbacks to trace or track instantiations (objects can be chained).
Definition: Sema.h:13207
SourceManager & getSourceManager() const
Definition: Sema.h:531
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:1828
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:130
std::string ModuleName
The name of the module.
Definition: ModuleFile.h:148
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:51
@ MK_Preamble
File is a PCH file treated as the preamble.
Definition: ModuleFile.h:54
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:12670
static void mapping(IO &io, TemplightEntry &fields)