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