30#include "llvm/Config/llvm-config.h"
31#include "llvm/Support/ErrorHandling.h"
32#include "llvm/Support/FileSystem.h"
33#include "llvm/Support/MemoryBuffer.h"
34#include "llvm/Support/YAMLTraits.h"
35#include "llvm/Support/raw_ostream.h"
38#include <system_error>
55 GetCodeCompletionConsumer(CI));
63std::unique_ptr<ASTConsumer>
65 return std::make_unique<ASTConsumer>();
68void InitOnlyAction::ExecuteAction() {
72void ReadPCHAndPreprocessAction::ExecuteAction() {
83 }
while (Tok.
isNot(tok::eof));
86std::unique_ptr<ASTConsumer>
89 return std::make_unique<ASTConsumer>();
96std::unique_ptr<ASTConsumer>
98 if (std::unique_ptr<raw_ostream> OS =
104std::unique_ptr<ASTConsumer>
113std::unique_ptr<ASTConsumer>
118std::unique_ptr<ASTConsumer>
123std::unique_ptr<ASTConsumer>
129 std::string OutputFile;
130 std::unique_ptr<raw_pwrite_stream> OS =
139 auto Buffer = std::make_shared<PCHBuffer>();
140 std::vector<std::unique_ptr<ASTConsumer>> Consumers;
141 Consumers.push_back(std::make_unique<PCHGenerator>(
145 FrontendOpts.IncludeTimestamps, FrontendOpts.BuildingImplicitModule,
148 CI, std::string(InFile), OutputFile, std::move(OS), Buffer));
150 return std::make_unique<MultiplexConsumer>(std::move(Consumers));
154 std::string &Sysroot) {
164std::unique_ptr<llvm::raw_pwrite_stream>
166 std::string &OutputFile) {
169 true, InFile,
"",
false);
188std::vector<std::unique_ptr<ASTConsumer>>
191 std::unique_ptr<raw_pwrite_stream> OS = CreateOutputFile(CI, InFile);
198 auto Buffer = std::make_shared<PCHBuffer>();
199 std::vector<std::unique_ptr<ASTConsumer>> Consumers;
201 Consumers.push_back(std::make_unique<PCHGenerator>(
213 CI, std::string(InFile), OutputFile, std::move(OS), Buffer));
217std::unique_ptr<ASTConsumer>
220 std::vector<std::unique_ptr<ASTConsumer>> Consumers =
222 if (Consumers.empty())
225 return std::make_unique<MultiplexConsumer>(std::move(Consumers));
233bool GenerateModuleFromModuleMapAction::BeginSourceFileAction(
243std::unique_ptr<raw_pwrite_stream>
250 if (ModuleMapFile.empty())
251 ModuleMapFile = InFile;
269 if (
const auto InputFormat = FIF.getKind().getFormat();
272 diag::err_frontend_action_unsupported_input_format)
273 <<
"module interface compilation" << FIF.getFile() << InputFormat;
287std::unique_ptr<ASTConsumer>
290 std::vector<std::unique_ptr<ASTConsumer>> Consumers;
294 Consumers.push_back(std::make_unique<ReducedBMIGenerator>(
300 Consumers.push_back(std::make_unique<CXX20ModulesGenerator>(
305 return std::make_unique<MultiplexConsumer>(std::move(Consumers));
308std::unique_ptr<raw_pwrite_stream>
314std::unique_ptr<ASTConsumer>
315GenerateReducedModuleInterfaceAction::CreateASTConsumer(
CompilerInstance &CI,
317 return std::make_unique<ReducedBMIGenerator>(
331std::unique_ptr<raw_pwrite_stream>
340std::unique_ptr<ASTConsumer>
342 return std::make_unique<ASTConsumer>();
345std::unique_ptr<ASTConsumer>
348 return std::make_unique<ASTConsumer>();
351std::unique_ptr<ASTConsumer>
353 return std::make_unique<ASTConsumer>();
360 std::unique_ptr<ASTReader> Reader(
new ASTReader(
364 Sysroot.empty() ?
"" : Sysroot.c_str(),
378struct TemplightEntry {
382 std::string DefinitionLocation;
383 std::string PointOfInstantiation;
389template <>
struct MappingTraits<TemplightEntry> {
390 static void mapping(IO &io, TemplightEntry &fields) {
391 io.mapRequired(
"name", fields.Name);
392 io.mapRequired(
"kind", fields.Kind);
393 io.mapRequired(
"event", fields.Event);
394 io.mapRequired(
"orig", fields.DefinitionLocation);
395 io.mapRequired(
"poi", fields.PointOfInstantiation);
411 const CodeSynthesisContext &Inst)
override {
412 displayTemplightEntry<true>(llvm::outs(), TheSema, Inst);
416 const CodeSynthesisContext &Inst)
override {
417 displayTemplightEntry<false>(llvm::outs(), TheSema, Inst);
421 static std::string
toString(CodeSynthesisContext::SynthesisKind
Kind) {
423 case CodeSynthesisContext::TemplateInstantiation:
424 return "TemplateInstantiation";
425 case CodeSynthesisContext::DefaultTemplateArgumentInstantiation:
426 return "DefaultTemplateArgumentInstantiation";
427 case CodeSynthesisContext::DefaultFunctionArgumentInstantiation:
428 return "DefaultFunctionArgumentInstantiation";
429 case CodeSynthesisContext::ExplicitTemplateArgumentSubstitution:
430 return "ExplicitTemplateArgumentSubstitution";
431 case CodeSynthesisContext::DeducedTemplateArgumentSubstitution:
432 return "DeducedTemplateArgumentSubstitution";
433 case CodeSynthesisContext::LambdaExpressionSubstitution:
434 return "LambdaExpressionSubstitution";
435 case CodeSynthesisContext::PriorTemplateArgumentSubstitution:
436 return "PriorTemplateArgumentSubstitution";
437 case CodeSynthesisContext::DefaultTemplateArgumentChecking:
438 return "DefaultTemplateArgumentChecking";
439 case CodeSynthesisContext::ExceptionSpecEvaluation:
440 return "ExceptionSpecEvaluation";
441 case CodeSynthesisContext::ExceptionSpecInstantiation:
442 return "ExceptionSpecInstantiation";
443 case CodeSynthesisContext::DeclaringSpecialMember:
444 return "DeclaringSpecialMember";
445 case CodeSynthesisContext::DeclaringImplicitEqualityComparison:
446 return "DeclaringImplicitEqualityComparison";
447 case CodeSynthesisContext::DefiningSynthesizedFunction:
448 return "DefiningSynthesizedFunction";
449 case CodeSynthesisContext::RewritingOperatorAsSpaceship:
450 return "RewritingOperatorAsSpaceship";
451 case CodeSynthesisContext::Memoization:
452 return "Memoization";
453 case CodeSynthesisContext::ConstraintsCheck:
454 return "ConstraintsCheck";
455 case CodeSynthesisContext::ConstraintSubstitution:
456 return "ConstraintSubstitution";
457 case CodeSynthesisContext::ConstraintNormalization:
458 return "ConstraintNormalization";
459 case CodeSynthesisContext::RequirementParameterInstantiation:
460 return "RequirementParameterInstantiation";
461 case CodeSynthesisContext::ParameterMappingSubstitution:
462 return "ParameterMappingSubstitution";
463 case CodeSynthesisContext::RequirementInstantiation:
464 return "RequirementInstantiation";
465 case CodeSynthesisContext::NestedRequirementConstraintsCheck:
466 return "NestedRequirementConstraintsCheck";
467 case CodeSynthesisContext::InitializingStructuredBinding:
468 return "InitializingStructuredBinding";
469 case CodeSynthesisContext::MarkingClassDllexported:
470 return "MarkingClassDllexported";
471 case CodeSynthesisContext::BuildingBuiltinDumpStructCall:
472 return "BuildingBuiltinDumpStructCall";
473 case CodeSynthesisContext::BuildingDeductionGuides:
474 return "BuildingDeductionGuides";
475 case CodeSynthesisContext::TypeAliasTemplateInstantiation:
476 return "TypeAliasTemplateInstantiation";
477 case CodeSynthesisContext::PartialOrderingTTP:
478 return "PartialOrderingTTP";
483 template <
bool BeginInstantiation>
484 static void displayTemplightEntry(llvm::raw_ostream &Out,
const Sema &TheSema,
485 const CodeSynthesisContext &Inst) {
488 llvm::raw_string_ostream OS(YAML);
489 llvm::yaml::Output YO(OS);
490 TemplightEntry Entry =
491 getTemplightEntry<BeginInstantiation>(TheSema, Inst);
492 llvm::yaml::EmptyContext Context;
493 llvm::yaml::yamlize(YO, Entry,
true, Context);
495 Out <<
"---" << YAML <<
"\n";
498 static void printEntryName(
const Sema &TheSema,
const Decl *Entity,
499 llvm::raw_string_ostream &OS) {
500 auto *NamedTemplate = cast<NamedDecl>(Entity);
505 NamedTemplate->getNameForDiagnostic(OS, Policy,
true);
507 if (!OS.str().empty())
511 NamedDecl *NamedCtx = dyn_cast_or_null<NamedDecl>(Ctx);
513 if (
const auto *
Decl = dyn_cast<TagDecl>(NamedTemplate)) {
514 if (
const auto *R = dyn_cast<RecordDecl>(
Decl)) {
521 OS <<
"unnamed " <<
Decl->getKindName();
525 assert(NamedCtx &&
"NamedCtx cannot be null");
527 if (
const auto *
Decl = dyn_cast<ParmVarDecl>(NamedTemplate)) {
528 OS <<
"unnamed function parameter " <<
Decl->getFunctionScopeIndex()
530 if (
Decl->getFunctionScopeDepth() > 0)
531 OS <<
"(at depth " <<
Decl->getFunctionScopeDepth() <<
") ";
537 if (
const auto *
Decl = dyn_cast<TemplateTypeParmDecl>(NamedTemplate)) {
538 if (
const Type *Ty =
Decl->getTypeForDecl()) {
539 if (
const auto *TTPT = dyn_cast_or_null<TemplateTypeParmType>(Ty)) {
540 OS <<
"unnamed template type parameter " << TTPT->getIndex() <<
" ";
541 if (TTPT->getDepth() > 0)
542 OS <<
"(at depth " << TTPT->getDepth() <<
") ";
550 if (
const auto *
Decl = dyn_cast<NonTypeTemplateParmDecl>(NamedTemplate)) {
551 OS <<
"unnamed template non-type parameter " <<
Decl->getIndex() <<
" ";
552 if (
Decl->getDepth() > 0)
553 OS <<
"(at depth " <<
Decl->getDepth() <<
") ";
559 if (
const auto *
Decl = dyn_cast<TemplateTemplateParmDecl>(NamedTemplate)) {
560 OS <<
"unnamed template template parameter " <<
Decl->getIndex() <<
" ";
561 if (
Decl->getDepth() > 0)
562 OS <<
"(at depth " <<
Decl->getDepth() <<
") ";
568 llvm_unreachable(
"Failed to retrieve a name for this entry!");
569 OS <<
"unnamed identifier";
572 template <
bool BeginInstantiation>
573 static TemplightEntry getTemplightEntry(
const Sema &TheSema,
574 const CodeSynthesisContext &Inst) {
575 TemplightEntry Entry;
577 Entry.Event = BeginInstantiation ?
"Begin" :
"End";
578 llvm::raw_string_ostream OS(Entry.Name);
579 printEntryName(TheSema, Inst.Entity, OS);
583 Entry.DefinitionLocation = std::string(DefLoc.
getFilename()) +
":" +
584 std::to_string(DefLoc.
getLine()) +
":" +
589 Entry.PointOfInstantiation = std::string(PoiLoc.
getFilename()) +
":" +
590 std::to_string(PoiLoc.
getLine()) +
":" +
598std::unique_ptr<ASTConsumer>
600 return std::make_unique<ASTConsumer>();
610 EnsureSemaIsCreated(CI, *
this);
613 std::make_unique<DefaultTemplateInstCallback>());
621 llvm::raw_ostream &Out;
624 DumpModuleInfoListener(llvm::raw_ostream &Out) : Out(Out) { }
626#define DUMP_BOOLEAN(Value, Text) \
627 Out.indent(4) << Text << ": " << (Value? "Yes" : "No") << "\n"
629 bool ReadFullVersionInformation(StringRef FullVersion)
override {
634 <<
" Clang: " << FullVersion <<
"\n";
638 void ReadModuleName(StringRef ModuleName)
override {
639 Out.indent(2) <<
"Module name: " << ModuleName <<
"\n";
641 void ReadModuleMapFile(StringRef ModuleMapPath)
override {
642 Out.indent(2) <<
"Module map file: " << ModuleMapPath <<
"\n";
645 bool ReadLanguageOptions(
const LangOptions &LangOpts,
646 StringRef ModuleFilename,
bool Complain,
647 bool AllowCompatibleDifferences)
override {
651 Out.indent(2) <<
"Language options:\n";
652#define LANGOPT(Name, Bits, Default, Compatibility, Description) \
653 if constexpr (CK::Compatibility != CK::Benign) \
654 DUMP_BOOLEAN(LangOpts.Name, Description);
655#define ENUM_LANGOPT(Name, Type, Bits, Default, Compatibility, Description) \
656 if constexpr (CK::Compatibility != CK::Benign) \
657 Out.indent(4) << Description << ": " \
658 << static_cast<unsigned>(LangOpts.get##Name()) << "\n";
659#define VALUE_LANGOPT(Name, Bits, Default, Compatibility, Description) \
660 if constexpr (CK::Compatibility != CK::Benign) \
661 Out.indent(4) << Description << ": " << LangOpts.Name << "\n";
662#include "clang/Basic/LangOptions.def"
665 Out.indent(4) <<
"Module features:\n";
667 Out.indent(6) <<
Feature <<
"\n";
674 StringRef ModuleFilename,
bool Complain,
675 bool AllowCompatibleDifferences)
override {
676 Out.indent(2) <<
"Target options:\n";
677 Out.indent(4) <<
" Triple: " << TargetOpts.
Triple <<
"\n";
678 Out.indent(4) <<
" CPU: " << TargetOpts.
CPU <<
"\n";
679 Out.indent(4) <<
" TuneCPU: " << TargetOpts.
TuneCPU <<
"\n";
680 Out.indent(4) <<
" ABI: " << TargetOpts.
ABI <<
"\n";
683 Out.indent(4) <<
"Target features:\n";
694 StringRef ModuleFilename,
695 bool Complain)
override {
696 Out.indent(2) <<
"Diagnostic options:\n";
697#define DIAGOPT(Name, Bits, Default) DUMP_BOOLEAN(DiagOpts.Name, #Name);
698#define ENUM_DIAGOPT(Name, Type, Bits, Default) \
699 Out.indent(4) << #Name << ": " << DiagOpts.get##Name() << "\n";
700#define VALUE_DIAGOPT(Name, Bits, Default) \
701 Out.indent(4) << #Name << ": " << DiagOpts.Name << "\n";
702#include "clang/Basic/DiagnosticOptions.def"
704 Out.indent(4) <<
"Diagnostic flags:\n";
706 Out.indent(6) <<
"-W" <<
Warning <<
"\n";
708 Out.indent(6) <<
"-R" <<
Remark <<
"\n";
714 StringRef ModuleFilename,
715 StringRef SpecificModuleCachePath,
716 bool Complain)
override {
717 Out.indent(2) <<
"Header search options:\n";
718 Out.indent(4) <<
"System root [-isysroot=]: '" << HSOpts.
Sysroot <<
"'\n";
719 Out.indent(4) <<
"Resource dir [ -resource-dir=]: '" << HSOpts.
ResourceDir <<
"'\n";
720 Out.indent(4) <<
"Module Cache: '" << SpecificModuleCachePath <<
"'\n";
722 "Use builtin include directories [-nobuiltininc]");
724 "Use standard system include directories [-nostdinc]");
726 "Use standard C++ include directories [-nostdinc++]");
728 "Use libc++ (rather than libstdc++) [-stdlib=]");
733 bool Complain)
override {
734 Out.indent(2) <<
"Header search paths:\n";
735 Out.indent(4) <<
"User entries:\n";
737 Out.indent(6) << Entry.Path <<
"\n";
738 Out.indent(4) <<
"System header prefixes:\n";
740 Out.indent(6) << Prefix.Prefix <<
"\n";
741 Out.indent(4) <<
"VFS overlay files:\n";
743 Out.indent(6) << Overlay <<
"\n";
748 StringRef ModuleFilename,
bool ReadMacros,
750 std::string &SuggestedPredefines)
override {
751 Out.indent(2) <<
"Preprocessor options:\n";
753 "Uses compiler/target-specific predefines [-undef]");
755 "Uses detailed preprocessing record (for indexing)");
758 Out.indent(4) <<
"Predefined macros:\n";
761 for (std::vector<std::pair<std::string, bool/*isUndef*/> >::const_iterator
769 Out << I->first <<
"\n";
775 void readModuleFileExtension(
777 Out.indent(2) <<
"Module file extension '"
782 Out.write_escaped(Metadata.
UserInfo);
790 bool needsInputFileVisitation()
override {
return true; }
794 bool needsSystemInputFileVisitation()
override {
return true; }
799 bool visitInputFile(StringRef FilenameAsRequested, StringRef
Filename,
800 bool isSystem,
bool isOverridden,
801 bool isExplicitModule)
override {
803 Out.indent(2) <<
"Input file: " << FilenameAsRequested;
805 if (isSystem || isOverridden || isExplicitModule) {
809 if (isOverridden || isExplicitModule)
814 if (isExplicitModule)
817 if (isExplicitModule)
818 Out <<
"ExplicitModule";
830 bool needsImportVisitation()
const override {
return true; }
834 void visitImport(StringRef ModuleName, StringRef
Filename)
override {
835 Out.indent(2) <<
"Imports module '" << ModuleName
852 return "Module Map Module";
854 return "Interface Unit";
856 return "Implementation Unit";
858 return "Partition Interface";
860 return "Partition Implementation";
862 return "Header Unit";
864 return "Global Module Fragment";
866 return "Implicit Module Fragment";
868 return "Private Module Fragment";
870 llvm_unreachable(
"unknown module kind!");
885 if (!OutputFileName.empty() && OutputFileName !=
"-") {
887 OutputStream.reset(
new llvm::raw_fd_ostream(
888 OutputFileName.str(), EC, llvm::sys::fs::OF_TextWithCRLF));
890 llvm::raw_ostream &Out = OutputStream ? *OutputStream : llvm::outs();
892 Out <<
"Information for module file '" <<
getCurrentFile() <<
"':\n";
895 StringRef Magic = (*Buffer)->getMemBufferRef().getBuffer();
896 bool IsRaw = Magic.starts_with(
"CPCH");
897 Out <<
" Module format: " << (IsRaw ?
"raw" :
"obj") <<
"\n";
900 DumpModuleInfoListener Listener(Out);
902 PP.getHeaderSearchInfo().getHeaderSearchOpts();
913 Out <<
" ====== C++20 Module structure ======\n";
916 Out <<
" Mismatched module names : " << MF.
ModuleName <<
" and "
926 std::map<std::string, SubModInfo> SubModMap;
929 auto I = SubModMap.find(Name);
930 if (I == SubModMap.end())
931 Out <<
" was not found in the sub modules!\n";
933 I->second.Seen =
true;
934 Out <<
" is at index #" << I->second.Idx <<
"\n";
937 Module *Primary =
nullptr;
938 for (
unsigned Idx = 0; Idx <= SubModuleCount; ++Idx) {
945 <<
"' is the Primary Module at index #" << Idx <<
"\n";
946 SubModMap.insert({M->
Name, {Idx, M, M->
Kind, M->Name,
true}});
948 SubModMap.insert({M->
Name, {Idx, M, M->
Kind, M->Name,
false}});
952 Out <<
" Sub Modules:\n";
954 PrintSubMapEntry(MI->Name, MI->Kind);
957 Out <<
" Imports:\n";
958 for (
auto *IMP : Primary->
Imports) {
959 PrintSubMapEntry(IMP->Name, IMP->Kind);
962 Out <<
" Exports:\n";
963 for (
unsigned MN = 0, N = Primary->
Exports.size(); MN != N; ++MN) {
965 PrintSubMapEntry(M->Name, M->Kind);
973 if (
auto FilteredMacros = llvm::make_filter_range(
975 [](
const auto &
Macro) { return Macro.first->isFromAST(); });
976 !FilteredMacros.empty()) {
977 Out <<
" Macro Definitions:\n";
978 for (
const auto &
Macro :
980 Out <<
" " <<
Macro.first->getName() <<
"\n";
984 for (
const auto &
SM : SubModMap) {
985 if (!
SM.second.Seen &&
SM.second.Mod) {
987 <<
"' at index #" <<
SM.second.Idx
988 <<
" has no direct reference in the Primary\n";
991 Out <<
" ====== ======\n";
1012 llvm::MemoryBufferRef FromFile =
SM.getBufferOrFake(
SM.getMainFileID());
1018 while (RawTok.
isNot(tok::eof)) {
1020 llvm::errs() <<
"\n";
1033 llvm::errs() <<
"\n";
1034 }
while (Tok.
isNot(tok::eof));
1048 }
while (Tok.
isNot(tok::eof));
1067 bool BinaryMode =
false;
1068 if (llvm::Triple(LLVM_HOST_TRIPLE).isOSWindows()) {
1071 if (std::optional<llvm::MemoryBufferRef> Buffer =
1072 SM.getBufferOrNone(
SM.getMainFileID())) {
1073 const char *cur = Buffer->getBufferStart();
1074 const char *end = Buffer->getBufferEnd();
1075 const char *next = (cur != end) ? cur + 1 : end;
1080 if (end - cur > 256)
1083 while (next < end) {
1089 }
else if (*cur == 0x0A)
1098 std::unique_ptr<raw_ostream> OS =
1106 if (Input.isFile()) {
1108 OS->write_escaped(Input.getFile());
1112 (*OS) <<
"#pragma clang module contents\n";
1149 llvm::outs().write((*Buffer)->getBufferStart(),
Preamble);
1153void DumpCompilerOptionsAction::ExecuteAction() {
1155 std::unique_ptr<raw_ostream> OSP =
1160 raw_ostream &OS = *OSP;
1170 OS <<
"\n\"features\" : [\n";
1173#define FEATURE(Name, Predicate) \
1174 ("\t{\"" #Name "\" : " + llvm::Twine(Predicate ? "true" : "false") + "},\n") \
1176#include "clang/Basic/Features.def"
1180 OS << Str.substr(0, Str.size() - 2);
1184 OS <<
"\n\"extensions\" : [\n";
1187#define EXTENSION(Name, Predicate) \
1188 ("\t{\"" #Name "\" : " + llvm::Twine(Predicate ? "true" : "false") + "},\n") \
1190#include "clang/Basic/Features.def"
1194 OS << Str.substr(0, Str.size() - 2);
1204 llvm::MemoryBufferRef FromFile =
SM.getBufferOrFake(
SM.getMainFileID());
1210 SM.getLocForStartOfFile(
SM.getMainFileID()))) {
1212 "no errors reported for failure");
1224 }
while (Tok.
isNot(tok::eof));
1232void GetDependenciesByModuleNameAction::ExecuteAction() {
1236 FileID MainFileID =
SM.getMainFileID();
1240 Path.emplace_back(FileStart, ModuleID);
1253 StringRef RootSigName;
1254 llvm::dxbc::RootSignatureVersion Version;
1256 std::optional<StringLiteral *> processStringLiteral(
ArrayRef<Token> Tokens) {
1257 for (
Token Tok : Tokens)
1259 return std::nullopt;
1263 return std::nullopt;
1265 if (
auto Signature = dyn_cast<StringLiteral>(StringResult.
get()))
1268 return std::nullopt;
1278 auto Signature = processStringLiteral(MI->
tokens());
1279 if (!Signature.has_value()) {
1281 diag::err_expected_string_literal)
1282 << 4 <<
"RootSignature";
1287 hlsl::ParseHLSLRootSignature(Actions, Version, *Signature);
1292 llvm::dxbc::RootSignatureVersion Version)
1293 :
PPCallbacks(), Actions(Actions), RootSigName(RootSigName),
1314 auto MacroCallback = std::make_unique<InjectRootSignatureCallback>(
1325 std::unique_ptr<FrontendAction> WrappedAction)
enum clang::sema::@1840::IndirectLocalPathEntry::EntryKind Kind
This is the interface for scanning header and source files to get the minimum necessary preprocessor ...
Defines the clang::FileManager interface and associated types.
#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.
void MacroDefined(const Token &MacroNameTok, const MacroDirective *MD) override
Hook called whenever a macro definition is seen.
InjectRootSignatureCallback(Sema &Actions, StringRef RootSigName, llvm::dxbc::RootSignatureVersion Version)
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 ModuleCache &ModCache, 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()
ModuleCache & getModuleCache() const
bool hasASTContext() 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()
CodeGenOptions & getCodeGenOpts()
SourceManager & getSourceManager() const
Return the current source manager.
CodeCompleteConsumer & getCodeCompletionConsumer() const
bool hasPreprocessor() 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
Options for controlling the compiler diagnostics engine.
std::vector< std::string > Remarks
The list of -R... options used to alter the diagnostic mappings, with the prefixes removed.
std::vector< std::string > Warnings
The list of -W... options used to alter the diagnostic mappings, with the prefixes removed.
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, std::optional< int64_t > MaybeLimit=std::nullopt, bool IsText=true)
Open the specified file as a MemoryBuffer, returning a new MemoryBuffer if successful,...
Abstract base class for actions which can be performed by the frontend.
const FrontendInputFile & getCurrentInput() const
InputKind getCurrentFileKind() const
virtual bool shouldEraseOutputFiles()
Callback at the end of processing a single input, to determine if the output files should be erased o...
ASTUnit & getCurrentASTUnit() const
CompilerInstance & getCompilerInstance() const
virtual bool PrepareToExecuteAction(CompilerInstance &CI)
Prepare to execute the action on the given CompilerInstance.
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
Module * getCurrentModule() 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.
SmallVector< FrontendInputFile, 0 > Inputs
The input files and their types.
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.
bool PrepareToExecuteAction(CompilerInstance &CI) override
Prepare to execute the action on the given CompilerInstance.
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...
void ExecuteAction() override
Callback to run the program action, using the initialized compiler instance.
HLSLFrontendAction(std::unique_ptr< FrontendAction > WrappedAction)
One of these records is kept for each identifier that is lexed.
StringRef getName() const
Return the actual identifier string.
@ CMK_HeaderUnit
Compiling a module header unit.
@ CMK_ModuleInterface
Compiling a C++ modules interface unit.
CompatibilityKind
For ASTs produced with different option value, signifies their level of compatibility.
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
std::string HLSLRootSigOverride
The HLSL root signature that will be used to overide the root signature used for the shader entry poi...
llvm::dxbc::RootSignatureVersion HLSLRootSigVer
The HLSL root signature version for dxil.
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.
Encapsulates changes to the "macros namespace" (the location where the macro name became active,...
const MacroInfo * getMacroInfo() const
Encapsulates the data about a macro definition (e.g.
SourceLocation getDefinitionLoc() const
Return the location that the macro was defined at.
ArrayRef< Token > tokens() const
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 addPPCallbacks(std::unique_ptr< PPCallbacks > C)
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.
void SetRootSignatureOverride(IdentifierInfo *DeclIdent)
Sema - This implements semantic analysis and AST building for C.
DiagnosticsEngine & getDiagnostics() const
ExprResult ActOnUnevaluatedStringLiteral(ArrayRef< Token > StringToks)
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.
IdentifierInfo * getIdentifierInfo() const
tok::TokenKind getKind() const
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.
A frontend action which simply wraps some other runtime-specified frontend action.
TranslationUnitKind getTranslationUnitKind() override
For AST-based actions, the kind of translation unit we're handling.
void ExecuteAction() override
Callback to run the program action, using the initialized compiler instance.
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.
bool isStringLiteral(TokenKind K)
Return true if this is a C or C++ string-literal (or C++11 user-defined-string-literal) token.
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)