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"
37#include <system_error>
54 GetCodeCompletionConsumer(CI));
62std::unique_ptr<ASTConsumer>
64 return std::make_unique<ASTConsumer>();
67void InitOnlyAction::ExecuteAction() {
71void ReadPCHAndPreprocessAction::ExecuteAction() {
82 }
while (Tok.
isNot(tok::eof));
85std::unique_ptr<ASTConsumer>
88 return std::make_unique<ASTConsumer>();
95std::unique_ptr<ASTConsumer>
97 if (std::unique_ptr<raw_ostream> OS =
103std::unique_ptr<ASTConsumer>
112std::unique_ptr<ASTConsumer>
117std::unique_ptr<ASTConsumer>
122std::unique_ptr<ASTConsumer>
128 std::string OutputFile;
129 std::unique_ptr<raw_pwrite_stream> OS =
138 auto Buffer = std::make_shared<PCHBuffer>();
139 std::vector<std::unique_ptr<ASTConsumer>> Consumers;
140 Consumers.push_back(std::make_unique<PCHGenerator>(
142 FrontendOpts.ModuleFileExtensions,
144 FrontendOpts.IncludeTimestamps, FrontendOpts.BuildingImplicitModule,
147 CI, std::string(InFile), OutputFile, std::move(OS), Buffer));
149 return std::make_unique<MultiplexConsumer>(std::move(Consumers));
153 std::string &Sysroot) {
163std::unique_ptr<llvm::raw_pwrite_stream>
165 std::string &OutputFile) {
168 true, InFile,
"",
false);
187std::vector<std::unique_ptr<ASTConsumer>>
190 std::unique_ptr<raw_pwrite_stream> OS = CreateOutputFile(CI, InFile);
197 auto Buffer = std::make_shared<PCHBuffer>();
198 std::vector<std::unique_ptr<ASTConsumer>> Consumers;
200 Consumers.push_back(std::make_unique<PCHGenerator>(
212 CI, std::string(InFile), OutputFile, std::move(OS), Buffer));
216std::unique_ptr<ASTConsumer>
219 std::vector<std::unique_ptr<ASTConsumer>> Consumers =
221 if (Consumers.empty())
224 return std::make_unique<MultiplexConsumer>(std::move(Consumers));
232bool GenerateModuleFromModuleMapAction::BeginSourceFileAction(
242std::unique_ptr<raw_pwrite_stream>
249 if (ModuleMapFile.empty())
250 ModuleMapFile = InFile;
272std::unique_ptr<ASTConsumer>
275 std::vector<std::unique_ptr<ASTConsumer>> Consumers;
276 Consumers.push_back(std::make_unique<CXX20ModulesGenerator>(
282 Consumers.push_back(std::make_unique<ReducedBMIGenerator>(
287 return std::make_unique<MultiplexConsumer>(std::move(Consumers));
290std::unique_ptr<raw_pwrite_stream>
296std::unique_ptr<ASTConsumer>
297GenerateReducedModuleInterfaceAction::CreateASTConsumer(
CompilerInstance &CI,
313std::unique_ptr<raw_pwrite_stream>
322std::unique_ptr<ASTConsumer>
324 return std::make_unique<ASTConsumer>();
327std::unique_ptr<ASTConsumer>
330 return std::make_unique<ASTConsumer>();
333std::unique_ptr<ASTConsumer>
335 return std::make_unique<ASTConsumer>();
342 std::unique_ptr<ASTReader> Reader(
new ASTReader(
345 Sysroot.empty() ?
"" : Sysroot.c_str(),
359struct TemplightEntry {
363 std::string DefinitionLocation;
364 std::string PointOfInstantiation;
370template <>
struct MappingTraits<TemplightEntry> {
371 static void mapping(IO &io, TemplightEntry &fields) {
372 io.mapRequired(
"name", fields.Name);
373 io.mapRequired(
"kind", fields.Kind);
374 io.mapRequired(
"event", fields.Event);
375 io.mapRequired(
"orig", fields.DefinitionLocation);
376 io.mapRequired(
"poi", fields.PointOfInstantiation);
392 const CodeSynthesisContext &Inst)
override {
393 displayTemplightEntry<true>(llvm::outs(), TheSema, Inst);
397 const CodeSynthesisContext &Inst)
override {
398 displayTemplightEntry<false>(llvm::outs(), TheSema, Inst);
402 static std::string
toString(CodeSynthesisContext::SynthesisKind Kind) {
404 case CodeSynthesisContext::TemplateInstantiation:
405 return "TemplateInstantiation";
406 case CodeSynthesisContext::DefaultTemplateArgumentInstantiation:
407 return "DefaultTemplateArgumentInstantiation";
408 case CodeSynthesisContext::DefaultFunctionArgumentInstantiation:
409 return "DefaultFunctionArgumentInstantiation";
410 case CodeSynthesisContext::ExplicitTemplateArgumentSubstitution:
411 return "ExplicitTemplateArgumentSubstitution";
412 case CodeSynthesisContext::DeducedTemplateArgumentSubstitution:
413 return "DeducedTemplateArgumentSubstitution";
414 case CodeSynthesisContext::LambdaExpressionSubstitution:
415 return "LambdaExpressionSubstitution";
416 case CodeSynthesisContext::PriorTemplateArgumentSubstitution:
417 return "PriorTemplateArgumentSubstitution";
418 case CodeSynthesisContext::DefaultTemplateArgumentChecking:
419 return "DefaultTemplateArgumentChecking";
420 case CodeSynthesisContext::ExceptionSpecEvaluation:
421 return "ExceptionSpecEvaluation";
422 case CodeSynthesisContext::ExceptionSpecInstantiation:
423 return "ExceptionSpecInstantiation";
424 case CodeSynthesisContext::DeclaringSpecialMember:
425 return "DeclaringSpecialMember";
426 case CodeSynthesisContext::DeclaringImplicitEqualityComparison:
427 return "DeclaringImplicitEqualityComparison";
428 case CodeSynthesisContext::DefiningSynthesizedFunction:
429 return "DefiningSynthesizedFunction";
430 case CodeSynthesisContext::RewritingOperatorAsSpaceship:
431 return "RewritingOperatorAsSpaceship";
432 case CodeSynthesisContext::Memoization:
433 return "Memoization";
434 case CodeSynthesisContext::ConstraintsCheck:
435 return "ConstraintsCheck";
436 case CodeSynthesisContext::ConstraintSubstitution:
437 return "ConstraintSubstitution";
438 case CodeSynthesisContext::ConstraintNormalization:
439 return "ConstraintNormalization";
440 case CodeSynthesisContext::RequirementParameterInstantiation:
441 return "RequirementParameterInstantiation";
442 case CodeSynthesisContext::ParameterMappingSubstitution:
443 return "ParameterMappingSubstitution";
444 case CodeSynthesisContext::RequirementInstantiation:
445 return "RequirementInstantiation";
446 case CodeSynthesisContext::NestedRequirementConstraintsCheck:
447 return "NestedRequirementConstraintsCheck";
448 case CodeSynthesisContext::InitializingStructuredBinding:
449 return "InitializingStructuredBinding";
450 case CodeSynthesisContext::MarkingClassDllexported:
451 return "MarkingClassDllexported";
452 case CodeSynthesisContext::BuildingBuiltinDumpStructCall:
453 return "BuildingBuiltinDumpStructCall";
454 case CodeSynthesisContext::BuildingDeductionGuides:
455 return "BuildingDeductionGuides";
456 case CodeSynthesisContext::TypeAliasTemplateInstantiation:
457 return "TypeAliasTemplateInstantiation";
462 template <
bool BeginInstantiation>
463 static void displayTemplightEntry(llvm::raw_ostream &Out,
const Sema &TheSema,
464 const CodeSynthesisContext &Inst) {
467 llvm::raw_string_ostream OS(YAML);
468 llvm::yaml::Output YO(OS);
469 TemplightEntry Entry =
470 getTemplightEntry<BeginInstantiation>(TheSema, Inst);
471 llvm::yaml::EmptyContext Context;
472 llvm::yaml::yamlize(YO, Entry,
true, Context);
474 Out <<
"---" << YAML <<
"\n";
477 static void printEntryName(
const Sema &TheSema,
const Decl *Entity,
478 llvm::raw_string_ostream &OS) {
479 auto *NamedTemplate = cast<NamedDecl>(Entity);
484 NamedTemplate->getNameForDiagnostic(OS, Policy,
true);
486 if (!OS.str().empty())
490 NamedDecl *NamedCtx = dyn_cast_or_null<NamedDecl>(Ctx);
492 if (
const auto *
Decl = dyn_cast<TagDecl>(NamedTemplate)) {
493 if (
const auto *R = dyn_cast<RecordDecl>(
Decl)) {
500 OS <<
"unnamed " <<
Decl->getKindName();
504 assert(NamedCtx &&
"NamedCtx cannot be null");
506 if (
const auto *
Decl = dyn_cast<ParmVarDecl>(NamedTemplate)) {
507 OS <<
"unnamed function parameter " <<
Decl->getFunctionScopeIndex()
509 if (
Decl->getFunctionScopeDepth() > 0)
510 OS <<
"(at depth " <<
Decl->getFunctionScopeDepth() <<
") ";
516 if (
const auto *
Decl = dyn_cast<TemplateTypeParmDecl>(NamedTemplate)) {
517 if (
const Type *Ty =
Decl->getTypeForDecl()) {
518 if (
const auto *TTPT = dyn_cast_or_null<TemplateTypeParmType>(Ty)) {
519 OS <<
"unnamed template type parameter " << TTPT->getIndex() <<
" ";
520 if (TTPT->getDepth() > 0)
521 OS <<
"(at depth " << TTPT->getDepth() <<
") ";
529 if (
const auto *
Decl = dyn_cast<NonTypeTemplateParmDecl>(NamedTemplate)) {
530 OS <<
"unnamed template non-type parameter " <<
Decl->getIndex() <<
" ";
531 if (
Decl->getDepth() > 0)
532 OS <<
"(at depth " <<
Decl->getDepth() <<
") ";
538 if (
const auto *
Decl = dyn_cast<TemplateTemplateParmDecl>(NamedTemplate)) {
539 OS <<
"unnamed template template parameter " <<
Decl->getIndex() <<
" ";
540 if (
Decl->getDepth() > 0)
541 OS <<
"(at depth " <<
Decl->getDepth() <<
") ";
547 llvm_unreachable(
"Failed to retrieve a name for this entry!");
548 OS <<
"unnamed identifier";
551 template <
bool BeginInstantiation>
552 static TemplightEntry getTemplightEntry(
const Sema &TheSema,
553 const CodeSynthesisContext &Inst) {
554 TemplightEntry Entry;
556 Entry.Event = BeginInstantiation ?
"Begin" :
"End";
557 llvm::raw_string_ostream OS(Entry.Name);
558 printEntryName(TheSema, Inst.Entity, OS);
562 Entry.DefinitionLocation = std::string(DefLoc.
getFilename()) +
":" +
563 std::to_string(DefLoc.
getLine()) +
":" +
568 Entry.PointOfInstantiation = std::string(PoiLoc.
getFilename()) +
":" +
569 std::to_string(PoiLoc.
getLine()) +
":" +
577std::unique_ptr<ASTConsumer>
579 return std::make_unique<ASTConsumer>();
589 EnsureSemaIsCreated(CI, *
this);
592 std::make_unique<DefaultTemplateInstCallback>());
600 llvm::raw_ostream &Out;
603 DumpModuleInfoListener(llvm::raw_ostream &Out) : Out(Out) { }
605#define DUMP_BOOLEAN(Value, Text) \
606 Out.indent(4) << Text << ": " << (Value? "Yes" : "No") << "\n"
608 bool ReadFullVersionInformation(StringRef FullVersion)
override {
613 <<
" Clang: " << FullVersion <<
"\n";
617 void ReadModuleName(StringRef ModuleName)
override {
618 Out.indent(2) <<
"Module name: " << ModuleName <<
"\n";
620 void ReadModuleMapFile(StringRef ModuleMapPath)
override {
621 Out.indent(2) <<
"Module map file: " << ModuleMapPath <<
"\n";
624 bool ReadLanguageOptions(
const LangOptions &LangOpts,
bool Complain,
625 bool AllowCompatibleDifferences)
override {
626 Out.indent(2) <<
"Language options:\n";
627#define LANGOPT(Name, Bits, Default, Description) \
628 DUMP_BOOLEAN(LangOpts.Name, Description);
629#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
630 Out.indent(4) << Description << ": " \
631 << static_cast<unsigned>(LangOpts.get##Name()) << "\n";
632#define VALUE_LANGOPT(Name, Bits, Default, Description) \
633 Out.indent(4) << Description << ": " << LangOpts.Name << "\n";
634#define BENIGN_LANGOPT(Name, Bits, Default, Description)
635#define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
636#include "clang/Basic/LangOptions.def"
639 Out.indent(4) <<
"Module features:\n";
641 Out.indent(6) << Feature <<
"\n";
647 bool ReadTargetOptions(
const TargetOptions &TargetOpts,
bool Complain,
648 bool AllowCompatibleDifferences)
override {
649 Out.indent(2) <<
"Target options:\n";
650 Out.indent(4) <<
" Triple: " << TargetOpts.
Triple <<
"\n";
651 Out.indent(4) <<
" CPU: " << TargetOpts.
CPU <<
"\n";
652 Out.indent(4) <<
" TuneCPU: " << TargetOpts.
TuneCPU <<
"\n";
653 Out.indent(4) <<
" ABI: " << TargetOpts.
ABI <<
"\n";
656 Out.indent(4) <<
"Target features:\n";
667 bool Complain)
override {
668 Out.indent(2) <<
"Diagnostic options:\n";
669#define DIAGOPT(Name, Bits, Default) DUMP_BOOLEAN(DiagOpts->Name, #Name);
670#define ENUM_DIAGOPT(Name, Type, Bits, Default) \
671 Out.indent(4) << #Name << ": " << DiagOpts->get##Name() << "\n";
672#define VALUE_DIAGOPT(Name, Bits, Default) \
673 Out.indent(4) << #Name << ": " << DiagOpts->Name << "\n";
674#include "clang/Basic/DiagnosticOptions.def"
676 Out.indent(4) <<
"Diagnostic flags:\n";
677 for (
const std::string &
Warning : DiagOpts->Warnings)
678 Out.indent(6) <<
"-W" <<
Warning <<
"\n";
679 for (
const std::string &
Remark : DiagOpts->Remarks)
680 Out.indent(6) <<
"-R" <<
Remark <<
"\n";
686 StringRef SpecificModuleCachePath,
687 bool Complain)
override {
688 Out.indent(2) <<
"Header search options:\n";
689 Out.indent(4) <<
"System root [-isysroot=]: '" << HSOpts.
Sysroot <<
"'\n";
690 Out.indent(4) <<
"Resource dir [ -resource-dir=]: '" << HSOpts.
ResourceDir <<
"'\n";
691 Out.indent(4) <<
"Module Cache: '" << SpecificModuleCachePath <<
"'\n";
693 "Use builtin include directories [-nobuiltininc]");
695 "Use standard system include directories [-nostdinc]");
697 "Use standard C++ include directories [-nostdinc++]");
699 "Use libc++ (rather than libstdc++) [-stdlib=]");
704 bool Complain)
override {
705 Out.indent(2) <<
"Header search paths:\n";
706 Out.indent(4) <<
"User entries:\n";
708 Out.indent(6) << Entry.Path <<
"\n";
709 Out.indent(4) <<
"System header prefixes:\n";
711 Out.indent(6) << Prefix.Prefix <<
"\n";
712 Out.indent(4) <<
"VFS overlay files:\n";
714 Out.indent(6) << Overlay <<
"\n";
719 bool ReadMacros,
bool Complain,
720 std::string &SuggestedPredefines)
override {
721 Out.indent(2) <<
"Preprocessor options:\n";
723 "Uses compiler/target-specific predefines [-undef]");
725 "Uses detailed preprocessing record (for indexing)");
728 Out.indent(4) <<
"Predefined macros:\n";
731 for (std::vector<std::pair<std::string, bool/*isUndef*/> >::const_iterator
739 Out << I->first <<
"\n";
745 void readModuleFileExtension(
747 Out.indent(2) <<
"Module file extension '"
752 Out.write_escaped(Metadata.
UserInfo);
760 bool needsInputFileVisitation()
override {
return true; }
764 bool needsSystemInputFileVisitation()
override {
return true; }
769 bool visitInputFile(StringRef
Filename,
bool isSystem,
770 bool isOverridden,
bool isExplicitModule)
override {
772 Out.indent(2) <<
"Input file: " <<
Filename;
774 if (isSystem || isOverridden || isExplicitModule) {
778 if (isOverridden || isExplicitModule)
783 if (isExplicitModule)
786 if (isExplicitModule)
787 Out <<
"ExplicitModule";
799 bool needsImportVisitation()
const override {
return true; }
803 void visitImport(StringRef ModuleName, StringRef
Filename)
override {
804 Out.indent(2) <<
"Imports module '" << ModuleName
821 return "Module Map Module";
823 return "Interface Unit";
825 return "Implementation Unit";
827 return "Partition Interface";
829 return "Partition Implementation";
831 return "Header Unit";
833 return "Global Module Fragment";
835 return "Implicit Module Fragment";
837 return "Private Module Fragment";
839 llvm_unreachable(
"unknown module kind!");
847 if (!OutputFileName.empty() && OutputFileName !=
"-") {
849 OutputStream.reset(
new llvm::raw_fd_ostream(
850 OutputFileName.str(), EC, llvm::sys::fs::OF_TextWithCRLF));
852 llvm::raw_ostream &Out = OutputStream ? *OutputStream : llvm::outs();
854 Out <<
"Information for module file '" <<
getCurrentFile() <<
"':\n";
857 StringRef Magic = (*Buffer)->getMemBufferRef().getBuffer();
858 bool IsRaw = Magic.starts_with(
"CPCH");
859 Out <<
" Module format: " << (IsRaw ?
"raw" :
"obj") <<
"\n";
862 DumpModuleInfoListener Listener(Out);
874 Out <<
" ====== C++20 Module structure ======\n";
877 Out <<
" Mismatched module names : " << MF.
ModuleName <<
" and "
887 std::map<std::string, SubModInfo> SubModMap;
890 auto I = SubModMap.find(Name);
891 if (I == SubModMap.end())
892 Out <<
" was not found in the sub modules!\n";
894 I->second.Seen =
true;
895 Out <<
" is at index #" << I->second.Idx <<
"\n";
898 Module *Primary =
nullptr;
899 for (
unsigned Idx = 0; Idx <= SubModuleCount; ++Idx) {
906 <<
"' is the Primary Module at index #" << Idx <<
"\n";
907 SubModMap.insert({M->
Name, {Idx, M, M->
Kind, M->Name,
true}});
909 SubModMap.insert({M->
Name, {Idx, M, M->
Kind, M->Name,
false}});
913 Out <<
" Sub Modules:\n";
915 PrintSubMapEntry(MI->Name, MI->Kind);
918 Out <<
" Imports:\n";
919 for (
auto *IMP : Primary->
Imports) {
920 PrintSubMapEntry(IMP->Name, IMP->Kind);
923 Out <<
" Exports:\n";
924 for (
unsigned MN = 0, N = Primary->
Exports.size(); MN != N; ++MN) {
926 PrintSubMapEntry(M->Name, M->Kind);
934 if (
auto FilteredMacros = llvm::make_filter_range(
936 [](
const auto &Macro) { return Macro.first->isFromAST(); });
937 !FilteredMacros.empty()) {
938 Out <<
" Macro Definitions:\n";
939 for (
const auto &Macro :
941 Out <<
" " << Macro.first->getName() <<
"\n";
945 for (
const auto &
SM : SubModMap) {
946 if (!
SM.second.Seen &&
SM.second.Mod) {
948 <<
"' at index #" <<
SM.second.Idx
949 <<
" has no direct reference in the Primary\n";
952 Out <<
" ====== ======\n";
973 llvm::MemoryBufferRef FromFile =
SM.getBufferOrFake(
SM.getMainFileID());
979 while (RawTok.
isNot(tok::eof)) {
981 llvm::errs() <<
"\n";
994 llvm::errs() <<
"\n";
995 }
while (Tok.
isNot(tok::eof));
1009 }
while (Tok.
isNot(tok::eof));
1028 bool BinaryMode =
false;
1029 if (llvm::Triple(LLVM_HOST_TRIPLE).isOSWindows()) {
1032 if (std::optional<llvm::MemoryBufferRef> Buffer =
1033 SM.getBufferOrNone(
SM.getMainFileID())) {
1034 const char *cur = Buffer->getBufferStart();
1035 const char *end = Buffer->getBufferEnd();
1036 const char *next = (cur != end) ? cur + 1 : end;
1041 if (end - cur > 256)
1044 while (next < end) {
1050 }
else if (*cur == 0x0A)
1059 std::unique_ptr<raw_ostream> OS =
1067 if (Input.isFile()) {
1069 OS->write_escaped(Input.getFile());
1073 (*OS) <<
"#pragma clang module contents\n";
1111 llvm::outs().write((*Buffer)->getBufferStart(),
Preamble);
1115void DumpCompilerOptionsAction::ExecuteAction() {
1117 std::unique_ptr<raw_ostream> OSP =
1122 raw_ostream &OS = *OSP;
1132 OS <<
"\n\"features\" : [\n";
1135#define FEATURE(Name, Predicate) \
1136 ("\t{\"" #Name "\" : " + llvm::Twine(Predicate ? "true" : "false") + "},\n") \
1138#include "clang/Basic/Features.def"
1142 OS << Str.substr(0, Str.size() - 2);
1146 OS <<
"\n\"extensions\" : [\n";
1149#define EXTENSION(Name, Predicate) \
1150 ("\t{\"" #Name "\" : " + llvm::Twine(Predicate ? "true" : "false") + "},\n") \
1152#include "clang/Basic/Features.def"
1156 OS << Str.substr(0, Str.size() - 2);
1166 llvm::MemoryBufferRef FromFile =
SM.getBufferOrFake(
SM.getMainFileID());
1172 SM.getLocForStartOfFile(
SM.getMainFileID()))) {
1174 "no errors reported for failure");
1186 }
while (Tok.
isNot(tok::eof));
1194void GetDependenciesByModuleNameAction::ExecuteAction() {
1198 FileID MainFileID =
SM.getMainFileID();
1202 Path.push_back(std::make_pair(ModuleID, FileStart));
This is the interface for scanning header and source files to get the minimum necessary preprocessor ...
Defines the clang::FileManager interface and associated types.
#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
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.
virtual bool ReadFullVersionInformation(StringRef FullVersion)
Receives the full Clang version information.
Reads an AST files chain containing the contents of a translation unit.
ModuleManager & getModuleManager()
Retrieve the module manager.
@ ARR_ConfigurationMismatch
The client can handle an AST file that cannot load because it's compiled configuration doesn't match ...
unsigned getTotalNumSubmodules() const
Returns the number of submodules known.
Module * getModule(unsigned ID) override
Retrieve the module that corresponds to the given module ID.
static bool readASTFileControlBlock(StringRef Filename, FileManager &FileMgr, const InMemoryModuleCache &ModuleCache, const PCHContainerReader &PCHContainerRdr, bool FindModuleFileExtensions, ASTReaderListener &Listener, bool ValidateDiagnosticOptions, unsigned ClientLoadCapabilities=ARR_ConfigurationMismatch|ARR_OutOfDate)
Read the control block for the named AST file.
Preprocessor & getPreprocessor() const
Retrieve the preprocessor.
const LangOptions & getLangOpts() const
IntrusiveRefCntPtr< ASTReader > getASTReader() const
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.
static Decl * castFromDeclContext(const DeclContext *)
SourceLocation getLocation() const
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
bool hasErrorOccurred() const
void setSuppressAllDiagnostics(bool Val)
Suppress all diagnostics, to silence the front end when we know that we don't want any more diagnosti...
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.
unsigned GenReducedBMI
Whether to generate reduced BMI for C++20 named modules.
std::vector< std::shared_ptr< ModuleFileExtension > > ModuleFileExtensions
The list of module file extensions.
ParsedSourceLocation CodeCompletionAt
If given, enable code completion at the provided location.
std::string OriginalModuleMap
When the input is a module map, the original module map file from which that map was inferred,...
std::string ModuleOutputPath
Output Path for module output file.
unsigned ASTDumpDeclTypes
Whether we include declaration type dumps in AST dumps.
unsigned ASTDumpAll
Whether we deserialize all decls when forming AST dumps.
unsigned RelocatablePCH
When generating PCH files, instruct the AST writer to create relocatable PCH files.
unsigned ASTDumpDecls
Whether we include declaration dumps in AST dumps.
bool shouldEraseOutputFiles() override
Callback at the end of processing a single input, to determine if the output files should be erased o...
std::vector< std::unique_ptr< ASTConsumer > > CreateMultiplexConsumer(CompilerInstance &CI, StringRef InFile)
std::unique_ptr< ASTConsumer > CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override
Create the AST consumer object for this action, if supported.
bool BeginSourceFileAction(CompilerInstance &CI) override
Callback at the start of processing a single input.
std::unique_ptr< raw_pwrite_stream > CreateOutputFile(CompilerInstance &CI, StringRef InFile) override
std::unique_ptr< ASTConsumer > CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override
Create the AST consumer object for this action, if supported.
static std::unique_ptr< llvm::raw_pwrite_stream > CreateOutputFile(CompilerInstance &CI, StringRef InFile, std::string &OutputFile)
Creates file to write the PCH into and returns a stream to write it into.
bool BeginSourceFileAction(CompilerInstance &CI) override
Callback at the start of processing a single input.
static bool ComputeASTConsumerArguments(CompilerInstance &CI, std::string &Sysroot)
Compute the AST consumer arguments that will be used to create the PCHGenerator instance returned by ...
std::unique_ptr< ASTConsumer > CreateASTConsumer(CompilerInstance &CI, StringRef InFile) override
Create the AST consumer object for this action, if supported.
bool shouldEraseOutputFiles() override
Callback at the end of processing a single input, to determine if the output files should be erased o...
One of these records is kept for each identifier that is lexed.
@ CMK_HeaderUnit
Compiling a module header unit.
@ CMK_ModuleInterface
Compiling a C++ modules interface unit.
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
std::string CurrentModule
The name of the current module, of which the main source file is a part.
std::vector< std::string > ModuleFeatures
The names of any features to enable in module 'requires' decls in addition to the hard-coded list in ...
Lexer - This provides a simple interface that turns a text buffer into a stream of tokens.
void SetKeepWhitespaceMode(bool Val)
SetKeepWhitespaceMode - This method lets clients enable or disable whitespace retention mode.
bool LexFromRawLexer(Token &Result)
LexFromRawLexer - Lex a token from a designated raw lexer (one with no associated preprocessor object...
static PreambleBounds ComputePreamble(StringRef Buffer, const LangOptions &LangOpts, unsigned MaxLines=0)
Compute the preamble of the given file.
Describes a module or submodule.
SmallVector< ExportDecl, 2 > Exports
The set of export declarations.
@ Hidden
All of the names in this module are hidden.
void print(raw_ostream &OS, unsigned Indent=0, bool Dump=false) const
Print the module map for this module to the given stream.
ModuleKind Kind
The kind of this module.
llvm::SmallSetVector< Module *, 2 > Imports
The set of modules imported by this module, and on which this module depends.
std::string Name
The name of this module.
llvm::iterator_range< submodule_iterator > submodules()
@ ModuleImplementationUnit
This is a C++20 module implementation unit.
@ ModuleMapModule
This is a module that was defined by a module map and built out of header files.
@ ImplicitGlobalModuleFragment
This is an implicit fragment of the global module which contains only language linkage declarations (...
@ ModulePartitionInterface
This is a C++20 module partition interface.
@ ModuleInterfaceUnit
This is a C++20 module interface unit.
@ ModuleHeaderUnit
This is a C++20 header unit.
@ ModulePartitionImplementation
This is a C++20 module partition implementation.
@ PrivateModuleFragment
This is the private module fragment within some C++ module.
@ ExplicitGlobalModuleFragment
This is the explicit Global Module Fragment of a modular TU.
This represents a decl that may have a name.
virtual void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const
Appends a human-readable name for this declaration into the given stream.
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.
virtual void moduleImport(SourceLocation ImportLoc, ModuleIdPath Path, const Module *Imported)
Callback invoked whenever there was an explicit module-import syntax.
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.
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).
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.
const LangOptions & getLangOpts() const
std::vector< std::unique_ptr< TemplateInstantiationCallback > > TemplateInstCallbacks
The template instantiation callbacks to trace or track instantiations (objects can be chained).
SourceManager & getSourceManager() const
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.
~SyntaxOnlyAction() override
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.
std::string Triple
The name of the target triple to compile for.
std::string ABI
If given, the name of the target ABI to use.
std::string TuneCPU
If given, the name of the target CPU to tune code for.
std::string CPU
If given, the name of the target CPU to generate code for.
std::vector< std::string > FeaturesAsWritten
The list of target specific features to enable or disable, as written on the command line.
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.
bool isNot(tok::TokenKind K) const
The base class of the type hierarchy.
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.
std::string ModuleName
The name of the module.
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.
@ MK_Preamble
File is a PCH file treated as the preamble.
The JSON file list parser is used to communicate input to InstallAPI.
void atTemplateEnd(TemplateInstantiationCallbackPtrs &Callbacks, const Sema &TheSema, const Sema::CodeSynthesisContext &Inst)
void atTemplateBegin(TemplateInstantiationCallbackPtrs &Callbacks, const Sema &TheSema, const Sema::CodeSynthesisContext &Inst)
void printDependencyDirectivesAsSource(StringRef Source, ArrayRef< dependency_directives_scan::Directive > Directives, llvm::raw_ostream &OS)
Print the previously scanned dependency directives as minimized source text.
void initialize(TemplateInstantiationCallbackPtrs &Callbacks, const Sema &TheSema)
bool scanSourceForDependencyDirectives(StringRef Input, SmallVectorImpl< dependency_directives_scan::Token > &Tokens, SmallVectorImpl< dependency_directives_scan::Directive > &Directives, DiagnosticsEngine *Diags=nullptr, SourceLocation InputSourceLoc=SourceLocation())
Scan the input for the preprocessor directives that might have an effect on the dependencies for a co...
std::unique_ptr< ASTConsumer > CreateASTDeclNodeLister()
@ C
Languages that the frontend can parse and compile.
@ CIR
LLVM IR & CIR: we accept these so that we can run the optimizer on them, and compile them to assembly...
@ Asm
Assembly: we accept this only so that we can preprocess it.
void DoPrintPreprocessedInput(Preprocessor &PP, raw_ostream *OS, const PreprocessorOutputOptions &Opts)
DoPrintPreprocessedInput - Implement -E mode.
std::unique_ptr< ASTConsumer > CreateASTDumper(std::unique_ptr< raw_ostream > OS, StringRef FilterString, bool DumpDecls, bool Deserialize, bool DumpLookups, bool DumpDeclTypes, ASTDumpOutputFormat Format)
std::unique_ptr< ASTConsumer > CreateASTPrinter(std::unique_ptr< raw_ostream > OS, StringRef FilterString)
std::unique_ptr< ASTConsumer > CreateASTViewer()
@ None
Perform validation, don't disable it.
std::string getClangFullRepositoryVersion()
Retrieves the full repository version that is an amalgamation of the information in getClangRepositor...
void finalize(TemplateInstantiationCallbackPtrs &Callbacks, const Sema &TheSema)
Diagnostic wrappers for TextAPI types for error reporting.
unsigned Size
Size of the preamble in bytes.
Describes how types, statements, expressions, and declarations should be printed.
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...
static void mapping(IO &io, TemplightEntry &fields)