clang 19.0.0git
FrontendActions.cpp
Go to the documentation of this file.
1//===--- FrontendActions.cpp ----------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
11#include "clang/AST/Decl.h"
14#include "clang/Basic/Module.h"
29#include "llvm/Support/ErrorHandling.h"
30#include "llvm/Support/FileSystem.h"
31#include "llvm/Support/MemoryBuffer.h"
32#include "llvm/Support/Path.h"
33#include "llvm/Support/YAMLTraits.h"
34#include "llvm/Support/raw_ostream.h"
35#include <memory>
36#include <optional>
37#include <system_error>
38
39using namespace clang;
40
41namespace {
42CodeCompleteConsumer *GetCodeCompletionConsumer(CompilerInstance &CI) {
44 : nullptr;
45}
46
47void EnsureSemaIsCreated(CompilerInstance &CI, FrontendAction &Action) {
48 if (Action.hasCodeCompletionSupport() &&
51
52 if (!CI.hasSema())
54 GetCodeCompletionConsumer(CI));
55}
56} // namespace
57
58//===----------------------------------------------------------------------===//
59// Custom Actions
60//===----------------------------------------------------------------------===//
61
62std::unique_ptr<ASTConsumer>
63InitOnlyAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
64 return std::make_unique<ASTConsumer>();
65}
66
67void InitOnlyAction::ExecuteAction() {
68}
69
70// Basically PreprocessOnlyAction::ExecuteAction.
71void ReadPCHAndPreprocessAction::ExecuteAction() {
73
74 // Ignore unknown pragmas.
75 PP.IgnorePragmas();
76
77 Token Tok;
78 // Start parsing the specified input file.
80 do {
81 PP.Lex(Tok);
82 } while (Tok.isNot(tok::eof));
83}
84
85std::unique_ptr<ASTConsumer>
86ReadPCHAndPreprocessAction::CreateASTConsumer(CompilerInstance &CI,
87 StringRef InFile) {
88 return std::make_unique<ASTConsumer>();
89}
90
91//===----------------------------------------------------------------------===//
92// AST Consumer Actions
93//===----------------------------------------------------------------------===//
94
95std::unique_ptr<ASTConsumer>
97 if (std::unique_ptr<raw_ostream> OS =
98 CI.createDefaultOutputFile(false, InFile))
99 return CreateASTPrinter(std::move(OS), CI.getFrontendOpts().ASTDumpFilter);
100 return nullptr;
101}
102
103std::unique_ptr<ASTConsumer>
105 const FrontendOptions &Opts = CI.getFrontendOpts();
106 return CreateASTDumper(nullptr /*Dump to stdout.*/, Opts.ASTDumpFilter,
107 Opts.ASTDumpDecls, Opts.ASTDumpAll,
109 Opts.ASTDumpFormat);
110}
111
112std::unique_ptr<ASTConsumer>
115}
116
117std::unique_ptr<ASTConsumer>
119 return CreateASTViewer();
120}
121
122std::unique_ptr<ASTConsumer>
124 std::string Sysroot;
125 if (!ComputeASTConsumerArguments(CI, /*ref*/ Sysroot))
126 return nullptr;
127
128 std::string OutputFile;
129 std::unique_ptr<raw_pwrite_stream> OS =
130 CreateOutputFile(CI, InFile, /*ref*/ OutputFile);
131 if (!OS)
132 return nullptr;
133
135 Sysroot.clear();
136
137 const auto &FrontendOpts = CI.getFrontendOpts();
138 auto Buffer = std::make_shared<PCHBuffer>();
139 std::vector<std::unique_ptr<ASTConsumer>> Consumers;
140 Consumers.push_back(std::make_unique<PCHGenerator>(
141 CI.getPreprocessor(), CI.getModuleCache(), OutputFile, Sysroot, Buffer,
142 FrontendOpts.ModuleFileExtensions,
144 FrontendOpts.IncludeTimestamps, FrontendOpts.BuildingImplicitModule,
145 +CI.getLangOpts().CacheGeneratedPCH));
146 Consumers.push_back(CI.getPCHContainerWriter().CreatePCHContainerGenerator(
147 CI, std::string(InFile), OutputFile, std::move(OS), Buffer));
148
149 return std::make_unique<MultiplexConsumer>(std::move(Consumers));
150}
151
153 std::string &Sysroot) {
154 Sysroot = CI.getHeaderSearchOpts().Sysroot;
155 if (CI.getFrontendOpts().RelocatablePCH && Sysroot.empty()) {
156 CI.getDiagnostics().Report(diag::err_relocatable_without_isysroot);
157 return false;
158 }
159
160 return true;
161}
162
163std::unique_ptr<llvm::raw_pwrite_stream>
165 std::string &OutputFile) {
166 // Because this is exposed via libclang we must disable RemoveFileOnSignal.
167 std::unique_ptr<raw_pwrite_stream> OS = CI.createDefaultOutputFile(
168 /*Binary=*/true, InFile, /*Extension=*/"", /*RemoveFileOnSignal=*/false);
169 if (!OS)
170 return nullptr;
171
172 OutputFile = CI.getFrontendOpts().OutputFile;
173 return OS;
174}
175
177 if (getCompilerInstance().getPreprocessorOpts().AllowPCHWithCompilerErrors)
178 return false;
180}
181
183 CI.getLangOpts().CompilingPCH = true;
184 return true;
185}
186
187std::vector<std::unique_ptr<ASTConsumer>>
189 StringRef InFile) {
190 std::unique_ptr<raw_pwrite_stream> OS = CreateOutputFile(CI, InFile);
191 if (!OS)
192 return {};
193
194 std::string OutputFile = CI.getFrontendOpts().OutputFile;
195 std::string Sysroot;
196
197 auto Buffer = std::make_shared<PCHBuffer>();
198 std::vector<std::unique_ptr<ASTConsumer>> Consumers;
199
200 Consumers.push_back(std::make_unique<PCHGenerator>(
201 CI.getPreprocessor(), CI.getModuleCache(), OutputFile, Sysroot, Buffer,
203 /*AllowASTWithErrors=*/
205 /*IncludeTimestamps=*/
208 /*BuildingImplicitModule=*/+CI.getFrontendOpts().BuildingImplicitModule,
209 /*ShouldCacheASTInMemory=*/
211 Consumers.push_back(CI.getPCHContainerWriter().CreatePCHContainerGenerator(
212 CI, std::string(InFile), OutputFile, std::move(OS), Buffer));
213 return Consumers;
214}
215
216std::unique_ptr<ASTConsumer>
218 StringRef InFile) {
219 std::vector<std::unique_ptr<ASTConsumer>> Consumers =
220 CreateMultiplexConsumer(CI, InFile);
221 if (Consumers.empty())
222 return nullptr;
223
224 return std::make_unique<MultiplexConsumer>(std::move(Consumers));
225}
226
230}
231
232bool GenerateModuleFromModuleMapAction::BeginSourceFileAction(
233 CompilerInstance &CI) {
234 if (!CI.getLangOpts().Modules) {
235 CI.getDiagnostics().Report(diag::err_module_build_requires_fmodules);
236 return false;
237 }
238
240}
241
242std::unique_ptr<raw_pwrite_stream>
243GenerateModuleFromModuleMapAction::CreateOutputFile(CompilerInstance &CI,
244 StringRef InFile) {
245 // If no output file was provided, figure out where this module would go
246 // in the module cache.
247 if (CI.getFrontendOpts().OutputFile.empty()) {
248 StringRef ModuleMapFile = CI.getFrontendOpts().OriginalModuleMap;
249 if (ModuleMapFile.empty())
250 ModuleMapFile = InFile;
251
255 ModuleMapFile);
256 }
257
258 // Because this is exposed via libclang we must disable RemoveFileOnSignal.
259 return CI.createDefaultOutputFile(/*Binary=*/true, InFile, /*Extension=*/"",
260 /*RemoveFileOnSignal=*/false,
261 /*CreateMissingDirectories=*/true,
262 /*ForceUseTemporary=*/true);
263}
264
266 CompilerInstance &CI) {
267 CI.getLangOpts().setCompilingModule(LangOptions::CMK_ModuleInterface);
268
270}
271
272std::unique_ptr<ASTConsumer>
274 StringRef InFile) {
278
279 std::vector<std::unique_ptr<ASTConsumer>> Consumers =
280 CreateMultiplexConsumer(CI, InFile);
281 if (Consumers.empty())
282 return nullptr;
283
284 return std::make_unique<MultiplexConsumer>(std::move(Consumers));
285}
286
287std::unique_ptr<raw_pwrite_stream>
289 StringRef InFile) {
290 return CI.createDefaultOutputFile(/*Binary=*/true, InFile, "pcm");
291}
292
293std::unique_ptr<ASTConsumer>
294GenerateReducedModuleInterfaceAction::CreateASTConsumer(CompilerInstance &CI,
295 StringRef InFile) {
296 return std::make_unique<ReducedBMIGenerator>(CI.getPreprocessor(),
297 CI.getModuleCache(),
299}
300
301bool GenerateHeaderUnitAction::BeginSourceFileAction(CompilerInstance &CI) {
302 if (!CI.getLangOpts().CPlusPlusModules) {
303 CI.getDiagnostics().Report(diag::err_module_interface_requires_cpp_modules);
304 return false;
305 }
306 CI.getLangOpts().setCompilingModule(LangOptions::CMK_HeaderUnit);
308}
309
310std::unique_ptr<raw_pwrite_stream>
311GenerateHeaderUnitAction::CreateOutputFile(CompilerInstance &CI,
312 StringRef InFile) {
313 return CI.createDefaultOutputFile(/*Binary=*/true, InFile, "pcm");
314}
315
317}
318
319std::unique_ptr<ASTConsumer>
321 return std::make_unique<ASTConsumer>();
322}
323
324std::unique_ptr<ASTConsumer>
326 StringRef InFile) {
327 return std::make_unique<ASTConsumer>();
328}
329
330std::unique_ptr<ASTConsumer>
332 return std::make_unique<ASTConsumer>();
333}
334
338 const std::string &Sysroot = CI.getHeaderSearchOpts().Sysroot;
339 std::unique_ptr<ASTReader> Reader(new ASTReader(
342 Sysroot.empty() ? "" : Sysroot.c_str(),
344 /*AllowASTWithCompilerErrors*/ false,
345 /*AllowConfigurationMismatch*/ true,
346 /*ValidateSystemInputs*/ true));
347
348 Reader->ReadAST(getCurrentFile(),
353}
354
355namespace {
356struct TemplightEntry {
357 std::string Name;
358 std::string Kind;
359 std::string Event;
360 std::string DefinitionLocation;
361 std::string PointOfInstantiation;
362};
363} // namespace
364
365namespace llvm {
366namespace yaml {
367template <> struct MappingTraits<TemplightEntry> {
368 static void mapping(IO &io, TemplightEntry &fields) {
369 io.mapRequired("name", fields.Name);
370 io.mapRequired("kind", fields.Kind);
371 io.mapRequired("event", fields.Event);
372 io.mapRequired("orig", fields.DefinitionLocation);
373 io.mapRequired("poi", fields.PointOfInstantiation);
374 }
375};
376} // namespace yaml
377} // namespace llvm
378
379namespace {
380class DefaultTemplateInstCallback : public TemplateInstantiationCallback {
381 using CodeSynthesisContext = Sema::CodeSynthesisContext;
382
383public:
384 void initialize(const Sema &) override {}
385
386 void finalize(const Sema &) override {}
387
388 void atTemplateBegin(const Sema &TheSema,
389 const CodeSynthesisContext &Inst) override {
390 displayTemplightEntry<true>(llvm::outs(), TheSema, Inst);
391 }
392
393 void atTemplateEnd(const Sema &TheSema,
394 const CodeSynthesisContext &Inst) override {
395 displayTemplightEntry<false>(llvm::outs(), TheSema, Inst);
396 }
397
398private:
399 static std::string toString(CodeSynthesisContext::SynthesisKind Kind) {
400 switch (Kind) {
401 case CodeSynthesisContext::TemplateInstantiation:
402 return "TemplateInstantiation";
403 case CodeSynthesisContext::DefaultTemplateArgumentInstantiation:
404 return "DefaultTemplateArgumentInstantiation";
405 case CodeSynthesisContext::DefaultFunctionArgumentInstantiation:
406 return "DefaultFunctionArgumentInstantiation";
407 case CodeSynthesisContext::ExplicitTemplateArgumentSubstitution:
408 return "ExplicitTemplateArgumentSubstitution";
409 case CodeSynthesisContext::DeducedTemplateArgumentSubstitution:
410 return "DeducedTemplateArgumentSubstitution";
411 case CodeSynthesisContext::LambdaExpressionSubstitution:
412 return "LambdaExpressionSubstitution";
413 case CodeSynthesisContext::PriorTemplateArgumentSubstitution:
414 return "PriorTemplateArgumentSubstitution";
415 case CodeSynthesisContext::DefaultTemplateArgumentChecking:
416 return "DefaultTemplateArgumentChecking";
417 case CodeSynthesisContext::ExceptionSpecEvaluation:
418 return "ExceptionSpecEvaluation";
419 case CodeSynthesisContext::ExceptionSpecInstantiation:
420 return "ExceptionSpecInstantiation";
421 case CodeSynthesisContext::DeclaringSpecialMember:
422 return "DeclaringSpecialMember";
423 case CodeSynthesisContext::DeclaringImplicitEqualityComparison:
424 return "DeclaringImplicitEqualityComparison";
425 case CodeSynthesisContext::DefiningSynthesizedFunction:
426 return "DefiningSynthesizedFunction";
427 case CodeSynthesisContext::RewritingOperatorAsSpaceship:
428 return "RewritingOperatorAsSpaceship";
429 case CodeSynthesisContext::Memoization:
430 return "Memoization";
431 case CodeSynthesisContext::ConstraintsCheck:
432 return "ConstraintsCheck";
433 case CodeSynthesisContext::ConstraintSubstitution:
434 return "ConstraintSubstitution";
435 case CodeSynthesisContext::ConstraintNormalization:
436 return "ConstraintNormalization";
437 case CodeSynthesisContext::RequirementParameterInstantiation:
438 return "RequirementParameterInstantiation";
439 case CodeSynthesisContext::ParameterMappingSubstitution:
440 return "ParameterMappingSubstitution";
441 case CodeSynthesisContext::RequirementInstantiation:
442 return "RequirementInstantiation";
443 case CodeSynthesisContext::NestedRequirementConstraintsCheck:
444 return "NestedRequirementConstraintsCheck";
445 case CodeSynthesisContext::InitializingStructuredBinding:
446 return "InitializingStructuredBinding";
447 case CodeSynthesisContext::MarkingClassDllexported:
448 return "MarkingClassDllexported";
449 case CodeSynthesisContext::BuildingBuiltinDumpStructCall:
450 return "BuildingBuiltinDumpStructCall";
451 case CodeSynthesisContext::BuildingDeductionGuides:
452 return "BuildingDeductionGuides";
453 }
454 return "";
455 }
456
457 template <bool BeginInstantiation>
458 static void displayTemplightEntry(llvm::raw_ostream &Out, const Sema &TheSema,
459 const CodeSynthesisContext &Inst) {
460 std::string YAML;
461 {
462 llvm::raw_string_ostream OS(YAML);
463 llvm::yaml::Output YO(OS);
464 TemplightEntry Entry =
465 getTemplightEntry<BeginInstantiation>(TheSema, Inst);
466 llvm::yaml::EmptyContext Context;
467 llvm::yaml::yamlize(YO, Entry, true, Context);
468 }
469 Out << "---" << YAML << "\n";
470 }
471
472 static void printEntryName(const Sema &TheSema, const Decl *Entity,
473 llvm::raw_string_ostream &OS) {
474 auto *NamedTemplate = cast<NamedDecl>(Entity);
475
476 PrintingPolicy Policy = TheSema.Context.getPrintingPolicy();
477 // FIXME: Also ask for FullyQualifiedNames?
478 Policy.SuppressDefaultTemplateArgs = false;
479 NamedTemplate->getNameForDiagnostic(OS, Policy, true);
480
481 if (!OS.str().empty())
482 return;
483
484 Decl *Ctx = Decl::castFromDeclContext(NamedTemplate->getDeclContext());
485 NamedDecl *NamedCtx = dyn_cast_or_null<NamedDecl>(Ctx);
486
487 if (const auto *Decl = dyn_cast<TagDecl>(NamedTemplate)) {
488 if (const auto *R = dyn_cast<RecordDecl>(Decl)) {
489 if (R->isLambda()) {
490 OS << "lambda at ";
491 Decl->getLocation().print(OS, TheSema.getSourceManager());
492 return;
493 }
494 }
495 OS << "unnamed " << Decl->getKindName();
496 return;
497 }
498
499 assert(NamedCtx && "NamedCtx cannot be null");
500
501 if (const auto *Decl = dyn_cast<ParmVarDecl>(NamedTemplate)) {
502 OS << "unnamed function parameter " << Decl->getFunctionScopeIndex()
503 << " ";
504 if (Decl->getFunctionScopeDepth() > 0)
505 OS << "(at depth " << Decl->getFunctionScopeDepth() << ") ";
506 OS << "of ";
507 NamedCtx->getNameForDiagnostic(OS, TheSema.getLangOpts(), true);
508 return;
509 }
510
511 if (const auto *Decl = dyn_cast<TemplateTypeParmDecl>(NamedTemplate)) {
512 if (const Type *Ty = Decl->getTypeForDecl()) {
513 if (const auto *TTPT = dyn_cast_or_null<TemplateTypeParmType>(Ty)) {
514 OS << "unnamed template type parameter " << TTPT->getIndex() << " ";
515 if (TTPT->getDepth() > 0)
516 OS << "(at depth " << TTPT->getDepth() << ") ";
517 OS << "of ";
518 NamedCtx->getNameForDiagnostic(OS, TheSema.getLangOpts(), true);
519 return;
520 }
521 }
522 }
523
524 if (const auto *Decl = dyn_cast<NonTypeTemplateParmDecl>(NamedTemplate)) {
525 OS << "unnamed template non-type parameter " << Decl->getIndex() << " ";
526 if (Decl->getDepth() > 0)
527 OS << "(at depth " << Decl->getDepth() << ") ";
528 OS << "of ";
529 NamedCtx->getNameForDiagnostic(OS, TheSema.getLangOpts(), true);
530 return;
531 }
532
533 if (const auto *Decl = dyn_cast<TemplateTemplateParmDecl>(NamedTemplate)) {
534 OS << "unnamed template template parameter " << Decl->getIndex() << " ";
535 if (Decl->getDepth() > 0)
536 OS << "(at depth " << Decl->getDepth() << ") ";
537 OS << "of ";
538 NamedCtx->getNameForDiagnostic(OS, TheSema.getLangOpts(), true);
539 return;
540 }
541
542 llvm_unreachable("Failed to retrieve a name for this entry!");
543 OS << "unnamed identifier";
544 }
545
546 template <bool BeginInstantiation>
547 static TemplightEntry getTemplightEntry(const Sema &TheSema,
548 const CodeSynthesisContext &Inst) {
549 TemplightEntry Entry;
550 Entry.Kind = toString(Inst.Kind);
551 Entry.Event = BeginInstantiation ? "Begin" : "End";
552 llvm::raw_string_ostream OS(Entry.Name);
553 printEntryName(TheSema, Inst.Entity, OS);
554 const PresumedLoc DefLoc =
555 TheSema.getSourceManager().getPresumedLoc(Inst.Entity->getLocation());
556 if (!DefLoc.isInvalid())
557 Entry.DefinitionLocation = std::string(DefLoc.getFilename()) + ":" +
558 std::to_string(DefLoc.getLine()) + ":" +
559 std::to_string(DefLoc.getColumn());
560 const PresumedLoc PoiLoc =
561 TheSema.getSourceManager().getPresumedLoc(Inst.PointOfInstantiation);
562 if (!PoiLoc.isInvalid()) {
563 Entry.PointOfInstantiation = std::string(PoiLoc.getFilename()) + ":" +
564 std::to_string(PoiLoc.getLine()) + ":" +
565 std::to_string(PoiLoc.getColumn());
566 }
567 return Entry;
568 }
569};
570} // namespace
571
572std::unique_ptr<ASTConsumer>
574 return std::make_unique<ASTConsumer>();
575}
576
579
580 // This part is normally done by ASTFrontEndAction, but needs to happen
581 // before Templight observers can be created
582 // FIXME: Move the truncation aspect of this into Sema, we delayed this till
583 // here so the source manager would be initialized.
584 EnsureSemaIsCreated(CI, *this);
585
586 CI.getSema().TemplateInstCallbacks.push_back(
587 std::make_unique<DefaultTemplateInstCallback>());
589}
590
591namespace {
592 /// AST reader listener that dumps module information for a module
593 /// file.
594 class DumpModuleInfoListener : public ASTReaderListener {
595 llvm::raw_ostream &Out;
596
597 public:
598 DumpModuleInfoListener(llvm::raw_ostream &Out) : Out(Out) { }
599
600#define DUMP_BOOLEAN(Value, Text) \
601 Out.indent(4) << Text << ": " << (Value? "Yes" : "No") << "\n"
602
603 bool ReadFullVersionInformation(StringRef FullVersion) override {
604 Out.indent(2)
605 << "Generated by "
606 << (FullVersion == getClangFullRepositoryVersion()? "this"
607 : "a different")
608 << " Clang: " << FullVersion << "\n";
610 }
611
612 void ReadModuleName(StringRef ModuleName) override {
613 Out.indent(2) << "Module name: " << ModuleName << "\n";
614 }
615 void ReadModuleMapFile(StringRef ModuleMapPath) override {
616 Out.indent(2) << "Module map file: " << ModuleMapPath << "\n";
617 }
618
619 bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain,
620 bool AllowCompatibleDifferences) override {
621 Out.indent(2) << "Language options:\n";
622#define LANGOPT(Name, Bits, Default, Description) \
623 DUMP_BOOLEAN(LangOpts.Name, Description);
624#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
625 Out.indent(4) << Description << ": " \
626 << static_cast<unsigned>(LangOpts.get##Name()) << "\n";
627#define VALUE_LANGOPT(Name, Bits, Default, Description) \
628 Out.indent(4) << Description << ": " << LangOpts.Name << "\n";
629#define BENIGN_LANGOPT(Name, Bits, Default, Description)
630#define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
631#include "clang/Basic/LangOptions.def"
632
633 if (!LangOpts.ModuleFeatures.empty()) {
634 Out.indent(4) << "Module features:\n";
635 for (StringRef Feature : LangOpts.ModuleFeatures)
636 Out.indent(6) << Feature << "\n";
637 }
638
639 return false;
640 }
641
642 bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain,
643 bool AllowCompatibleDifferences) override {
644 Out.indent(2) << "Target options:\n";
645 Out.indent(4) << " Triple: " << TargetOpts.Triple << "\n";
646 Out.indent(4) << " CPU: " << TargetOpts.CPU << "\n";
647 Out.indent(4) << " TuneCPU: " << TargetOpts.TuneCPU << "\n";
648 Out.indent(4) << " ABI: " << TargetOpts.ABI << "\n";
649
650 if (!TargetOpts.FeaturesAsWritten.empty()) {
651 Out.indent(4) << "Target features:\n";
652 for (unsigned I = 0, N = TargetOpts.FeaturesAsWritten.size();
653 I != N; ++I) {
654 Out.indent(6) << TargetOpts.FeaturesAsWritten[I] << "\n";
655 }
656 }
657
658 return false;
659 }
660
661 bool ReadDiagnosticOptions(IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts,
662 bool Complain) override {
663 Out.indent(2) << "Diagnostic options:\n";
664#define DIAGOPT(Name, Bits, Default) DUMP_BOOLEAN(DiagOpts->Name, #Name);
665#define ENUM_DIAGOPT(Name, Type, Bits, Default) \
666 Out.indent(4) << #Name << ": " << DiagOpts->get##Name() << "\n";
667#define VALUE_DIAGOPT(Name, Bits, Default) \
668 Out.indent(4) << #Name << ": " << DiagOpts->Name << "\n";
669#include "clang/Basic/DiagnosticOptions.def"
670
671 Out.indent(4) << "Diagnostic flags:\n";
672 for (const std::string &Warning : DiagOpts->Warnings)
673 Out.indent(6) << "-W" << Warning << "\n";
674 for (const std::string &Remark : DiagOpts->Remarks)
675 Out.indent(6) << "-R" << Remark << "\n";
676
677 return false;
678 }
679
680 bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
681 StringRef SpecificModuleCachePath,
682 bool Complain) override {
683 Out.indent(2) << "Header search options:\n";
684 Out.indent(4) << "System root [-isysroot=]: '" << HSOpts.Sysroot << "'\n";
685 Out.indent(4) << "Resource dir [ -resource-dir=]: '" << HSOpts.ResourceDir << "'\n";
686 Out.indent(4) << "Module Cache: '" << SpecificModuleCachePath << "'\n";
688 "Use builtin include directories [-nobuiltininc]");
690 "Use standard system include directories [-nostdinc]");
692 "Use standard C++ include directories [-nostdinc++]");
693 DUMP_BOOLEAN(HSOpts.UseLibcxx,
694 "Use libc++ (rather than libstdc++) [-stdlib=]");
695 return false;
696 }
697
698 bool ReadHeaderSearchPaths(const HeaderSearchOptions &HSOpts,
699 bool Complain) override {
700 Out.indent(2) << "Header search paths:\n";
701 Out.indent(4) << "User entries:\n";
702 for (const auto &Entry : HSOpts.UserEntries)
703 Out.indent(6) << Entry.Path << "\n";
704 Out.indent(4) << "System header prefixes:\n";
705 for (const auto &Prefix : HSOpts.SystemHeaderPrefixes)
706 Out.indent(6) << Prefix.Prefix << "\n";
707 Out.indent(4) << "VFS overlay files:\n";
708 for (const auto &Overlay : HSOpts.VFSOverlayFiles)
709 Out.indent(6) << Overlay << "\n";
710 return false;
711 }
712
713 bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
714 bool ReadMacros, bool Complain,
715 std::string &SuggestedPredefines) override {
716 Out.indent(2) << "Preprocessor options:\n";
718 "Uses compiler/target-specific predefines [-undef]");
720 "Uses detailed preprocessing record (for indexing)");
721
722 if (ReadMacros) {
723 Out.indent(4) << "Predefined macros:\n";
724 }
725
726 for (std::vector<std::pair<std::string, bool/*isUndef*/> >::const_iterator
727 I = PPOpts.Macros.begin(), IEnd = PPOpts.Macros.end();
728 I != IEnd; ++I) {
729 Out.indent(6);
730 if (I->second)
731 Out << "-U";
732 else
733 Out << "-D";
734 Out << I->first << "\n";
735 }
736 return false;
737 }
738
739 /// Indicates that a particular module file extension has been read.
740 void readModuleFileExtension(
741 const ModuleFileExtensionMetadata &Metadata) override {
742 Out.indent(2) << "Module file extension '"
743 << Metadata.BlockName << "' " << Metadata.MajorVersion
744 << "." << Metadata.MinorVersion;
745 if (!Metadata.UserInfo.empty()) {
746 Out << ": ";
747 Out.write_escaped(Metadata.UserInfo);
748 }
749
750 Out << "\n";
751 }
752
753 /// Tells the \c ASTReaderListener that we want to receive the
754 /// input files of the AST file via \c visitInputFile.
755 bool needsInputFileVisitation() override { return true; }
756
757 /// Tells the \c ASTReaderListener that we want to receive the
758 /// input files of the AST file via \c visitInputFile.
759 bool needsSystemInputFileVisitation() override { return true; }
760
761 /// Indicates that the AST file contains particular input file.
762 ///
763 /// \returns true to continue receiving the next input file, false to stop.
764 bool visitInputFile(StringRef Filename, bool isSystem,
765 bool isOverridden, bool isExplicitModule) override {
766
767 Out.indent(2) << "Input file: " << Filename;
768
769 if (isSystem || isOverridden || isExplicitModule) {
770 Out << " [";
771 if (isSystem) {
772 Out << "System";
773 if (isOverridden || isExplicitModule)
774 Out << ", ";
775 }
776 if (isOverridden) {
777 Out << "Overridden";
778 if (isExplicitModule)
779 Out << ", ";
780 }
781 if (isExplicitModule)
782 Out << "ExplicitModule";
783
784 Out << "]";
785 }
786
787 Out << "\n";
788
789 return true;
790 }
791
792 /// Returns true if this \c ASTReaderListener wants to receive the
793 /// imports of the AST file via \c visitImport, false otherwise.
794 bool needsImportVisitation() const override { return true; }
795
796 /// If needsImportVisitation returns \c true, this is called for each
797 /// AST file imported by this AST file.
798 void visitImport(StringRef ModuleName, StringRef Filename) override {
799 Out.indent(2) << "Imports module '" << ModuleName
800 << "': " << Filename.str() << "\n";
801 }
802#undef DUMP_BOOLEAN
803 };
804}
805
807 // The Object file reader also supports raw ast files and there is no point in
808 // being strict about the module file format in -module-file-info mode.
810 return true;
811}
812
813static StringRef ModuleKindName(Module::ModuleKind MK) {
814 switch (MK) {
816 return "Module Map Module";
818 return "Interface Unit";
820 return "Implementation Unit";
822 return "Partition Interface";
824 return "Partition Implementation";
826 return "Header Unit";
828 return "Global Module Fragment";
830 return "Implicit Module Fragment";
832 return "Private Module Fragment";
833 }
834 llvm_unreachable("unknown module kind!");
835}
836
838 assert(isCurrentFileAST() && "dumping non-AST?");
839 // Set up the output file.
841 StringRef OutputFileName = CI.getFrontendOpts().OutputFile;
842 if (!OutputFileName.empty() && OutputFileName != "-") {
843 std::error_code EC;
844 OutputStream.reset(new llvm::raw_fd_ostream(
845 OutputFileName.str(), EC, llvm::sys::fs::OF_TextWithCRLF));
846 }
847 llvm::raw_ostream &Out = OutputStream ? *OutputStream : llvm::outs();
848
849 Out << "Information for module file '" << getCurrentFile() << "':\n";
850 auto &FileMgr = CI.getFileManager();
851 auto Buffer = FileMgr.getBufferForFile(getCurrentFile());
852 StringRef Magic = (*Buffer)->getMemBufferRef().getBuffer();
853 bool IsRaw = Magic.starts_with("CPCH");
854 Out << " Module format: " << (IsRaw ? "raw" : "obj") << "\n";
855
856 Preprocessor &PP = CI.getPreprocessor();
857 DumpModuleInfoListener Listener(Out);
858 HeaderSearchOptions &HSOpts = PP.getHeaderSearchInfo().getHeaderSearchOpts();
859
860 // The FrontendAction::BeginSourceFile () method loads the AST so that much
861 // of the information is already available and modules should have been
862 // loaded.
863
865 if (LO.CPlusPlusModules && !LO.CurrentModule.empty()) {
867 unsigned SubModuleCount = R->getTotalNumSubmodules();
869 Out << " ====== C++20 Module structure ======\n";
870
871 if (MF.ModuleName != LO.CurrentModule)
872 Out << " Mismatched module names : " << MF.ModuleName << " and "
873 << LO.CurrentModule << "\n";
874
875 struct SubModInfo {
876 unsigned Idx;
877 Module *Mod;
879 std::string &Name;
880 bool Seen;
881 };
882 std::map<std::string, SubModInfo> SubModMap;
883 auto PrintSubMapEntry = [&](std::string Name, Module::ModuleKind Kind) {
884 Out << " " << ModuleKindName(Kind) << " '" << Name << "'";
885 auto I = SubModMap.find(Name);
886 if (I == SubModMap.end())
887 Out << " was not found in the sub modules!\n";
888 else {
889 I->second.Seen = true;
890 Out << " is at index #" << I->second.Idx << "\n";
891 }
892 };
893 Module *Primary = nullptr;
894 for (unsigned Idx = 0; Idx <= SubModuleCount; ++Idx) {
895 Module *M = R->getModule(Idx);
896 if (!M)
897 continue;
898 if (M->Name == LO.CurrentModule) {
899 Primary = M;
900 Out << " " << ModuleKindName(M->Kind) << " '" << LO.CurrentModule
901 << "' is the Primary Module at index #" << Idx << "\n";
902 SubModMap.insert({M->Name, {Idx, M, M->Kind, M->Name, true}});
903 } else
904 SubModMap.insert({M->Name, {Idx, M, M->Kind, M->Name, false}});
905 }
906 if (Primary) {
907 if (!Primary->submodules().empty())
908 Out << " Sub Modules:\n";
909 for (auto *MI : Primary->submodules()) {
910 PrintSubMapEntry(MI->Name, MI->Kind);
911 }
912 if (!Primary->Imports.empty())
913 Out << " Imports:\n";
914 for (auto *IMP : Primary->Imports) {
915 PrintSubMapEntry(IMP->Name, IMP->Kind);
916 }
917 if (!Primary->Exports.empty())
918 Out << " Exports:\n";
919 for (unsigned MN = 0, N = Primary->Exports.size(); MN != N; ++MN) {
920 if (Module *M = Primary->Exports[MN].getPointer()) {
921 PrintSubMapEntry(M->Name, M->Kind);
922 }
923 }
924 }
925
926 // Emit the macro definitions in the module file so that we can know how
927 // much definitions in the module file quickly.
928 // TODO: Emit the macro definition bodies completely.
929 if (auto FilteredMacros = llvm::make_filter_range(
930 R->getPreprocessor().macros(),
931 [](const auto &Macro) { return Macro.first->isFromAST(); });
932 !FilteredMacros.empty()) {
933 Out << " Macro Definitions:\n";
934 for (/*<IdentifierInfo *, MacroState> pair*/ const auto &Macro :
935 FilteredMacros)
936 Out << " " << Macro.first->getName() << "\n";
937 }
938
939 // Now let's print out any modules we did not see as part of the Primary.
940 for (const auto &SM : SubModMap) {
941 if (!SM.second.Seen && SM.second.Mod) {
942 Out << " " << ModuleKindName(SM.second.Kind) << " '" << SM.first
943 << "' at index #" << SM.second.Idx
944 << " has no direct reference in the Primary\n";
945 }
946 }
947 Out << " ====== ======\n";
948 }
949
950 // The reminder of the output is produced from the listener as the AST
951 // FileCcontrolBlock is (re-)parsed.
953 getCurrentFile(), FileMgr, CI.getModuleCache(),
955 /*FindModuleFileExtensions=*/true, Listener,
957}
958
959//===----------------------------------------------------------------------===//
960// Preprocessor Actions
961//===----------------------------------------------------------------------===//
962
966
967 // Start lexing the specified input file.
968 llvm::MemoryBufferRef FromFile = SM.getBufferOrFake(SM.getMainFileID());
969 Lexer RawLex(SM.getMainFileID(), FromFile, SM, PP.getLangOpts());
970 RawLex.SetKeepWhitespaceMode(true);
971
972 Token RawTok;
973 RawLex.LexFromRawLexer(RawTok);
974 while (RawTok.isNot(tok::eof)) {
975 PP.DumpToken(RawTok, true);
976 llvm::errs() << "\n";
977 RawLex.LexFromRawLexer(RawTok);
978 }
979}
980
983 // Start preprocessing the specified input file.
984 Token Tok;
986 do {
987 PP.Lex(Tok);
988 PP.DumpToken(Tok, true);
989 llvm::errs() << "\n";
990 } while (Tok.isNot(tok::eof));
991}
992
995
996 // Ignore unknown pragmas.
997 PP.IgnorePragmas();
998
999 Token Tok;
1000 // Start parsing the specified input file.
1002 do {
1003 PP.Lex(Tok);
1004 } while (Tok.isNot(tok::eof));
1005}
1006
1009 // Output file may need to be set to 'Binary', to avoid converting Unix style
1010 // line feeds (<LF>) to Microsoft style line feeds (<CR><LF>) on Windows.
1011 //
1012 // Look to see what type of line endings the file uses. If there's a
1013 // CRLF, then we won't open the file up in binary mode. If there is
1014 // just an LF or CR, then we will open the file up in binary mode.
1015 // In this fashion, the output format should match the input format, unless
1016 // the input format has inconsistent line endings.
1017 //
1018 // This should be a relatively fast operation since most files won't have
1019 // all of their source code on a single line. However, that is still a
1020 // concern, so if we scan for too long, we'll just assume the file should
1021 // be opened in binary mode.
1022
1023 bool BinaryMode = false;
1024 if (llvm::Triple(LLVM_HOST_TRIPLE).isOSWindows()) {
1025 BinaryMode = true;
1026 const SourceManager &SM = CI.getSourceManager();
1027 if (std::optional<llvm::MemoryBufferRef> Buffer =
1028 SM.getBufferOrNone(SM.getMainFileID())) {
1029 const char *cur = Buffer->getBufferStart();
1030 const char *end = Buffer->getBufferEnd();
1031 const char *next = (cur != end) ? cur + 1 : end;
1032
1033 // Limit ourselves to only scanning 256 characters into the source
1034 // file. This is mostly a check in case the file has no
1035 // newlines whatsoever.
1036 if (end - cur > 256)
1037 end = cur + 256;
1038
1039 while (next < end) {
1040 if (*cur == 0x0D) { // CR
1041 if (*next == 0x0A) // CRLF
1042 BinaryMode = false;
1043
1044 break;
1045 } else if (*cur == 0x0A) // LF
1046 break;
1047
1048 ++cur;
1049 ++next;
1050 }
1051 }
1052 }
1053
1054 std::unique_ptr<raw_ostream> OS =
1056 if (!OS) return;
1057
1058 // If we're preprocessing a module map, start by dumping the contents of the
1059 // module itself before switching to the input buffer.
1060 auto &Input = getCurrentInput();
1061 if (Input.getKind().getFormat() == InputKind::ModuleMap) {
1062 if (Input.isFile()) {
1063 (*OS) << "# 1 \"";
1064 OS->write_escaped(Input.getFile());
1065 (*OS) << "\"\n";
1066 }
1067 getCurrentModule()->print(*OS);
1068 (*OS) << "#pragma clang module contents\n";
1069 }
1070
1073}
1074
1076 switch (getCurrentFileKind().getLanguage()) {
1077 case Language::C:
1078 case Language::CXX:
1079 case Language::ObjC:
1080 case Language::ObjCXX:
1081 case Language::OpenCL:
1083 case Language::CUDA:
1084 case Language::HIP:
1085 case Language::HLSL:
1086 break;
1087
1088 case Language::Unknown:
1089 case Language::Asm:
1090 case Language::LLVM_IR:
1092 // We can't do anything with these.
1093 return;
1094 }
1095
1096 // We don't expect to find any #include directives in a preprocessed input.
1097 if (getCurrentFileKind().isPreprocessed())
1098 return;
1099
1101 auto Buffer = CI.getFileManager().getBufferForFile(getCurrentFile());
1102 if (Buffer) {
1103 unsigned Preamble =
1104 Lexer::ComputePreamble((*Buffer)->getBuffer(), CI.getLangOpts()).Size;
1105 llvm::outs().write((*Buffer)->getBufferStart(), Preamble);
1106 }
1107}
1108
1109void DumpCompilerOptionsAction::ExecuteAction() {
1111 std::unique_ptr<raw_ostream> OSP =
1113 if (!OSP)
1114 return;
1115
1116 raw_ostream &OS = *OSP;
1117 const Preprocessor &PP = CI.getPreprocessor();
1118 const LangOptions &LangOpts = PP.getLangOpts();
1119
1120 // FIXME: Rather than manually format the JSON (which is awkward due to
1121 // needing to remove trailing commas), this should make use of a JSON library.
1122 // FIXME: Instead of printing enums as an integral value and specifying the
1123 // type as a separate field, use introspection to print the enumerator.
1124
1125 OS << "{\n";
1126 OS << "\n\"features\" : [\n";
1127 {
1129#define FEATURE(Name, Predicate) \
1130 ("\t{\"" #Name "\" : " + llvm::Twine(Predicate ? "true" : "false") + "},\n") \
1131 .toVector(Str);
1132#include "clang/Basic/Features.def"
1133#undef FEATURE
1134 // Remove the newline and comma from the last entry to ensure this remains
1135 // valid JSON.
1136 OS << Str.substr(0, Str.size() - 2);
1137 }
1138 OS << "\n],\n";
1139
1140 OS << "\n\"extensions\" : [\n";
1141 {
1143#define EXTENSION(Name, Predicate) \
1144 ("\t{\"" #Name "\" : " + llvm::Twine(Predicate ? "true" : "false") + "},\n") \
1145 .toVector(Str);
1146#include "clang/Basic/Features.def"
1147#undef EXTENSION
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 << "}";
1155}
1156
1160 llvm::MemoryBufferRef FromFile = SM.getBufferOrFake(SM.getMainFileID());
1161
1165 FromFile.getBuffer(), Tokens, Directives, &CI.getDiagnostics(),
1166 SM.getLocForStartOfFile(SM.getMainFileID()))) {
1167 assert(CI.getDiagnostics().hasErrorOccurred() &&
1168 "no errors reported for failure");
1169
1170 // Preprocess the source when verifying the diagnostics to capture the
1171 // 'expected' comments.
1172 if (CI.getDiagnosticOpts().VerifyDiagnostics) {
1173 // Make sure we don't emit new diagnostics!
1177 Token Tok;
1178 do {
1179 PP.Lex(Tok);
1180 } while (Tok.isNot(tok::eof));
1181 }
1182 return;
1183 }
1184 printDependencyDirectivesAsSource(FromFile.getBuffer(), Directives,
1185 llvm::outs());
1186}
1187
1188void GetDependenciesByModuleNameAction::ExecuteAction() {
1190 Preprocessor &PP = CI.getPreprocessor();
1192 FileID MainFileID = SM.getMainFileID();
1193 SourceLocation FileStart = SM.getLocForStartOfFile(MainFileID);
1195 IdentifierInfo *ModuleID = PP.getIdentifierInfo(ModuleName);
1196 Path.push_back(std::make_pair(ModuleID, FileStart));
1197 auto ModResult = CI.loadModule(FileStart, Path, Module::Hidden, false);
1198 PPCallbacks *CB = PP.getPPCallbacks();
1199 CB->moduleImport(SourceLocation(), Path, ModResult);
1200}
#define SM(sm)
Definition: Cuda.cpp:82
This is the interface for scanning header and source files to get the minimum necessary preprocessor ...
Defines the clang::FileManager interface and associated types.
StringRef Filename
Definition: Format.cpp:2952
#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:692
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:1763
@ ARR_ConfigurationMismatch
The client can handle an AST file that cannot load because it's compiled configuration doesn't match ...
Definition: ASTReader.h:1618
unsigned getTotalNumSubmodules() const
Returns the number of submodules known.
Definition: ASTReader.h:1858
Module * getModule(unsigned ID) override
Retrieve the module that corresponds to the given module ID.
Definition: ASTReader.cpp:8972
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:5397
Preprocessor & getPreprocessor() const
Retrieve the preprocessor.
Definition: ASTReader.h:1766
const LangOptions & getLangOpts() const
Definition: ASTUnit.h:464
IntrusiveRefCntPtr< ASTReader > getASTReader() const
Definition: ASTUnit.cpp:761
std::unique_ptr< ASTConsumer > CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override
Create the AST consumer object for this action, if supported.
Abstract interface for a consumer of code-completion information.
CompilerInstance - Helper class for managing a single instance of the Clang compiler.
const PCHContainerReader & getPCHContainerReader() const
Return the appropriate PCHContainerReader depending on the current CodeGenOptions.
DiagnosticsEngine & getDiagnostics() const
Get the current diagnostics engine.
std::unique_ptr< raw_pwrite_stream > createDefaultOutputFile(bool Binary=true, StringRef BaseInput="", StringRef Extension="", bool RemoveFileOnSignal=true, bool CreateMissingDirectories=false, bool ForceUseTemporary=false)
Create the default output file (from the invocation's options) and add it to the list of tracked outp...
ModuleLoadResult loadModule(SourceLocation ImportLoc, ModuleIdPath Path, Module::NameVisibilityKind Visibility, bool IsInclusionDirective) override
Attempt to load the given module.
FileManager & getFileManager() const
Return the current file manager to the caller.
PreprocessorOutputOptions & getPreprocessorOutputOpts()
InMemoryModuleCache & getModuleCache() const
Preprocessor & getPreprocessor() const
Return the current preprocessor.
ASTContext & getASTContext() const
FrontendOptions & getFrontendOpts()
HeaderSearchOptions & getHeaderSearchOpts()
bool hasCodeCompletionConsumer() const
const PCHContainerWriter & getPCHContainerWriter() const
Return the appropriate PCHContainerWriter depending on the current CodeGenOptions.
PreprocessorOptions & getPreprocessorOpts()
void createCodeCompletionConsumer()
Create a code completion consumer using the invocation; note that this will cause the source manager ...
DiagnosticOptions & getDiagnosticOpts()
LangOptions & getLangOpts()
SourceManager & getSourceManager() const
Return the current source manager.
CodeCompleteConsumer & getCodeCompletionConsumer() const
void createSema(TranslationUnitKind TUKind, CodeCompleteConsumer *CompletionConsumer)
Create the Sema object to be used for parsing.
Decl - This represents one declaration (or definition), e.g.
Definition: DeclBase.h:85
static Decl * castFromDeclContext(const DeclContext *)
Definition: DeclBase.cpp:1003
SourceLocation getLocation() const
Definition: DeclBase.h:444
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1547
bool hasErrorOccurred() const
Definition: Diagnostic.h:843
void setSuppressAllDiagnostics(bool Val)
Suppress all diagnostics, to silence the front end when we know that we don't want any more diagnosti...
Definition: Diagnostic.h:697
std::unique_ptr< ASTConsumer > CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override
Create the AST consumer object for this action, if supported.
void ExecuteAction() override
Implement the ExecuteAction interface by running Sema on the already-initialized AST consumer.
bool BeginInvocation(CompilerInstance &CI) override
Callback before starting processing a single input, giving the opportunity to modify the CompilerInvo...
void ExecuteAction() override
Callback to run the program action, using the initialized compiler instance.
void ExecuteAction() override
Callback to run the program action, using the initialized compiler instance.
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
llvm::ErrorOr< std::unique_ptr< llvm::MemoryBuffer > > getBufferForFile(FileEntryRef Entry, bool isVolatile=false, bool RequiresNullTerminator=true)
Open the specified file as a MemoryBuffer, returning a new MemoryBuffer if successful,...
Abstract base class for actions which can be performed by the frontend.
const FrontendInputFile & getCurrentInput() const
InputKind getCurrentFileKind() const
virtual bool shouldEraseOutputFiles()
Callback at the end of processing a single input, to determine if the output files should be erased o...
ASTUnit & getCurrentASTUnit() const
CompilerInstance & getCompilerInstance() const
Module * getCurrentModule() const
StringRef getCurrentFile() const
virtual bool BeginSourceFileAction(CompilerInstance &CI)
Callback at the start of processing a single input.
virtual TranslationUnitKind getTranslationUnitKind()
For AST-based actions, the kind of translation unit we're handling.
virtual bool hasCodeCompletionSupport() const
Does this action support use with code completion?
StringRef getCurrentFileOrBufferName() const
bool isCurrentFileAST() const
FrontendOptions - Options for controlling the behavior of the frontend.
unsigned BuildingImplicitModule
Whether we are performing an implicit module build.
unsigned AllowPCMWithCompilerErrors
Output (and read) PCM files regardless of compiler errors.
unsigned IncludeTimestamps
Whether timestamps should be written to the produced PCH file.
std::string ASTDumpFilter
If given, filter dumped AST Decl nodes by this substring.
unsigned ASTDumpLookups
Whether we include lookup table dumps in AST dumps.
ASTDumpOutputFormat ASTDumpFormat
Specifies the output format of the AST.
std::string OutputFile
The output file, if any.
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,...
unsigned ASTDumpDeclTypes
Whether we include declaration type dumps in AST dumps.
unsigned ASTDumpAll
Whether we deserialize all decls when forming AST dumps.
unsigned RelocatablePCH
When generating PCH files, instruct the AST writer to create relocatable PCH files.
unsigned ASTDumpDecls
Whether we include declaration dumps in AST dumps.
bool shouldEraseOutputFiles() override
Callback at the end of processing a single input, to determine if the output files should be erased o...
std::vector< std::unique_ptr< ASTConsumer > > CreateMultiplexConsumer(CompilerInstance &CI, StringRef InFile)
std::unique_ptr< ASTConsumer > CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override
Create the AST consumer object for this action, if supported.
bool BeginSourceFileAction(CompilerInstance &CI) override
Callback at the start of processing a single input.
std::unique_ptr< raw_pwrite_stream > CreateOutputFile(CompilerInstance &CI, StringRef InFile) override
std::unique_ptr< ASTConsumer > CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override
Create the AST consumer object for this action, if supported.
static std::unique_ptr< llvm::raw_pwrite_stream > CreateOutputFile(CompilerInstance &CI, StringRef InFile, std::string &OutputFile)
Creates file to write the PCH into and returns a stream to write it into.
bool BeginSourceFileAction(CompilerInstance &CI) override
Callback at the start of processing a single input.
static bool ComputeASTConsumerArguments(CompilerInstance &CI, std::string &Sysroot)
Compute the AST consumer arguments that will be used to create the PCHGenerator instance returned by ...
std::unique_ptr< ASTConsumer > CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override
Create the AST consumer object for this action, if supported.
bool shouldEraseOutputFiles() override
Callback at the end of processing a single input, to determine if the output files should be erased o...
HeaderSearchOptions - Helper class for storing options related to the initialization of the HeaderSea...
unsigned ModulesSkipHeaderSearchPaths
Whether to entirely skip writing header search paths.
std::vector< SystemHeaderPrefix > SystemHeaderPrefixes
User-specified system header prefixes.
std::string ModuleFormat
The module/pch container format.
std::string Sysroot
If non-empty, the directory to use as a "virtual system root" for include paths.
unsigned ModulesSkipDiagnosticOptions
Whether to entirely skip writing diagnostic options.
std::vector< std::string > VFSOverlayFiles
The set of user-provided virtual filesystem overlay files.
unsigned UseLibcxx
Use libc++ instead of the default libstdc++.
unsigned UseBuiltinIncludes
Include the compiler builtin includes.
unsigned UseStandardCXXIncludes
Include the system standard C++ library include search directories.
unsigned ModulesSkipPragmaDiagnosticMappings
Whether to entirely skip writing pragma diagnostic mappings.
std::vector< Entry > UserEntries
User specified include entries.
std::string ResourceDir
The directory which holds the compiler resource files (builtin includes, etc.).
unsigned UseStandardSystemIncludes
Include the system standard include search directories.
Encapsulates the information needed to find the file referenced by a #include or #include_next,...
Definition: HeaderSearch.h:232
std::string getCachedModuleFileName(Module *Module)
Retrieve the name of the cached module file that should be used to load the given module.
One of these records is kept for each identifier that is lexed.
@ CMK_HeaderUnit
Compiling a module header unit.
Definition: LangOptions.h:98
@ CMK_ModuleInterface
Compiling a C++ modules interface unit.
Definition: LangOptions.h:101
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:418
std::string CurrentModule
The name of the current module, of which the main source file is a part.
Definition: LangOptions.h:473
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:479
Lexer - This provides a simple interface that turns a text buffer into a stream of tokens.
Definition: Lexer.h:78
void SetKeepWhitespaceMode(bool Val)
SetKeepWhitespaceMode - This method lets clients enable or disable whitespace retention mode.
Definition: Lexer.h:254
bool LexFromRawLexer(Token &Result)
LexFromRawLexer - Lex a token from a designated raw lexer (one with no associated preprocessor object...
Definition: Lexer.h:236
static PreambleBounds ComputePreamble(StringRef Buffer, const LangOptions &LangOpts, unsigned MaxLines=0)
Compute the preamble of the given file.
Definition: Lexer.cpp:637
Describes a module or submodule.
Definition: Module.h:105
SmallVector< ExportDecl, 2 > Exports
The set of export declarations.
Definition: Module.h:414
@ Hidden
All of the names in this module are hidden.
Definition: Module.h:388
void print(raw_ostream &OS, unsigned Indent=0, bool Dump=false) const
Print the module map for this module to the given stream.
Definition: Module.cpp:478
ModuleKind Kind
The kind of this module.
Definition: Module.h:150
llvm::SmallSetVector< Module *, 2 > Imports
The set of modules imported by this module, and on which this module depends.
Definition: Module.h:401
std::string Name
The name of this module.
Definition: Module.h:108
llvm::iterator_range< submodule_iterator > submodules()
Definition: Module.h:782
@ ModuleImplementationUnit
This is a C++20 module implementation unit.
Definition: Module.h:128
@ ModuleMapModule
This is a module that was defined by a module map and built out of header files.
Definition: Module.h:119
@ ImplicitGlobalModuleFragment
This is an implicit fragment of the global module which contains only language linkage declarations (...
Definition: Module.h:146
@ ModulePartitionInterface
This is a C++20 module partition interface.
Definition: Module.h:131
@ ModuleInterfaceUnit
This is a C++20 module interface unit.
Definition: Module.h:125
@ ModuleHeaderUnit
This is a C++20 header unit.
Definition: Module.h:122
@ ModulePartitionImplementation
This is a C++20 module partition implementation.
Definition: Module.h:134
@ PrivateModuleFragment
This is the private module fragment within some C++ module.
Definition: Module.h:141
@ ExplicitGlobalModuleFragment
This is the explicit Global Module Fragment of a modular TU.
Definition: Module.h:138
This represents a decl that may have a name.
Definition: Decl.h:249
virtual void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const
Appends a human-readable name for this declaration into the given stream.
Definition: Decl.cpp:1826
virtual std::unique_ptr< ASTConsumer > CreatePCHContainerGenerator(CompilerInstance &CI, const std::string &MainFileName, const std::string &OutputFileName, std::unique_ptr< llvm::raw_pwrite_stream > OS, std::shared_ptr< PCHBuffer > Buffer) const =0
Return an ASTConsumer that can be chained with a PCHGenerator that produces a wrapper file format con...
This interface provides a way to observe the actions of the preprocessor as it does its thing.
Definition: PPCallbacks.h:35
virtual void moduleImport(SourceLocation ImportLoc, ModuleIdPath Path, const Module *Imported)
Callback invoked whenever there was an explicit module-import syntax.
Definition: PPCallbacks.h:180
void ExecuteAction() override
Callback to run the program action, using the initialized compiler instance.
PreprocessorOptions - This class is used for passing the various options used in preprocessor initial...
std::pair< unsigned, bool > PrecompiledPreambleBytes
If non-zero, the implicit PCH include is actually a precompiled preamble that covers this number of b...
bool DetailedRecord
Whether we should maintain a detailed record of all macro definitions and expansions.
bool UsePredefines
Initialize the preprocessor with the compiler and target specific predefines.
std::vector< std::pair< std::string, bool > > Macros
bool AllowPCHWithCompilerErrors
When true, a PCH with compiler errors will not be rejected.
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:128
void DumpToken(const Token &Tok, bool DumpFlags=false) const
Print the token to stderr, used for debugging.
void IgnorePragmas()
Install empty handlers for all pragmas (making them ignored).
Definition: Pragma.cpp:2195
PPCallbacks * getPPCallbacks() const
void Lex(Token &Result)
Lex the next token for this preprocessor.
void EnterMainSourceFile()
Enter the specified FileID as the main source file, which implicitly adds the builtin defines etc.
IdentifierInfo * getIdentifierInfo(StringRef Name) const
Return information about the specified preprocessor identifier token.
SourceManager & getSourceManager() const
llvm::iterator_range< macro_iterator > macros(bool IncludeExternalMacros=true) const
HeaderSearch & getHeaderSearchInfo() const
const LangOptions & getLangOpts() const
Represents an unpacked "presumed" location which can be presented to the user.
unsigned getColumn() const
Return the presumed column number of this location.
const char * getFilename() const
Return the presumed filename of this location.
unsigned getLine() const
Return the presumed line number of this location.
bool isInvalid() const
Return true if this object is invalid or uninitialized.
void ExecuteAction() override
Callback to run the program action, using the initialized compiler instance.
void ExecuteAction() override
Callback to run the program action, using the initialized compiler instance.
void ExecuteAction() override
Callback to run the program action, using the initialized compiler instance.
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:426
ASTContext & Context
Definition: Sema.h:1030
const LangOptions & getLangOpts() const
Definition: Sema.h:494
std::vector< std::unique_ptr< TemplateInstantiationCallback > > TemplateInstCallbacks
The template instantiation callbacks to trace or track instantiations (objects can be chained).
Definition: Sema.h:10529
SourceManager & getSourceManager() const
Definition: Sema.h:499
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:1606
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.
@ LLVM_IR
LLVM IR: we accept this so that we can run the optimizer on it, and compile it to assembly or object ...
@ 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)
YAML serialization mapping.
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:10051
static void mapping(IO &io, TemplightEntry &fields)