clang 17.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, +CI.getLangOpts().CacheGeneratedPCH));
145 Consumers.push_back(CI.getPCHContainerWriter().CreatePCHContainerGenerator(
146 CI, std::string(InFile), OutputFile, std::move(OS), Buffer));
147
148 return std::make_unique<MultiplexConsumer>(std::move(Consumers));
149}
150
152 std::string &Sysroot) {
153 Sysroot = CI.getHeaderSearchOpts().Sysroot;
154 if (CI.getFrontendOpts().RelocatablePCH && Sysroot.empty()) {
155 CI.getDiagnostics().Report(diag::err_relocatable_without_isysroot);
156 return false;
157 }
158
159 return true;
160}
161
162std::unique_ptr<llvm::raw_pwrite_stream>
164 std::string &OutputFile) {
165 // Because this is exposed via libclang we must disable RemoveFileOnSignal.
166 std::unique_ptr<raw_pwrite_stream> OS = CI.createDefaultOutputFile(
167 /*Binary=*/true, InFile, /*Extension=*/"", /*RemoveFileOnSignal=*/false);
168 if (!OS)
169 return nullptr;
170
171 OutputFile = CI.getFrontendOpts().OutputFile;
172 return OS;
173}
174
176 if (getCompilerInstance().getPreprocessorOpts().AllowPCHWithCompilerErrors)
177 return false;
179}
180
182 CI.getLangOpts().CompilingPCH = true;
183 return true;
184}
185
186std::unique_ptr<ASTConsumer>
188 StringRef InFile) {
189 std::unique_ptr<raw_pwrite_stream> OS = CreateOutputFile(CI, InFile);
190 if (!OS)
191 return nullptr;
192
193 std::string OutputFile = CI.getFrontendOpts().OutputFile;
194 std::string Sysroot;
195
196 auto Buffer = std::make_shared<PCHBuffer>();
197 std::vector<std::unique_ptr<ASTConsumer>> Consumers;
198
199 Consumers.push_back(std::make_unique<PCHGenerator>(
200 CI.getPreprocessor(), CI.getModuleCache(), OutputFile, Sysroot, Buffer,
202 /*AllowASTWithErrors=*/
204 /*IncludeTimestamps=*/
207 /*ShouldCacheASTInMemory=*/
209 Consumers.push_back(CI.getPCHContainerWriter().CreatePCHContainerGenerator(
210 CI, std::string(InFile), OutputFile, std::move(OS), Buffer));
211 return std::make_unique<MultiplexConsumer>(std::move(Consumers));
212}
213
217}
218
219bool GenerateModuleFromModuleMapAction::BeginSourceFileAction(
220 CompilerInstance &CI) {
221 if (!CI.getLangOpts().Modules) {
222 CI.getDiagnostics().Report(diag::err_module_build_requires_fmodules);
223 return false;
224 }
225
227}
228
229std::unique_ptr<raw_pwrite_stream>
230GenerateModuleFromModuleMapAction::CreateOutputFile(CompilerInstance &CI,
231 StringRef InFile) {
232 // If no output file was provided, figure out where this module would go
233 // in the module cache.
234 if (CI.getFrontendOpts().OutputFile.empty()) {
235 StringRef ModuleMapFile = CI.getFrontendOpts().OriginalModuleMap;
236 if (ModuleMapFile.empty())
237 ModuleMapFile = InFile;
238
242 ModuleMapFile);
243 }
244
245 // Because this is exposed via libclang we must disable RemoveFileOnSignal.
246 return CI.createDefaultOutputFile(/*Binary=*/true, InFile, /*Extension=*/"",
247 /*RemoveFileOnSignal=*/false,
248 /*CreateMissingDirectories=*/true,
249 /*ForceUseTemporary=*/true);
250}
251
252bool GenerateModuleInterfaceAction::BeginSourceFileAction(
253 CompilerInstance &CI) {
254 CI.getLangOpts().setCompilingModule(LangOptions::CMK_ModuleInterface);
255
257}
258
259std::unique_ptr<raw_pwrite_stream>
260GenerateModuleInterfaceAction::CreateOutputFile(CompilerInstance &CI,
261 StringRef InFile) {
262 return CI.createDefaultOutputFile(/*Binary=*/true, InFile, "pcm");
263}
264
265bool GenerateHeaderUnitAction::BeginSourceFileAction(CompilerInstance &CI) {
266 if (!CI.getLangOpts().CPlusPlusModules) {
267 CI.getDiagnostics().Report(diag::err_module_interface_requires_cpp_modules);
268 return false;
269 }
270 CI.getLangOpts().setCompilingModule(LangOptions::CMK_HeaderUnit);
272}
273
274std::unique_ptr<raw_pwrite_stream>
275GenerateHeaderUnitAction::CreateOutputFile(CompilerInstance &CI,
276 StringRef InFile) {
277 return CI.createDefaultOutputFile(/*Binary=*/true, InFile, "pcm");
278}
279
281}
282
283std::unique_ptr<ASTConsumer>
285 return std::make_unique<ASTConsumer>();
286}
287
288std::unique_ptr<ASTConsumer>
290 StringRef InFile) {
291 return std::make_unique<ASTConsumer>();
292}
293
294std::unique_ptr<ASTConsumer>
296 return std::make_unique<ASTConsumer>();
297}
298
302 const std::string &Sysroot = CI.getHeaderSearchOpts().Sysroot;
303 std::unique_ptr<ASTReader> Reader(new ASTReader(
306 Sysroot.empty() ? "" : Sysroot.c_str(),
308 /*AllowASTWithCompilerErrors*/ false,
309 /*AllowConfigurationMismatch*/ true,
310 /*ValidateSystemInputs*/ true));
311
312 Reader->ReadAST(getCurrentFile(),
317}
318
319namespace {
320struct TemplightEntry {
321 std::string Name;
322 std::string Kind;
323 std::string Event;
324 std::string DefinitionLocation;
325 std::string PointOfInstantiation;
326};
327} // namespace
328
329namespace llvm {
330namespace yaml {
331template <> struct MappingTraits<TemplightEntry> {
332 static void mapping(IO &io, TemplightEntry &fields) {
333 io.mapRequired("name", fields.Name);
334 io.mapRequired("kind", fields.Kind);
335 io.mapRequired("event", fields.Event);
336 io.mapRequired("orig", fields.DefinitionLocation);
337 io.mapRequired("poi", fields.PointOfInstantiation);
338 }
339};
340} // namespace yaml
341} // namespace llvm
342
343namespace {
344class DefaultTemplateInstCallback : public TemplateInstantiationCallback {
345 using CodeSynthesisContext = Sema::CodeSynthesisContext;
346
347public:
348 void initialize(const Sema &) override {}
349
350 void finalize(const Sema &) override {}
351
352 void atTemplateBegin(const Sema &TheSema,
353 const CodeSynthesisContext &Inst) override {
354 displayTemplightEntry<true>(llvm::outs(), TheSema, Inst);
355 }
356
357 void atTemplateEnd(const Sema &TheSema,
358 const CodeSynthesisContext &Inst) override {
359 displayTemplightEntry<false>(llvm::outs(), TheSema, Inst);
360 }
361
362private:
363 static std::string toString(CodeSynthesisContext::SynthesisKind Kind) {
364 switch (Kind) {
365 case CodeSynthesisContext::TemplateInstantiation:
366 return "TemplateInstantiation";
367 case CodeSynthesisContext::DefaultTemplateArgumentInstantiation:
368 return "DefaultTemplateArgumentInstantiation";
369 case CodeSynthesisContext::DefaultFunctionArgumentInstantiation:
370 return "DefaultFunctionArgumentInstantiation";
371 case CodeSynthesisContext::ExplicitTemplateArgumentSubstitution:
372 return "ExplicitTemplateArgumentSubstitution";
373 case CodeSynthesisContext::DeducedTemplateArgumentSubstitution:
374 return "DeducedTemplateArgumentSubstitution";
375 case CodeSynthesisContext::PriorTemplateArgumentSubstitution:
376 return "PriorTemplateArgumentSubstitution";
377 case CodeSynthesisContext::DefaultTemplateArgumentChecking:
378 return "DefaultTemplateArgumentChecking";
379 case CodeSynthesisContext::ExceptionSpecEvaluation:
380 return "ExceptionSpecEvaluation";
381 case CodeSynthesisContext::ExceptionSpecInstantiation:
382 return "ExceptionSpecInstantiation";
383 case CodeSynthesisContext::DeclaringSpecialMember:
384 return "DeclaringSpecialMember";
385 case CodeSynthesisContext::DeclaringImplicitEqualityComparison:
386 return "DeclaringImplicitEqualityComparison";
387 case CodeSynthesisContext::DefiningSynthesizedFunction:
388 return "DefiningSynthesizedFunction";
389 case CodeSynthesisContext::RewritingOperatorAsSpaceship:
390 return "RewritingOperatorAsSpaceship";
391 case CodeSynthesisContext::Memoization:
392 return "Memoization";
393 case CodeSynthesisContext::ConstraintsCheck:
394 return "ConstraintsCheck";
395 case CodeSynthesisContext::ConstraintSubstitution:
396 return "ConstraintSubstitution";
397 case CodeSynthesisContext::ConstraintNormalization:
398 return "ConstraintNormalization";
399 case CodeSynthesisContext::RequirementParameterInstantiation:
400 return "RequirementParameterInstantiation";
401 case CodeSynthesisContext::ParameterMappingSubstitution:
402 return "ParameterMappingSubstitution";
403 case CodeSynthesisContext::RequirementInstantiation:
404 return "RequirementInstantiation";
405 case CodeSynthesisContext::NestedRequirementConstraintsCheck:
406 return "NestedRequirementConstraintsCheck";
407 case CodeSynthesisContext::InitializingStructuredBinding:
408 return "InitializingStructuredBinding";
409 case CodeSynthesisContext::MarkingClassDllexported:
410 return "MarkingClassDllexported";
411 case CodeSynthesisContext::BuildingBuiltinDumpStructCall:
412 return "BuildingBuiltinDumpStructCall";
413 }
414 return "";
415 }
416
417 template <bool BeginInstantiation>
418 static void displayTemplightEntry(llvm::raw_ostream &Out, const Sema &TheSema,
419 const CodeSynthesisContext &Inst) {
420 std::string YAML;
421 {
422 llvm::raw_string_ostream OS(YAML);
423 llvm::yaml::Output YO(OS);
424 TemplightEntry Entry =
425 getTemplightEntry<BeginInstantiation>(TheSema, Inst);
426 llvm::yaml::EmptyContext Context;
427 llvm::yaml::yamlize(YO, Entry, true, Context);
428 }
429 Out << "---" << YAML << "\n";
430 }
431
432 static void printEntryName(const Sema &TheSema, const Decl *Entity,
433 llvm::raw_string_ostream &OS) {
434 auto *NamedTemplate = cast<NamedDecl>(Entity);
435
436 PrintingPolicy Policy = TheSema.Context.getPrintingPolicy();
437 // FIXME: Also ask for FullyQualifiedNames?
438 Policy.SuppressDefaultTemplateArgs = false;
439 NamedTemplate->getNameForDiagnostic(OS, Policy, true);
440
441 if (!OS.str().empty())
442 return;
443
444 Decl *Ctx = Decl::castFromDeclContext(NamedTemplate->getDeclContext());
445 NamedDecl *NamedCtx = dyn_cast_or_null<NamedDecl>(Ctx);
446
447 if (const auto *Decl = dyn_cast<TagDecl>(NamedTemplate)) {
448 if (const auto *R = dyn_cast<RecordDecl>(Decl)) {
449 if (R->isLambda()) {
450 OS << "lambda at ";
452 return;
453 }
454 }
455 OS << "unnamed " << Decl->getKindName();
456 return;
457 }
458
459 if (const auto *Decl = dyn_cast<ParmVarDecl>(NamedTemplate)) {
460 OS << "unnamed function parameter " << Decl->getFunctionScopeIndex()
461 << " ";
462 if (Decl->getFunctionScopeDepth() > 0)
463 OS << "(at depth " << Decl->getFunctionScopeDepth() << ") ";
464 OS << "of ";
465 NamedCtx->getNameForDiagnostic(OS, TheSema.getLangOpts(), true);
466 return;
467 }
468
469 if (const auto *Decl = dyn_cast<TemplateTypeParmDecl>(NamedTemplate)) {
470 if (const Type *Ty = Decl->getTypeForDecl()) {
471 if (const auto *TTPT = dyn_cast_or_null<TemplateTypeParmType>(Ty)) {
472 OS << "unnamed template type parameter " << TTPT->getIndex() << " ";
473 if (TTPT->getDepth() > 0)
474 OS << "(at depth " << TTPT->getDepth() << ") ";
475 OS << "of ";
476 NamedCtx->getNameForDiagnostic(OS, TheSema.getLangOpts(), true);
477 return;
478 }
479 }
480 }
481
482 if (const auto *Decl = dyn_cast<NonTypeTemplateParmDecl>(NamedTemplate)) {
483 OS << "unnamed template non-type parameter " << Decl->getIndex() << " ";
484 if (Decl->getDepth() > 0)
485 OS << "(at depth " << Decl->getDepth() << ") ";
486 OS << "of ";
487 NamedCtx->getNameForDiagnostic(OS, TheSema.getLangOpts(), true);
488 return;
489 }
490
491 if (const auto *Decl = dyn_cast<TemplateTemplateParmDecl>(NamedTemplate)) {
492 OS << "unnamed template template parameter " << Decl->getIndex() << " ";
493 if (Decl->getDepth() > 0)
494 OS << "(at depth " << Decl->getDepth() << ") ";
495 OS << "of ";
496 NamedCtx->getNameForDiagnostic(OS, TheSema.getLangOpts(), true);
497 return;
498 }
499
500 llvm_unreachable("Failed to retrieve a name for this entry!");
501 OS << "unnamed identifier";
502 }
503
504 template <bool BeginInstantiation>
505 static TemplightEntry getTemplightEntry(const Sema &TheSema,
506 const CodeSynthesisContext &Inst) {
507 TemplightEntry Entry;
508 Entry.Kind = toString(Inst.Kind);
509 Entry.Event = BeginInstantiation ? "Begin" : "End";
510 llvm::raw_string_ostream OS(Entry.Name);
511 printEntryName(TheSema, Inst.Entity, OS);
512 const PresumedLoc DefLoc =
513 TheSema.getSourceManager().getPresumedLoc(Inst.Entity->getLocation());
514 if (!DefLoc.isInvalid())
515 Entry.DefinitionLocation = std::string(DefLoc.getFilename()) + ":" +
516 std::to_string(DefLoc.getLine()) + ":" +
517 std::to_string(DefLoc.getColumn());
518 const PresumedLoc PoiLoc =
519 TheSema.getSourceManager().getPresumedLoc(Inst.PointOfInstantiation);
520 if (!PoiLoc.isInvalid()) {
521 Entry.PointOfInstantiation = std::string(PoiLoc.getFilename()) + ":" +
522 std::to_string(PoiLoc.getLine()) + ":" +
523 std::to_string(PoiLoc.getColumn());
524 }
525 return Entry;
526 }
527};
528} // namespace
529
530std::unique_ptr<ASTConsumer>
532 return std::make_unique<ASTConsumer>();
533}
534
537
538 // This part is normally done by ASTFrontEndAction, but needs to happen
539 // before Templight observers can be created
540 // FIXME: Move the truncation aspect of this into Sema, we delayed this till
541 // here so the source manager would be initialized.
542 EnsureSemaIsCreated(CI, *this);
543
544 CI.getSema().TemplateInstCallbacks.push_back(
545 std::make_unique<DefaultTemplateInstCallback>());
547}
548
549namespace {
550 /// AST reader listener that dumps module information for a module
551 /// file.
552 class DumpModuleInfoListener : public ASTReaderListener {
553 llvm::raw_ostream &Out;
554
555 public:
556 DumpModuleInfoListener(llvm::raw_ostream &Out) : Out(Out) { }
557
558#define DUMP_BOOLEAN(Value, Text) \
559 Out.indent(4) << Text << ": " << (Value? "Yes" : "No") << "\n"
560
561 bool ReadFullVersionInformation(StringRef FullVersion) override {
562 Out.indent(2)
563 << "Generated by "
564 << (FullVersion == getClangFullRepositoryVersion()? "this"
565 : "a different")
566 << " Clang: " << FullVersion << "\n";
568 }
569
570 void ReadModuleName(StringRef ModuleName) override {
571 Out.indent(2) << "Module name: " << ModuleName << "\n";
572 }
573 void ReadModuleMapFile(StringRef ModuleMapPath) override {
574 Out.indent(2) << "Module map file: " << ModuleMapPath << "\n";
575 }
576
577 bool ReadLanguageOptions(const LangOptions &LangOpts, bool Complain,
578 bool AllowCompatibleDifferences) override {
579 Out.indent(2) << "Language options:\n";
580#define LANGOPT(Name, Bits, Default, Description) \
581 DUMP_BOOLEAN(LangOpts.Name, Description);
582#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
583 Out.indent(4) << Description << ": " \
584 << static_cast<unsigned>(LangOpts.get##Name()) << "\n";
585#define VALUE_LANGOPT(Name, Bits, Default, Description) \
586 Out.indent(4) << Description << ": " << LangOpts.Name << "\n";
587#define BENIGN_LANGOPT(Name, Bits, Default, Description)
588#define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
589#include "clang/Basic/LangOptions.def"
590
591 if (!LangOpts.ModuleFeatures.empty()) {
592 Out.indent(4) << "Module features:\n";
593 for (StringRef Feature : LangOpts.ModuleFeatures)
594 Out.indent(6) << Feature << "\n";
595 }
596
597 return false;
598 }
599
600 bool ReadTargetOptions(const TargetOptions &TargetOpts, bool Complain,
601 bool AllowCompatibleDifferences) override {
602 Out.indent(2) << "Target options:\n";
603 Out.indent(4) << " Triple: " << TargetOpts.Triple << "\n";
604 Out.indent(4) << " CPU: " << TargetOpts.CPU << "\n";
605 Out.indent(4) << " TuneCPU: " << TargetOpts.TuneCPU << "\n";
606 Out.indent(4) << " ABI: " << TargetOpts.ABI << "\n";
607
608 if (!TargetOpts.FeaturesAsWritten.empty()) {
609 Out.indent(4) << "Target features:\n";
610 for (unsigned I = 0, N = TargetOpts.FeaturesAsWritten.size();
611 I != N; ++I) {
612 Out.indent(6) << TargetOpts.FeaturesAsWritten[I] << "\n";
613 }
614 }
615
616 return false;
617 }
618
619 bool ReadDiagnosticOptions(IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts,
620 bool Complain) override {
621 Out.indent(2) << "Diagnostic options:\n";
622#define DIAGOPT(Name, Bits, Default) DUMP_BOOLEAN(DiagOpts->Name, #Name);
623#define ENUM_DIAGOPT(Name, Type, Bits, Default) \
624 Out.indent(4) << #Name << ": " << DiagOpts->get##Name() << "\n";
625#define VALUE_DIAGOPT(Name, Bits, Default) \
626 Out.indent(4) << #Name << ": " << DiagOpts->Name << "\n";
627#include "clang/Basic/DiagnosticOptions.def"
628
629 Out.indent(4) << "Diagnostic flags:\n";
630 for (const std::string &Warning : DiagOpts->Warnings)
631 Out.indent(6) << "-W" << Warning << "\n";
632 for (const std::string &Remark : DiagOpts->Remarks)
633 Out.indent(6) << "-R" << Remark << "\n";
634
635 return false;
636 }
637
638 bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
639 StringRef SpecificModuleCachePath,
640 bool Complain) override {
641 Out.indent(2) << "Header search options:\n";
642 Out.indent(4) << "System root [-isysroot=]: '" << HSOpts.Sysroot << "'\n";
643 Out.indent(4) << "Resource dir [ -resource-dir=]: '" << HSOpts.ResourceDir << "'\n";
644 Out.indent(4) << "Module Cache: '" << SpecificModuleCachePath << "'\n";
646 "Use builtin include directories [-nobuiltininc]");
648 "Use standard system include directories [-nostdinc]");
650 "Use standard C++ include directories [-nostdinc++]");
651 DUMP_BOOLEAN(HSOpts.UseLibcxx,
652 "Use libc++ (rather than libstdc++) [-stdlib=]");
653 return false;
654 }
655
656 bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
657 bool Complain,
658 std::string &SuggestedPredefines) override {
659 Out.indent(2) << "Preprocessor options:\n";
661 "Uses compiler/target-specific predefines [-undef]");
663 "Uses detailed preprocessing record (for indexing)");
664
665 if (!PPOpts.Macros.empty()) {
666 Out.indent(4) << "Predefined macros:\n";
667 }
668
669 for (std::vector<std::pair<std::string, bool/*isUndef*/> >::const_iterator
670 I = PPOpts.Macros.begin(), IEnd = PPOpts.Macros.end();
671 I != IEnd; ++I) {
672 Out.indent(6);
673 if (I->second)
674 Out << "-U";
675 else
676 Out << "-D";
677 Out << I->first << "\n";
678 }
679 return false;
680 }
681
682 /// Indicates that a particular module file extension has been read.
683 void readModuleFileExtension(
684 const ModuleFileExtensionMetadata &Metadata) override {
685 Out.indent(2) << "Module file extension '"
686 << Metadata.BlockName << "' " << Metadata.MajorVersion
687 << "." << Metadata.MinorVersion;
688 if (!Metadata.UserInfo.empty()) {
689 Out << ": ";
690 Out.write_escaped(Metadata.UserInfo);
691 }
692
693 Out << "\n";
694 }
695
696 /// Tells the \c ASTReaderListener that we want to receive the
697 /// input files of the AST file via \c visitInputFile.
698 bool needsInputFileVisitation() override { return true; }
699
700 /// Tells the \c ASTReaderListener that we want to receive the
701 /// input files of the AST file via \c visitInputFile.
702 bool needsSystemInputFileVisitation() override { return true; }
703
704 /// Indicates that the AST file contains particular input file.
705 ///
706 /// \returns true to continue receiving the next input file, false to stop.
707 bool visitInputFile(StringRef Filename, bool isSystem,
708 bool isOverridden, bool isExplicitModule) override {
709
710 Out.indent(2) << "Input file: " << Filename;
711
712 if (isSystem || isOverridden || isExplicitModule) {
713 Out << " [";
714 if (isSystem) {
715 Out << "System";
716 if (isOverridden || isExplicitModule)
717 Out << ", ";
718 }
719 if (isOverridden) {
720 Out << "Overridden";
721 if (isExplicitModule)
722 Out << ", ";
723 }
724 if (isExplicitModule)
725 Out << "ExplicitModule";
726
727 Out << "]";
728 }
729
730 Out << "\n";
731
732 return true;
733 }
734
735 /// Returns true if this \c ASTReaderListener wants to receive the
736 /// imports of the AST file via \c visitImport, false otherwise.
737 bool needsImportVisitation() const override { return true; }
738
739 /// If needsImportVisitation returns \c true, this is called for each
740 /// AST file imported by this AST file.
741 void visitImport(StringRef ModuleName, StringRef Filename) override {
742 Out.indent(2) << "Imports module '" << ModuleName
743 << "': " << Filename.str() << "\n";
744 }
745#undef DUMP_BOOLEAN
746 };
747}
748
750 // The Object file reader also supports raw ast files and there is no point in
751 // being strict about the module file format in -module-file-info mode.
753 return true;
754}
755
756static StringRef ModuleKindName(Module::ModuleKind MK) {
757 switch (MK) {
759 return "Module Map Module";
761 return "Interface Unit";
763 return "Partition Interface";
765 return "Partition Implementation";
767 return "Header Unit";
769 return "Global Module Fragment";
771 return "Implicit Module Fragment";
773 return "Private Module Fragment";
774 }
775 llvm_unreachable("unknown module kind!");
776}
777
779 assert(isCurrentFileAST() && "dumping non-AST?");
780 // Set up the output file.
781 std::unique_ptr<llvm::raw_fd_ostream> OutFile;
783 StringRef OutputFileName = CI.getFrontendOpts().OutputFile;
784 if (!OutputFileName.empty() && OutputFileName != "-") {
785 std::error_code EC;
786 OutFile.reset(new llvm::raw_fd_ostream(OutputFileName.str(), EC,
787 llvm::sys::fs::OF_TextWithCRLF));
788 OutputStream = OutFile.get();
789 }
790 llvm::raw_ostream &Out = OutputStream ? *OutputStream : llvm::outs();
791
792 Out << "Information for module file '" << getCurrentFile() << "':\n";
793 auto &FileMgr = CI.getFileManager();
794 auto Buffer = FileMgr.getBufferForFile(getCurrentFile());
795 StringRef Magic = (*Buffer)->getMemBufferRef().getBuffer();
796 bool IsRaw = (Magic.size() >= 4 && Magic[0] == 'C' && Magic[1] == 'P' &&
797 Magic[2] == 'C' && Magic[3] == 'H');
798 Out << " Module format: " << (IsRaw ? "raw" : "obj") << "\n";
799
800 Preprocessor &PP = CI.getPreprocessor();
801 DumpModuleInfoListener Listener(Out);
802 HeaderSearchOptions &HSOpts = PP.getHeaderSearchInfo().getHeaderSearchOpts();
803
804 // The FrontendAction::BeginSourceFile () method loads the AST so that much
805 // of the information is already available and modules should have been
806 // loaded.
807
809 if (LO.CPlusPlusModules && !LO.CurrentModule.empty()) {
810
812 unsigned SubModuleCount = R->getTotalNumSubmodules();
814 Out << " ====== C++20 Module structure ======\n";
815
816 if (MF.ModuleName != LO.CurrentModule)
817 Out << " Mismatched module names : " << MF.ModuleName << " and "
818 << LO.CurrentModule << "\n";
819
820 struct SubModInfo {
821 unsigned Idx;
822 Module *Mod;
824 std::string &Name;
825 bool Seen;
826 };
827 std::map<std::string, SubModInfo> SubModMap;
828 auto PrintSubMapEntry = [&](std::string Name, Module::ModuleKind Kind) {
829 Out << " " << ModuleKindName(Kind) << " '" << Name << "'";
830 auto I = SubModMap.find(Name);
831 if (I == SubModMap.end())
832 Out << " was not found in the sub modules!\n";
833 else {
834 I->second.Seen = true;
835 Out << " is at index #" << I->second.Idx << "\n";
836 }
837 };
838 Module *Primary = nullptr;
839 for (unsigned Idx = 0; Idx <= SubModuleCount; ++Idx) {
840 Module *M = R->getModule(Idx);
841 if (!M)
842 continue;
843 if (M->Name == LO.CurrentModule) {
844 Primary = M;
845 Out << " " << ModuleKindName(M->Kind) << " '" << LO.CurrentModule
846 << "' is the Primary Module at index #" << Idx << "\n";
847 SubModMap.insert({M->Name, {Idx, M, M->Kind, M->Name, true}});
848 } else
849 SubModMap.insert({M->Name, {Idx, M, M->Kind, M->Name, false}});
850 }
851 if (Primary) {
852 if (!Primary->submodules().empty())
853 Out << " Sub Modules:\n";
854 for (auto *MI : Primary->submodules()) {
855 PrintSubMapEntry(MI->Name, MI->Kind);
856 }
857 if (!Primary->Imports.empty())
858 Out << " Imports:\n";
859 for (auto *IMP : Primary->Imports) {
860 PrintSubMapEntry(IMP->Name, IMP->Kind);
861 }
862 if (!Primary->Exports.empty())
863 Out << " Exports:\n";
864 for (unsigned MN = 0, N = Primary->Exports.size(); MN != N; ++MN) {
865 if (Module *M = Primary->Exports[MN].getPointer()) {
866 PrintSubMapEntry(M->Name, M->Kind);
867 }
868 }
869 }
870
871 // Emit the macro definitions in the module file so that we can know how
872 // much definitions in the module file quickly.
873 // TODO: Emit the macro definition bodies completely.
874 if (auto FilteredMacros = llvm::make_filter_range(
875 R->getPreprocessor().macros(),
876 [](const auto &Macro) { return Macro.first->isFromAST(); });
877 !FilteredMacros.empty()) {
878 Out << " Macro Definitions:\n";
879 for (/*<IdentifierInfo *, MacroState> pair*/ const auto &Macro :
880 FilteredMacros)
881 Out << " " << Macro.first->getName() << "\n";
882 }
883
884 // Now let's print out any modules we did not see as part of the Primary.
885 for (auto SM : SubModMap) {
886 if (!SM.second.Seen && SM.second.Mod) {
887 Out << " " << ModuleKindName(SM.second.Kind) << " '" << SM.first
888 << "' at index #" << SM.second.Idx
889 << " has no direct reference in the Primary\n";
890 }
891 }
892 Out << " ====== ======\n";
893 }
894
895 // The reminder of the output is produced from the listener as the AST
896 // FileCcontrolBlock is (re-)parsed.
898 getCurrentFile(), FileMgr, CI.getModuleCache(),
900 /*FindModuleFileExtensions=*/true, Listener,
902}
903
904//===----------------------------------------------------------------------===//
905// Preprocessor Actions
906//===----------------------------------------------------------------------===//
907
911
912 // Start lexing the specified input file.
913 llvm::MemoryBufferRef FromFile = SM.getBufferOrFake(SM.getMainFileID());
914 Lexer RawLex(SM.getMainFileID(), FromFile, SM, PP.getLangOpts());
915 RawLex.SetKeepWhitespaceMode(true);
916
917 Token RawTok;
918 RawLex.LexFromRawLexer(RawTok);
919 while (RawTok.isNot(tok::eof)) {
920 PP.DumpToken(RawTok, true);
921 llvm::errs() << "\n";
922 RawLex.LexFromRawLexer(RawTok);
923 }
924}
925
928 // Start preprocessing the specified input file.
929 Token Tok;
931 do {
932 PP.Lex(Tok);
933 PP.DumpToken(Tok, true);
934 llvm::errs() << "\n";
935 } while (Tok.isNot(tok::eof));
936}
937
940
941 // Ignore unknown pragmas.
942 PP.IgnorePragmas();
943
944 Token Tok;
945 // Start parsing the specified input file.
947 do {
948 PP.Lex(Tok);
949 } while (Tok.isNot(tok::eof));
950}
951
954 // Output file may need to be set to 'Binary', to avoid converting Unix style
955 // line feeds (<LF>) to Microsoft style line feeds (<CR><LF>) on Windows.
956 //
957 // Look to see what type of line endings the file uses. If there's a
958 // CRLF, then we won't open the file up in binary mode. If there is
959 // just an LF or CR, then we will open the file up in binary mode.
960 // In this fashion, the output format should match the input format, unless
961 // the input format has inconsistent line endings.
962 //
963 // This should be a relatively fast operation since most files won't have
964 // all of their source code on a single line. However, that is still a
965 // concern, so if we scan for too long, we'll just assume the file should
966 // be opened in binary mode.
967
968 bool BinaryMode = false;
969 if (llvm::Triple(LLVM_HOST_TRIPLE).isOSWindows()) {
970 BinaryMode = true;
971 const SourceManager &SM = CI.getSourceManager();
972 if (std::optional<llvm::MemoryBufferRef> Buffer =
973 SM.getBufferOrNone(SM.getMainFileID())) {
974 const char *cur = Buffer->getBufferStart();
975 const char *end = Buffer->getBufferEnd();
976 const char *next = (cur != end) ? cur + 1 : end;
977
978 // Limit ourselves to only scanning 256 characters into the source
979 // file. This is mostly a check in case the file has no
980 // newlines whatsoever.
981 if (end - cur > 256)
982 end = cur + 256;
983
984 while (next < end) {
985 if (*cur == 0x0D) { // CR
986 if (*next == 0x0A) // CRLF
987 BinaryMode = false;
988
989 break;
990 } else if (*cur == 0x0A) // LF
991 break;
992
993 ++cur;
994 ++next;
995 }
996 }
997 }
998
999 std::unique_ptr<raw_ostream> OS =
1001 if (!OS) return;
1002
1003 // If we're preprocessing a module map, start by dumping the contents of the
1004 // module itself before switching to the input buffer.
1005 auto &Input = getCurrentInput();
1006 if (Input.getKind().getFormat() == InputKind::ModuleMap) {
1007 if (Input.isFile()) {
1008 (*OS) << "# 1 \"";
1009 OS->write_escaped(Input.getFile());
1010 (*OS) << "\"\n";
1011 }
1013 (*OS) << "#pragma clang module contents\n";
1014 }
1015
1018}
1019
1021 switch (getCurrentFileKind().getLanguage()) {
1022 case Language::C:
1023 case Language::CXX:
1024 case Language::ObjC:
1025 case Language::ObjCXX:
1026 case Language::OpenCL:
1028 case Language::CUDA:
1029 case Language::HIP:
1030 case Language::HLSL:
1031 break;
1032
1033 case Language::Unknown:
1034 case Language::Asm:
1035 case Language::LLVM_IR:
1037 // We can't do anything with these.
1038 return;
1039 }
1040
1041 // We don't expect to find any #include directives in a preprocessed input.
1042 if (getCurrentFileKind().isPreprocessed())
1043 return;
1044
1046 auto Buffer = CI.getFileManager().getBufferForFile(getCurrentFile());
1047 if (Buffer) {
1048 unsigned Preamble =
1049 Lexer::ComputePreamble((*Buffer)->getBuffer(), CI.getLangOpts()).Size;
1050 llvm::outs().write((*Buffer)->getBufferStart(), Preamble);
1051 }
1052}
1053
1054void DumpCompilerOptionsAction::ExecuteAction() {
1056 std::unique_ptr<raw_ostream> OSP =
1058 if (!OSP)
1059 return;
1060
1061 raw_ostream &OS = *OSP;
1062 const Preprocessor &PP = CI.getPreprocessor();
1063 const LangOptions &LangOpts = PP.getLangOpts();
1064
1065 // FIXME: Rather than manually format the JSON (which is awkward due to
1066 // needing to remove trailing commas), this should make use of a JSON library.
1067 // FIXME: Instead of printing enums as an integral value and specifying the
1068 // type as a separate field, use introspection to print the enumerator.
1069
1070 OS << "{\n";
1071 OS << "\n\"features\" : [\n";
1072 {
1074#define FEATURE(Name, Predicate) \
1075 ("\t{\"" #Name "\" : " + llvm::Twine(Predicate ? "true" : "false") + "},\n") \
1076 .toVector(Str);
1077#include "clang/Basic/Features.def"
1078#undef FEATURE
1079 // Remove the newline and comma from the last entry to ensure this remains
1080 // valid JSON.
1081 OS << Str.substr(0, Str.size() - 2);
1082 }
1083 OS << "\n],\n";
1084
1085 OS << "\n\"extensions\" : [\n";
1086 {
1088#define EXTENSION(Name, Predicate) \
1089 ("\t{\"" #Name "\" : " + llvm::Twine(Predicate ? "true" : "false") + "},\n") \
1090 .toVector(Str);
1091#include "clang/Basic/Features.def"
1092#undef EXTENSION
1093 // Remove the newline and comma from the last entry to ensure this remains
1094 // valid JSON.
1095 OS << Str.substr(0, Str.size() - 2);
1096 }
1097 OS << "\n]\n";
1098
1099 OS << "}";
1100}
1101
1105 llvm::MemoryBufferRef FromFile = SM.getBufferOrFake(SM.getMainFileID());
1106
1110 FromFile.getBuffer(), Tokens, Directives, &CI.getDiagnostics(),
1111 SM.getLocForStartOfFile(SM.getMainFileID()))) {
1112 assert(CI.getDiagnostics().hasErrorOccurred() &&
1113 "no errors reported for failure");
1114
1115 // Preprocess the source when verifying the diagnostics to capture the
1116 // 'expected' comments.
1117 if (CI.getDiagnosticOpts().VerifyDiagnostics) {
1118 // Make sure we don't emit new diagnostics!
1122 Token Tok;
1123 do {
1124 PP.Lex(Tok);
1125 } while (Tok.isNot(tok::eof));
1126 }
1127 return;
1128 }
1129 printDependencyDirectivesAsSource(FromFile.getBuffer(), Directives,
1130 llvm::outs());
1131}
1132
1133void GetDependenciesByModuleNameAction::ExecuteAction() {
1135 Preprocessor &PP = CI.getPreprocessor();
1137 FileID MainFileID = SM.getMainFileID();
1138 SourceLocation FileStart = SM.getLocForStartOfFile(MainFileID);
1140 IdentifierInfo *ModuleID = PP.getIdentifierInfo(ModuleName);
1141 Path.push_back(std::make_pair(ModuleID, FileStart));
1142 auto ModResult = CI.loadModule(FileStart, Path, Module::Hidden, false);
1143 PPCallbacks *CB = PP.getPPCallbacks();
1144 CB->moduleImport(SourceLocation(), Path, ModResult);
1145}
#define SM(sm)
Definition: Cuda.cpp:78
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:2774
#define DUMP_BOOLEAN(Value, Text)
static StringRef ModuleKindName(Module::ModuleKind MK)
llvm::raw_ostream & OS
Definition: Logger.cpp:24
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:684
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:113
virtual bool ReadFullVersionInformation(StringRef FullVersion)
Receives the full Clang version information.
Definition: ASTReader.h:121
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:1735
@ ARR_ConfigurationMismatch
The client can handle an AST file that cannot load because it's compiled configuration doesn't match ...
Definition: ASTReader.h:1595
unsigned getTotalNumSubmodules() const
Returns the number of submodules known.
Definition: ASTReader.h:1829
Module * getModule(unsigned ID) override
Retrieve the module that corresponds to the given module ID.
Definition: ASTReader.cpp:8754
static bool readASTFileControlBlock(StringRef Filename, FileManager &FileMgr, const InMemoryModuleCache &ModuleCache, const PCHContainerReader &PCHContainerRdr, bool FindModuleFileExtensions, ASTReaderListener &Listener, bool ValidateDiagnosticOptions)
Read the control block for the named AST file.
Definition: ASTReader.cpp:5230
Preprocessor & getPreprocessor() const
Retrieve the preprocessor.
Definition: ASTReader.h:1738
const LangOptions & getLangOpts() const
Definition: ASTUnit.h:462
IntrusiveRefCntPtr< ASTReader > getASTReader() const
Definition: ASTUnit.cpp:747
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:83
static Decl * castFromDeclContext(const DeclContext *)
Definition: DeclBase.cpp:931
SourceLocation getLocation() const
Definition: DeclBase.h:432
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1542
bool hasErrorOccurred() const
Definition: Diagnostic.h:838
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:692
llvm::raw_ostream * OutputStream
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(const FileEntry *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::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::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 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::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:223
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.
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:82
@ CMK_HeaderUnit
Compiling a module header unit.
Definition: LangOptions.h:115
@ CMK_ModuleInterface
Compiling a C++ modules interface unit.
Definition: LangOptions.h:118
std::string CurrentModule
The name of the current module, of which the main source file is a part.
Definition: LangOptions.h:437
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:443
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:588
Describes a module or submodule.
Definition: Module.h:98
SmallVector< ExportDecl, 2 > Exports
The set of export declarations.
Definition: Module.h:377
@ Hidden
All of the names in this module are hidden.
Definition: Module.h:351
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:454
ModuleKind Kind
The kind of this module.
Definition: Module.h:137
llvm::SmallSetVector< Module *, 2 > Imports
The set of modules imported by this module, and on which this module depends.
Definition: Module.h:364
std::string Name
The name of this module.
Definition: Module.h:101
llvm::iterator_range< submodule_iterator > submodules()
Definition: Module.h:731
@ ModuleMapModule
This is a module that was defined by a module map and built out of header files.
Definition: Module.h:109
@ ImplicitGlobalModuleFragment
This is an implicit fragment of the global module which contains only language linkage declarations (...
Definition: Module.h:133
@ ModulePartitionInterface
This is a C++ 20 module partition interface.
Definition: Module.h:118
@ ModuleInterfaceUnit
This is a C++20 module interface unit.
Definition: Module.h:112
@ ModuleHeaderUnit
This is a C++ 20 header unit.
Definition: Module.h:115
@ ModulePartitionImplementation
This is a C++ 20 module partition implementation.
Definition: Module.h:121
@ PrivateModuleFragment
This is the private module fragment within some C++ module.
Definition: Module.h:128
@ ExplicitGlobalModuleFragment
This is the explicit Global Module Fragment of a modular TU.
Definition: Module.h:125
This represents a decl that may have a name.
Definition: Decl.h:247
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:1788
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:177
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:2174
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:356
ASTContext & Context
Definition: Sema.h:407
const LangOptions & getLangOpts() const
Definition: Sema.h:1645
std::vector< std::unique_ptr< TemplateInstantiationCallback > > TemplateInstCallbacks
The template instantiation callbacks to trace or track instantiations (objects can be chained).
Definition: Sema.h:9440
SourceManager & getSourceManager() const
Definition: Sema.h:1650
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:35
bool isNot(tok::TokenKind K) const
Definition: Token.h:99
The base class of the type hierarchy.
Definition: Type.h:1566
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:122
std::string ModuleName
The name of the module.
Definition: ModuleFile.h:140
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
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:60
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:9214
static void mapping(IO &io, TemplightEntry &fields)