1328 lines · cpp
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-exception6//7//===----------------------------------------------------------------------===//8 9#include "clang/Frontend/FrontendActions.h"10#include "clang/AST/ASTConsumer.h"11#include "clang/AST/Decl.h"12#include "clang/Basic/DiagnosticFrontend.h"13#include "clang/Basic/FileManager.h"14#include "clang/Basic/LangStandard.h"15#include "clang/Basic/Module.h"16#include "clang/Basic/TargetInfo.h"17#include "clang/Frontend/ASTConsumers.h"18#include "clang/Frontend/CompilerInstance.h"19#include "clang/Frontend/MultiplexConsumer.h"20#include "clang/Frontend/Utils.h"21#include "clang/Lex/DependencyDirectivesScanner.h"22#include "clang/Lex/HeaderSearch.h"23#include "clang/Lex/Preprocessor.h"24#include "clang/Lex/PreprocessorOptions.h"25#include "clang/Parse/ParseHLSLRootSignature.h"26#include "clang/Sema/TemplateInstCallback.h"27#include "clang/Serialization/ASTReader.h"28#include "clang/Serialization/ASTWriter.h"29#include "clang/Serialization/ModuleFile.h"30#include "llvm/Config/llvm-config.h" // for LLVM_HOST_TRIPLE31#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"36#include <memory>37#include <optional>38#include <system_error>39 40using namespace clang;41 42namespace {43CodeCompleteConsumer *GetCodeCompletionConsumer(CompilerInstance &CI) {44 return CI.hasCodeCompletionConsumer() ? &CI.getCodeCompletionConsumer()45 : nullptr;46}47 48void EnsureSemaIsCreated(CompilerInstance &CI, FrontendAction &Action) {49 if (Action.hasCodeCompletionSupport() &&50 !CI.getFrontendOpts().CodeCompletionAt.FileName.empty())51 CI.createCodeCompletionConsumer();52 53 if (!CI.hasSema())54 CI.createSema(Action.getTranslationUnitKind(),55 GetCodeCompletionConsumer(CI));56}57} // namespace58 59//===----------------------------------------------------------------------===//60// Custom Actions61//===----------------------------------------------------------------------===//62 63std::unique_ptr<ASTConsumer>64InitOnlyAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {65 return std::make_unique<ASTConsumer>();66}67 68void InitOnlyAction::ExecuteAction() {69}70 71// Basically PreprocessOnlyAction::ExecuteAction.72void ReadPCHAndPreprocessAction::ExecuteAction() {73 Preprocessor &PP = getCompilerInstance().getPreprocessor();74 75 // Ignore unknown pragmas.76 PP.IgnorePragmas();77 78 Token Tok;79 // Start parsing the specified input file.80 PP.EnterMainSourceFile();81 do {82 PP.Lex(Tok);83 } while (Tok.isNot(tok::eof));84}85 86std::unique_ptr<ASTConsumer>87ReadPCHAndPreprocessAction::CreateASTConsumer(CompilerInstance &CI,88 StringRef InFile) {89 return std::make_unique<ASTConsumer>();90}91 92//===----------------------------------------------------------------------===//93// AST Consumer Actions94//===----------------------------------------------------------------------===//95 96std::unique_ptr<ASTConsumer>97ASTPrintAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {98 if (std::unique_ptr<raw_ostream> OS =99 CI.createDefaultOutputFile(false, InFile))100 return CreateASTPrinter(std::move(OS), CI.getFrontendOpts().ASTDumpFilter);101 return nullptr;102}103 104std::unique_ptr<ASTConsumer>105ASTDumpAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {106 const FrontendOptions &Opts = CI.getFrontendOpts();107 return CreateASTDumper(nullptr /*Dump to stdout.*/, Opts.ASTDumpFilter,108 Opts.ASTDumpDecls, Opts.ASTDumpAll,109 Opts.ASTDumpLookups, Opts.ASTDumpDeclTypes,110 Opts.ASTDumpFormat);111}112 113std::unique_ptr<ASTConsumer>114ASTDeclListAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {115 return CreateASTDeclNodeLister();116}117 118std::unique_ptr<ASTConsumer>119ASTViewAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {120 return CreateASTViewer();121}122 123std::unique_ptr<ASTConsumer>124GeneratePCHAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {125 std::string Sysroot;126 if (!ComputeASTConsumerArguments(CI, /*ref*/ Sysroot))127 return nullptr;128 129 std::string OutputFile;130 std::unique_ptr<raw_pwrite_stream> OS =131 CreateOutputFile(CI, InFile, /*ref*/ OutputFile);132 if (!OS)133 return nullptr;134 135 if (!CI.getFrontendOpts().RelocatablePCH)136 Sysroot.clear();137 138 const auto &FrontendOpts = CI.getFrontendOpts();139 auto Buffer = std::make_shared<PCHBuffer>();140 std::vector<std::unique_ptr<ASTConsumer>> Consumers;141 Consumers.push_back(std::make_unique<PCHGenerator>(142 CI.getPreprocessor(), CI.getModuleCache(), OutputFile, Sysroot, Buffer,143 CI.getCodeGenOpts(), FrontendOpts.ModuleFileExtensions,144 CI.getPreprocessorOpts().AllowPCHWithCompilerErrors,145 FrontendOpts.IncludeTimestamps, FrontendOpts.BuildingImplicitModule,146 +CI.getLangOpts().CacheGeneratedPCH));147 Consumers.push_back(CI.getPCHContainerWriter().CreatePCHContainerGenerator(148 CI, std::string(InFile), OutputFile, std::move(OS), Buffer));149 150 return std::make_unique<MultiplexConsumer>(std::move(Consumers));151}152 153bool GeneratePCHAction::ComputeASTConsumerArguments(CompilerInstance &CI,154 std::string &Sysroot) {155 Sysroot = CI.getHeaderSearchOpts().Sysroot;156 if (CI.getFrontendOpts().RelocatablePCH && Sysroot.empty()) {157 CI.getDiagnostics().Report(diag::err_relocatable_without_isysroot);158 return false;159 }160 161 return true;162}163 164std::unique_ptr<llvm::raw_pwrite_stream>165GeneratePCHAction::CreateOutputFile(CompilerInstance &CI, StringRef InFile,166 std::string &OutputFile) {167 // Because this is exposed via libclang we must disable RemoveFileOnSignal.168 std::unique_ptr<raw_pwrite_stream> OS = CI.createDefaultOutputFile(169 /*Binary=*/true, InFile, /*Extension=*/"", /*RemoveFileOnSignal=*/false);170 if (!OS)171 return nullptr;172 173 OutputFile = CI.getFrontendOpts().OutputFile;174 return OS;175}176 177bool GeneratePCHAction::shouldEraseOutputFiles() {178 if (getCompilerInstance().getPreprocessorOpts().AllowPCHWithCompilerErrors)179 return false;180 return ASTFrontendAction::shouldEraseOutputFiles();181}182 183bool GeneratePCHAction::BeginSourceFileAction(CompilerInstance &CI) {184 CI.getLangOpts().CompilingPCH = true;185 return ASTFrontendAction::BeginSourceFileAction(CI);186}187 188std::vector<std::unique_ptr<ASTConsumer>>189GenerateModuleAction::CreateMultiplexConsumer(CompilerInstance &CI,190 StringRef InFile) {191 std::unique_ptr<raw_pwrite_stream> OS = CreateOutputFile(CI, InFile);192 if (!OS)193 return {};194 195 std::string OutputFile = CI.getFrontendOpts().OutputFile;196 std::string Sysroot;197 198 auto Buffer = std::make_shared<PCHBuffer>();199 std::vector<std::unique_ptr<ASTConsumer>> Consumers;200 201 Consumers.push_back(std::make_unique<PCHGenerator>(202 CI.getPreprocessor(), CI.getModuleCache(), OutputFile, Sysroot, Buffer,203 CI.getCodeGenOpts(), CI.getFrontendOpts().ModuleFileExtensions,204 /*AllowASTWithErrors=*/205 +CI.getFrontendOpts().AllowPCMWithCompilerErrors,206 /*IncludeTimestamps=*/207 +CI.getFrontendOpts().BuildingImplicitModule &&208 +CI.getFrontendOpts().IncludeTimestamps,209 /*BuildingImplicitModule=*/+CI.getFrontendOpts().BuildingImplicitModule,210 /*ShouldCacheASTInMemory=*/211 +CI.getFrontendOpts().BuildingImplicitModule));212 Consumers.push_back(CI.getPCHContainerWriter().CreatePCHContainerGenerator(213 CI, std::string(InFile), OutputFile, std::move(OS), Buffer));214 return Consumers;215}216 217std::unique_ptr<ASTConsumer>218GenerateModuleAction::CreateASTConsumer(CompilerInstance &CI,219 StringRef InFile) {220 std::vector<std::unique_ptr<ASTConsumer>> Consumers =221 CreateMultiplexConsumer(CI, InFile);222 if (Consumers.empty())223 return nullptr;224 225 return std::make_unique<MultiplexConsumer>(std::move(Consumers));226}227 228bool GenerateModuleAction::shouldEraseOutputFiles() {229 return !getCompilerInstance().getFrontendOpts().AllowPCMWithCompilerErrors &&230 ASTFrontendAction::shouldEraseOutputFiles();231}232 233bool GenerateModuleFromModuleMapAction::BeginSourceFileAction(234 CompilerInstance &CI) {235 if (!CI.getLangOpts().Modules) {236 CI.getDiagnostics().Report(diag::err_module_build_requires_fmodules);237 return false;238 }239 240 return GenerateModuleAction::BeginSourceFileAction(CI);241}242 243std::unique_ptr<raw_pwrite_stream>244GenerateModuleFromModuleMapAction::CreateOutputFile(CompilerInstance &CI,245 StringRef InFile) {246 // If no output file was provided, figure out where this module would go247 // in the module cache.248 if (CI.getFrontendOpts().OutputFile.empty()) {249 StringRef ModuleMapFile = CI.getFrontendOpts().OriginalModuleMap;250 if (ModuleMapFile.empty())251 ModuleMapFile = InFile;252 253 HeaderSearch &HS = CI.getPreprocessor().getHeaderSearchInfo();254 CI.getFrontendOpts().OutputFile =255 HS.getCachedModuleFileName(CI.getLangOpts().CurrentModule,256 ModuleMapFile);257 }258 259 // Because this is exposed via libclang we must disable RemoveFileOnSignal.260 return CI.createDefaultOutputFile(/*Binary=*/true, InFile, /*Extension=*/"",261 /*RemoveFileOnSignal=*/false,262 /*CreateMissingDirectories=*/true,263 /*ForceUseTemporary=*/true);264}265 266bool GenerateModuleInterfaceAction::PrepareToExecuteAction(267 CompilerInstance &CI) {268 for (const auto &FIF : CI.getFrontendOpts().Inputs) {269 if (const auto InputFormat = FIF.getKind().getFormat();270 InputFormat != InputKind::Format::Source) {271 CI.getDiagnostics().Report(272 diag::err_frontend_action_unsupported_input_format)273 << "module interface compilation" << FIF.getFile() << InputFormat;274 return false;275 }276 }277 return GenerateModuleAction::PrepareToExecuteAction(CI);278}279 280bool GenerateModuleInterfaceAction::BeginSourceFileAction(281 CompilerInstance &CI) {282 CI.getLangOpts().setCompilingModule(LangOptions::CMK_ModuleInterface);283 284 return GenerateModuleAction::BeginSourceFileAction(CI);285}286 287std::unique_ptr<ASTConsumer>288GenerateModuleInterfaceAction::CreateASTConsumer(CompilerInstance &CI,289 StringRef InFile) {290 std::vector<std::unique_ptr<ASTConsumer>> Consumers;291 292 if (CI.getFrontendOpts().GenReducedBMI &&293 !CI.getFrontendOpts().ModuleOutputPath.empty()) {294 Consumers.push_back(std::make_unique<ReducedBMIGenerator>(295 CI.getPreprocessor(), CI.getModuleCache(),296 CI.getFrontendOpts().ModuleOutputPath, CI.getCodeGenOpts(),297 +CI.getFrontendOpts().AllowPCMWithCompilerErrors));298 }299 300 Consumers.push_back(std::make_unique<CXX20ModulesGenerator>(301 CI.getPreprocessor(), CI.getModuleCache(),302 CI.getFrontendOpts().OutputFile, CI.getCodeGenOpts(),303 +CI.getFrontendOpts().AllowPCMWithCompilerErrors));304 305 return std::make_unique<MultiplexConsumer>(std::move(Consumers));306}307 308std::unique_ptr<raw_pwrite_stream>309GenerateModuleInterfaceAction::CreateOutputFile(CompilerInstance &CI,310 StringRef InFile) {311 return CI.createDefaultOutputFile(/*Binary=*/true, InFile, "pcm");312}313 314std::unique_ptr<ASTConsumer>315GenerateReducedModuleInterfaceAction::CreateASTConsumer(CompilerInstance &CI,316 StringRef InFile) {317 return std::make_unique<ReducedBMIGenerator>(318 CI.getPreprocessor(), CI.getModuleCache(),319 CI.getFrontendOpts().OutputFile, CI.getCodeGenOpts());320}321 322bool GenerateHeaderUnitAction::BeginSourceFileAction(CompilerInstance &CI) {323 if (!CI.getLangOpts().CPlusPlusModules) {324 CI.getDiagnostics().Report(diag::err_module_interface_requires_cpp_modules);325 return false;326 }327 CI.getLangOpts().setCompilingModule(LangOptions::CMK_HeaderUnit);328 return GenerateModuleAction::BeginSourceFileAction(CI);329}330 331std::unique_ptr<raw_pwrite_stream>332GenerateHeaderUnitAction::CreateOutputFile(CompilerInstance &CI,333 StringRef InFile) {334 return CI.createDefaultOutputFile(/*Binary=*/true, InFile, "pcm");335}336 337SyntaxOnlyAction::~SyntaxOnlyAction() {338}339 340std::unique_ptr<ASTConsumer>341SyntaxOnlyAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {342 return std::make_unique<ASTConsumer>();343}344 345std::unique_ptr<ASTConsumer>346DumpModuleInfoAction::CreateASTConsumer(CompilerInstance &CI,347 StringRef InFile) {348 return std::make_unique<ASTConsumer>();349}350 351std::unique_ptr<ASTConsumer>352VerifyPCHAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {353 return std::make_unique<ASTConsumer>();354}355 356void VerifyPCHAction::ExecuteAction() {357 CompilerInstance &CI = getCompilerInstance();358 bool Preamble = CI.getPreprocessorOpts().PrecompiledPreambleBytes.first != 0;359 const std::string &Sysroot = CI.getHeaderSearchOpts().Sysroot;360 std::unique_ptr<ASTReader> Reader(new ASTReader(361 CI.getPreprocessor(), CI.getModuleCache(), &CI.getASTContext(),362 CI.getPCHContainerReader(), CI.getCodeGenOpts(),363 CI.getFrontendOpts().ModuleFileExtensions,364 Sysroot.empty() ? "" : Sysroot.c_str(),365 DisableValidationForModuleKind::None,366 /*AllowASTWithCompilerErrors*/ false,367 /*AllowConfigurationMismatch*/ true,368 /*ValidateSystemInputs*/ true, /*ForceValidateUserInputs*/ true));369 370 Reader->ReadAST(getCurrentFile(),371 Preamble ? serialization::MK_Preamble372 : serialization::MK_PCH,373 SourceLocation(),374 ASTReader::ARR_ConfigurationMismatch);375}376 377namespace {378struct TemplightEntry {379 std::string Name;380 std::string Kind;381 std::string Event;382 std::string DefinitionLocation;383 std::string PointOfInstantiation;384};385} // namespace386 387namespace llvm {388namespace yaml {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);396 }397};398} // namespace yaml399} // namespace llvm400 401namespace {402class DefaultTemplateInstCallback : public TemplateInstantiationCallback {403 using CodeSynthesisContext = Sema::CodeSynthesisContext;404 405public:406 void initialize(const Sema &) override {}407 408 void finalize(const Sema &) override {}409 410 void atTemplateBegin(const Sema &TheSema,411 const CodeSynthesisContext &Inst) override {412 displayTemplightEntry<true>(llvm::outs(), TheSema, Inst);413 }414 415 void atTemplateEnd(const Sema &TheSema,416 const CodeSynthesisContext &Inst) override {417 displayTemplightEntry<false>(llvm::outs(), TheSema, Inst);418 }419 420private:421 static std::string toString(CodeSynthesisContext::SynthesisKind Kind) {422 switch (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";479 }480 return "";481 }482 483 template <bool BeginInstantiation>484 static void displayTemplightEntry(llvm::raw_ostream &Out, const Sema &TheSema,485 const CodeSynthesisContext &Inst) {486 std::string YAML;487 {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);494 }495 Out << "---" << YAML << "\n";496 }497 498 static void printEntryName(const Sema &TheSema, const Decl *Entity,499 llvm::raw_string_ostream &OS) {500 auto *NamedTemplate = cast<NamedDecl>(Entity);501 502 PrintingPolicy Policy = TheSema.Context.getPrintingPolicy();503 // FIXME: Also ask for FullyQualifiedNames?504 Policy.SuppressDefaultTemplateArgs = false;505 NamedTemplate->getNameForDiagnostic(OS, Policy, true);506 507 if (!OS.str().empty())508 return;509 510 Decl *Ctx = Decl::castFromDeclContext(NamedTemplate->getDeclContext());511 NamedDecl *NamedCtx = dyn_cast_or_null<NamedDecl>(Ctx);512 513 if (const auto *Decl = dyn_cast<TagDecl>(NamedTemplate)) {514 if (const auto *R = dyn_cast<RecordDecl>(Decl)) {515 if (R->isLambda()) {516 OS << "lambda at ";517 Decl->getLocation().print(OS, TheSema.getSourceManager());518 return;519 }520 }521 OS << "unnamed " << Decl->getKindName();522 return;523 }524 525 assert(NamedCtx && "NamedCtx cannot be null");526 527 if (const auto *Decl = dyn_cast<ParmVarDecl>(NamedTemplate)) {528 OS << "unnamed function parameter " << Decl->getFunctionScopeIndex()529 << " ";530 if (Decl->getFunctionScopeDepth() > 0)531 OS << "(at depth " << Decl->getFunctionScopeDepth() << ") ";532 OS << "of ";533 NamedCtx->getNameForDiagnostic(OS, TheSema.getLangOpts(), true);534 return;535 }536 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() << ") ";543 OS << "of ";544 NamedCtx->getNameForDiagnostic(OS, TheSema.getLangOpts(), true);545 return;546 }547 }548 }549 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() << ") ";554 OS << "of ";555 NamedCtx->getNameForDiagnostic(OS, TheSema.getLangOpts(), true);556 return;557 }558 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() << ") ";563 OS << "of ";564 NamedCtx->getNameForDiagnostic(OS, TheSema.getLangOpts(), true);565 return;566 }567 568 llvm_unreachable("Failed to retrieve a name for this entry!");569 OS << "unnamed identifier";570 }571 572 template <bool BeginInstantiation>573 static TemplightEntry getTemplightEntry(const Sema &TheSema,574 const CodeSynthesisContext &Inst) {575 TemplightEntry Entry;576 Entry.Kind = toString(Inst.Kind);577 Entry.Event = BeginInstantiation ? "Begin" : "End";578 llvm::raw_string_ostream OS(Entry.Name);579 printEntryName(TheSema, Inst.Entity, OS);580 const PresumedLoc DefLoc =581 TheSema.getSourceManager().getPresumedLoc(Inst.Entity->getLocation());582 if (!DefLoc.isInvalid())583 Entry.DefinitionLocation = std::string(DefLoc.getFilename()) + ":" +584 std::to_string(DefLoc.getLine()) + ":" +585 std::to_string(DefLoc.getColumn());586 const PresumedLoc PoiLoc =587 TheSema.getSourceManager().getPresumedLoc(Inst.PointOfInstantiation);588 if (!PoiLoc.isInvalid()) {589 Entry.PointOfInstantiation = std::string(PoiLoc.getFilename()) + ":" +590 std::to_string(PoiLoc.getLine()) + ":" +591 std::to_string(PoiLoc.getColumn());592 }593 return Entry;594 }595};596} // namespace597 598std::unique_ptr<ASTConsumer>599TemplightDumpAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {600 return std::make_unique<ASTConsumer>();601}602 603void TemplightDumpAction::ExecuteAction() {604 CompilerInstance &CI = getCompilerInstance();605 606 // This part is normally done by ASTFrontEndAction, but needs to happen607 // before Templight observers can be created608 // FIXME: Move the truncation aspect of this into Sema, we delayed this till609 // here so the source manager would be initialized.610 EnsureSemaIsCreated(CI, *this);611 612 CI.getSema().TemplateInstCallbacks.push_back(613 std::make_unique<DefaultTemplateInstCallback>());614 ASTFrontendAction::ExecuteAction();615}616 617namespace {618 /// AST reader listener that dumps module information for a module619 /// file.620 class DumpModuleInfoListener : public ASTReaderListener {621 llvm::raw_ostream &Out;622 623 public:624 DumpModuleInfoListener(llvm::raw_ostream &Out) : Out(Out) { }625 626#define DUMP_BOOLEAN(Value, Text) \627 Out.indent(4) << Text << ": " << (Value? "Yes" : "No") << "\n"628 629 bool ReadFullVersionInformation(StringRef FullVersion) override {630 Out.indent(2)631 << "Generated by "632 << (FullVersion == getClangFullRepositoryVersion()? "this"633 : "a different")634 << " Clang: " << FullVersion << "\n";635 return ASTReaderListener::ReadFullVersionInformation(FullVersion);636 }637 638 void ReadModuleName(StringRef ModuleName) override {639 Out.indent(2) << "Module name: " << ModuleName << "\n";640 }641 void ReadModuleMapFile(StringRef ModuleMapPath) override {642 Out.indent(2) << "Module map file: " << ModuleMapPath << "\n";643 }644 645 bool ReadLanguageOptions(const LangOptions &LangOpts,646 StringRef ModuleFilename, bool Complain,647 bool AllowCompatibleDifferences) override {648 // FIXME: Replace with C++20 `using enum LangOptions::CompatibilityKind`.649 using CK = LangOptions::CompatibilityKind;650 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"663 664 if (!LangOpts.ModuleFeatures.empty()) {665 Out.indent(4) << "Module features:\n";666 for (StringRef Feature : LangOpts.ModuleFeatures)667 Out.indent(6) << Feature << "\n";668 }669 670 return false;671 }672 673 bool ReadTargetOptions(const TargetOptions &TargetOpts,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";681 682 if (!TargetOpts.FeaturesAsWritten.empty()) {683 Out.indent(4) << "Target features:\n";684 for (unsigned I = 0, N = TargetOpts.FeaturesAsWritten.size();685 I != N; ++I) {686 Out.indent(6) << TargetOpts.FeaturesAsWritten[I] << "\n";687 }688 }689 690 return false;691 }692 693 bool ReadDiagnosticOptions(DiagnosticOptions &DiagOpts,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"703 704 Out.indent(4) << "Diagnostic flags:\n";705 for (const std::string &Warning : DiagOpts.Warnings)706 Out.indent(6) << "-W" << Warning << "\n";707 for (const std::string &Remark : DiagOpts.Remarks)708 Out.indent(6) << "-R" << Remark << "\n";709 710 return false;711 }712 713 bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,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";721 DUMP_BOOLEAN(HSOpts.UseBuiltinIncludes,722 "Use builtin include directories [-nobuiltininc]");723 DUMP_BOOLEAN(HSOpts.UseStandardSystemIncludes,724 "Use standard system include directories [-nostdinc]");725 DUMP_BOOLEAN(HSOpts.UseStandardCXXIncludes,726 "Use standard C++ include directories [-nostdinc++]");727 DUMP_BOOLEAN(HSOpts.UseLibcxx,728 "Use libc++ (rather than libstdc++) [-stdlib=]");729 return false;730 }731 732 bool ReadHeaderSearchPaths(const HeaderSearchOptions &HSOpts,733 bool Complain) override {734 Out.indent(2) << "Header search paths:\n";735 Out.indent(4) << "User entries:\n";736 for (const auto &Entry : HSOpts.UserEntries)737 Out.indent(6) << Entry.Path << "\n";738 Out.indent(4) << "System header prefixes:\n";739 for (const auto &Prefix : HSOpts.SystemHeaderPrefixes)740 Out.indent(6) << Prefix.Prefix << "\n";741 Out.indent(4) << "VFS overlay files:\n";742 for (const auto &Overlay : HSOpts.VFSOverlayFiles)743 Out.indent(6) << Overlay << "\n";744 return false;745 }746 747 bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,748 StringRef ModuleFilename, bool ReadMacros,749 bool Complain,750 std::string &SuggestedPredefines) override {751 Out.indent(2) << "Preprocessor options:\n";752 DUMP_BOOLEAN(PPOpts.UsePredefines,753 "Uses compiler/target-specific predefines [-undef]");754 DUMP_BOOLEAN(PPOpts.DetailedRecord,755 "Uses detailed preprocessing record (for indexing)");756 757 if (ReadMacros) {758 Out.indent(4) << "Predefined macros:\n";759 }760 761 for (std::vector<std::pair<std::string, bool/*isUndef*/> >::const_iterator762 I = PPOpts.Macros.begin(), IEnd = PPOpts.Macros.end();763 I != IEnd; ++I) {764 Out.indent(6);765 if (I->second)766 Out << "-U";767 else768 Out << "-D";769 Out << I->first << "\n";770 }771 return false;772 }773 774 /// Indicates that a particular module file extension has been read.775 void readModuleFileExtension(776 const ModuleFileExtensionMetadata &Metadata) override {777 Out.indent(2) << "Module file extension '"778 << Metadata.BlockName << "' " << Metadata.MajorVersion779 << "." << Metadata.MinorVersion;780 if (!Metadata.UserInfo.empty()) {781 Out << ": ";782 Out.write_escaped(Metadata.UserInfo);783 }784 785 Out << "\n";786 }787 788 /// Tells the \c ASTReaderListener that we want to receive the789 /// input files of the AST file via \c visitInputFile.790 bool needsInputFileVisitation() override { return true; }791 792 /// Tells the \c ASTReaderListener that we want to receive the793 /// input files of the AST file via \c visitInputFile.794 bool needsSystemInputFileVisitation() override { return true; }795 796 /// Indicates that the AST file contains particular input file.797 ///798 /// \returns true to continue receiving the next input file, false to stop.799 bool visitInputFileAsRequested(StringRef FilenameAsRequested,800 StringRef Filename, bool isSystem,801 bool isOverridden,802 bool isExplicitModule) override {803 804 Out.indent(2) << "Input file: " << FilenameAsRequested;805 806 if (isSystem || isOverridden || isExplicitModule) {807 Out << " [";808 if (isSystem) {809 Out << "System";810 if (isOverridden || isExplicitModule)811 Out << ", ";812 }813 if (isOverridden) {814 Out << "Overridden";815 if (isExplicitModule)816 Out << ", ";817 }818 if (isExplicitModule)819 Out << "ExplicitModule";820 821 Out << "]";822 }823 824 Out << "\n";825 826 return true;827 }828 829 /// Returns true if this \c ASTReaderListener wants to receive the830 /// imports of the AST file via \c visitImport, false otherwise.831 bool needsImportVisitation() const override { return true; }832 833 /// If needsImportVisitation returns \c true, this is called for each834 /// AST file imported by this AST file.835 void visitImport(StringRef ModuleName, StringRef Filename) override {836 Out.indent(2) << "Imports module '" << ModuleName837 << "': " << Filename.str() << "\n";838 }839#undef DUMP_BOOLEAN840 };841}842 843bool DumpModuleInfoAction::BeginInvocation(CompilerInstance &CI) {844 // The Object file reader also supports raw ast files and there is no point in845 // being strict about the module file format in -module-file-info mode.846 CI.getHeaderSearchOpts().ModuleFormat = "obj";847 return true;848}849 850static StringRef ModuleKindName(Module::ModuleKind MK) {851 switch (MK) {852 case Module::ModuleMapModule:853 return "Module Map Module";854 case Module::ModuleInterfaceUnit:855 return "Interface Unit";856 case Module::ModuleImplementationUnit:857 return "Implementation Unit";858 case Module::ModulePartitionInterface:859 return "Partition Interface";860 case Module::ModulePartitionImplementation:861 return "Partition Implementation";862 case Module::ModuleHeaderUnit:863 return "Header Unit";864 case Module::ExplicitGlobalModuleFragment:865 return "Global Module Fragment";866 case Module::ImplicitGlobalModuleFragment:867 return "Implicit Module Fragment";868 case Module::PrivateModuleFragment:869 return "Private Module Fragment";870 }871 llvm_unreachable("unknown module kind!");872}873 874void DumpModuleInfoAction::ExecuteAction() {875 CompilerInstance &CI = getCompilerInstance();876 877 // Don't process files of type other than module to avoid crash878 if (!isCurrentFileAST()) {879 CI.getDiagnostics().Report(diag::err_file_is_not_module)880 << getCurrentFile();881 return;882 }883 884 // Set up the output file.885 StringRef OutputFileName = CI.getFrontendOpts().OutputFile;886 if (!OutputFileName.empty() && OutputFileName != "-") {887 std::error_code EC;888 OutputStream.reset(new llvm::raw_fd_ostream(889 OutputFileName.str(), EC, llvm::sys::fs::OF_TextWithCRLF));890 }891 llvm::raw_ostream &Out = OutputStream ? *OutputStream : llvm::outs();892 893 Out << "Information for module file '" << getCurrentFile() << "':\n";894 auto &FileMgr = CI.getFileManager();895 auto Buffer = FileMgr.getBufferForFile(getCurrentFile());896 StringRef Magic = (*Buffer)->getMemBufferRef().getBuffer();897 bool IsRaw = Magic.starts_with("CPCH");898 Out << " Module format: " << (IsRaw ? "raw" : "obj") << "\n";899 900 Preprocessor &PP = CI.getPreprocessor();901 DumpModuleInfoListener Listener(Out);902 const HeaderSearchOptions &HSOpts =903 PP.getHeaderSearchInfo().getHeaderSearchOpts();904 905 // The FrontendAction::BeginSourceFile () method loads the AST so that much906 // of the information is already available and modules should have been907 // loaded.908 909 const LangOptions &LO = getCurrentASTUnit().getLangOpts();910 if (LO.CPlusPlusModules && !LO.CurrentModule.empty()) {911 ASTReader *R = getCurrentASTUnit().getASTReader().get();912 unsigned SubModuleCount = R->getTotalNumSubmodules();913 serialization::ModuleFile &MF = R->getModuleManager().getPrimaryModule();914 Out << " ====== C++20 Module structure ======\n";915 916 if (MF.ModuleName != LO.CurrentModule)917 Out << " Mismatched module names : " << MF.ModuleName << " and "918 << LO.CurrentModule << "\n";919 920 struct SubModInfo {921 unsigned Idx;922 Module *Mod;923 Module::ModuleKind Kind;924 std::string &Name;925 bool Seen;926 };927 std::map<std::string, SubModInfo> SubModMap;928 auto PrintSubMapEntry = [&](std::string Name, Module::ModuleKind Kind) {929 Out << " " << ModuleKindName(Kind) << " '" << Name << "'";930 auto I = SubModMap.find(Name);931 if (I == SubModMap.end())932 Out << " was not found in the sub modules!\n";933 else {934 I->second.Seen = true;935 Out << " is at index #" << I->second.Idx << "\n";936 }937 };938 Module *Primary = nullptr;939 for (unsigned Idx = 0; Idx <= SubModuleCount; ++Idx) {940 Module *M = R->getModule(Idx);941 if (!M)942 continue;943 if (M->Name == LO.CurrentModule) {944 Primary = M;945 Out << " " << ModuleKindName(M->Kind) << " '" << LO.CurrentModule946 << "' is the Primary Module at index #" << Idx << "\n";947 SubModMap.insert({M->Name, {Idx, M, M->Kind, M->Name, true}});948 } else949 SubModMap.insert({M->Name, {Idx, M, M->Kind, M->Name, false}});950 }951 if (Primary) {952 if (!Primary->submodules().empty())953 Out << " Sub Modules:\n";954 for (auto *MI : Primary->submodules()) {955 PrintSubMapEntry(MI->Name, MI->Kind);956 }957 if (!Primary->Imports.empty())958 Out << " Imports:\n";959 for (auto *IMP : Primary->Imports) {960 PrintSubMapEntry(IMP->Name, IMP->Kind);961 }962 if (!Primary->Exports.empty())963 Out << " Exports:\n";964 for (unsigned MN = 0, N = Primary->Exports.size(); MN != N; ++MN) {965 if (Module *M = Primary->Exports[MN].getPointer()) {966 PrintSubMapEntry(M->Name, M->Kind);967 }968 }969 }970 971 // Emit the macro definitions in the module file so that we can know how972 // much definitions in the module file quickly.973 // TODO: Emit the macro definition bodies completely.974 {975 std::vector<StringRef> MacroNames;976 for (const auto &M : R->getPreprocessor().macros()) {977 if (M.first->isFromAST())978 MacroNames.push_back(M.first->getName());979 }980 llvm::sort(MacroNames);981 if (!MacroNames.empty())982 Out << " Macro Definitions:\n";983 for (StringRef Name : MacroNames)984 Out << " " << Name << "\n";985 }986 987 // Now let's print out any modules we did not see as part of the Primary.988 for (const auto &SM : SubModMap) {989 if (!SM.second.Seen && SM.second.Mod) {990 Out << " " << ModuleKindName(SM.second.Kind) << " '" << SM.first991 << "' at index #" << SM.second.Idx992 << " has no direct reference in the Primary\n";993 }994 }995 Out << " ====== ======\n";996 }997 998 // The reminder of the output is produced from the listener as the AST999 // FileCcontrolBlock is (re-)parsed.1000 ASTReader::readASTFileControlBlock(1001 getCurrentFile(), FileMgr, CI.getModuleCache(),1002 CI.getPCHContainerReader(),1003 /*FindModuleFileExtensions=*/true, Listener,1004 HSOpts.ModulesValidateDiagnosticOptions);1005}1006 1007//===----------------------------------------------------------------------===//1008// Preprocessor Actions1009//===----------------------------------------------------------------------===//1010 1011void DumpRawTokensAction::ExecuteAction() {1012 Preprocessor &PP = getCompilerInstance().getPreprocessor();1013 SourceManager &SM = PP.getSourceManager();1014 1015 // Start lexing the specified input file.1016 llvm::MemoryBufferRef FromFile = SM.getBufferOrFake(SM.getMainFileID());1017 Lexer RawLex(SM.getMainFileID(), FromFile, SM, PP.getLangOpts());1018 RawLex.SetKeepWhitespaceMode(true);1019 1020 Token RawTok;1021 RawLex.LexFromRawLexer(RawTok);1022 while (RawTok.isNot(tok::eof)) {1023 PP.DumpToken(RawTok, true);1024 llvm::errs() << "\n";1025 RawLex.LexFromRawLexer(RawTok);1026 }1027}1028 1029void DumpTokensAction::ExecuteAction() {1030 Preprocessor &PP = getCompilerInstance().getPreprocessor();1031 // Start preprocessing the specified input file.1032 Token Tok;1033 PP.EnterMainSourceFile();1034 do {1035 PP.Lex(Tok);1036 PP.DumpToken(Tok, true);1037 llvm::errs() << "\n";1038 } while (Tok.isNot(tok::eof));1039}1040 1041void PreprocessOnlyAction::ExecuteAction() {1042 Preprocessor &PP = getCompilerInstance().getPreprocessor();1043 1044 // Ignore unknown pragmas.1045 PP.IgnorePragmas();1046 1047 Token Tok;1048 // Start parsing the specified input file.1049 PP.EnterMainSourceFile();1050 do {1051 PP.Lex(Tok);1052 } while (Tok.isNot(tok::eof));1053}1054 1055void PrintPreprocessedAction::ExecuteAction() {1056 CompilerInstance &CI = getCompilerInstance();1057 // Output file may need to be set to 'Binary', to avoid converting Unix style1058 // line feeds (<LF>) to Microsoft style line feeds (<CR><LF>) on Windows.1059 //1060 // Look to see what type of line endings the file uses. If there's a1061 // CRLF, then we won't open the file up in binary mode. If there is1062 // just an LF or CR, then we will open the file up in binary mode.1063 // In this fashion, the output format should match the input format, unless1064 // the input format has inconsistent line endings.1065 //1066 // This should be a relatively fast operation since most files won't have1067 // all of their source code on a single line. However, that is still a1068 // concern, so if we scan for too long, we'll just assume the file should1069 // be opened in binary mode.1070 1071 bool BinaryMode = false;1072 if (llvm::Triple(LLVM_HOST_TRIPLE).isOSWindows()) {1073 BinaryMode = true;1074 const SourceManager &SM = CI.getSourceManager();1075 if (std::optional<llvm::MemoryBufferRef> Buffer =1076 SM.getBufferOrNone(SM.getMainFileID())) {1077 const char *cur = Buffer->getBufferStart();1078 const char *end = Buffer->getBufferEnd();1079 const char *next = (cur != end) ? cur + 1 : end;1080 1081 // Limit ourselves to only scanning 256 characters into the source1082 // file. This is mostly a check in case the file has no1083 // newlines whatsoever.1084 if (end - cur > 256)1085 end = cur + 256;1086 1087 while (next < end) {1088 if (*cur == 0x0D) { // CR1089 if (*next == 0x0A) // CRLF1090 BinaryMode = false;1091 1092 break;1093 } else if (*cur == 0x0A) // LF1094 break;1095 1096 ++cur;1097 ++next;1098 }1099 }1100 }1101 1102 std::unique_ptr<raw_ostream> OS =1103 CI.createDefaultOutputFile(BinaryMode, getCurrentFileOrBufferName());1104 if (!OS) return;1105 1106 // If we're preprocessing a module map, start by dumping the contents of the1107 // module itself before switching to the input buffer.1108 auto &Input = getCurrentInput();1109 if (Input.getKind().getFormat() == InputKind::ModuleMap) {1110 if (Input.isFile()) {1111 (*OS) << "# 1 \"";1112 OS->write_escaped(Input.getFile());1113 (*OS) << "\"\n";1114 }1115 getCurrentModule()->print(*OS);1116 (*OS) << "#pragma clang module contents\n";1117 }1118 1119 DoPrintPreprocessedInput(CI.getPreprocessor(), OS.get(),1120 CI.getPreprocessorOutputOpts());1121}1122 1123void PrintPreambleAction::ExecuteAction() {1124 switch (getCurrentFileKind().getLanguage()) {1125 case Language::C:1126 case Language::CXX:1127 case Language::ObjC:1128 case Language::ObjCXX:1129 case Language::OpenCL:1130 case Language::OpenCLCXX:1131 case Language::CUDA:1132 case Language::HIP:1133 case Language::HLSL:1134 case Language::CIR:1135 break;1136 1137 case Language::Unknown:1138 case Language::Asm:1139 case Language::LLVM_IR:1140 // We can't do anything with these.1141 return;1142 }1143 1144 // We don't expect to find any #include directives in a preprocessed input.1145 if (getCurrentFileKind().isPreprocessed())1146 return;1147 1148 CompilerInstance &CI = getCompilerInstance();1149 auto Buffer = CI.getFileManager().getBufferForFile(getCurrentFile());1150 if (Buffer) {1151 unsigned Preamble =1152 Lexer::ComputePreamble((*Buffer)->getBuffer(), CI.getLangOpts()).Size;1153 llvm::outs().write((*Buffer)->getBufferStart(), Preamble);1154 }1155}1156 1157void DumpCompilerOptionsAction::ExecuteAction() {1158 CompilerInstance &CI = getCompilerInstance();1159 std::unique_ptr<raw_ostream> OSP =1160 CI.createDefaultOutputFile(false, getCurrentFile());1161 if (!OSP)1162 return;1163 1164 raw_ostream &OS = *OSP;1165 const Preprocessor &PP = CI.getPreprocessor();1166 const LangOptions &LangOpts = PP.getLangOpts();1167 1168 // FIXME: Rather than manually format the JSON (which is awkward due to1169 // needing to remove trailing commas), this should make use of a JSON library.1170 // FIXME: Instead of printing enums as an integral value and specifying the1171 // type as a separate field, use introspection to print the enumerator.1172 1173 OS << "{\n";1174 OS << "\n\"features\" : [\n";1175 {1176 llvm::SmallString<128> Str;1177#define FEATURE(Name, Predicate) \1178 ("\t{\"" #Name "\" : " + llvm::Twine(Predicate ? "true" : "false") + "},\n") \1179 .toVector(Str);1180#include "clang/Basic/Features.def"1181#undef FEATURE1182 // Remove the newline and comma from the last entry to ensure this remains1183 // valid JSON.1184 OS << Str.substr(0, Str.size() - 2);1185 }1186 OS << "\n],\n";1187 1188 OS << "\n\"extensions\" : [\n";1189 {1190 llvm::SmallString<128> Str;1191#define EXTENSION(Name, Predicate) \1192 ("\t{\"" #Name "\" : " + llvm::Twine(Predicate ? "true" : "false") + "},\n") \1193 .toVector(Str);1194#include "clang/Basic/Features.def"1195#undef EXTENSION1196 // Remove the newline and comma from the last entry to ensure this remains1197 // valid JSON.1198 OS << Str.substr(0, Str.size() - 2);1199 }1200 OS << "\n]\n";1201 1202 OS << "}";1203}1204 1205void PrintDependencyDirectivesSourceMinimizerAction::ExecuteAction() {1206 CompilerInstance &CI = getCompilerInstance();1207 SourceManager &SM = CI.getPreprocessor().getSourceManager();1208 llvm::MemoryBufferRef FromFile = SM.getBufferOrFake(SM.getMainFileID());1209 1210 llvm::SmallVector<dependency_directives_scan::Token, 16> Tokens;1211 llvm::SmallVector<dependency_directives_scan::Directive, 32> Directives;1212 if (scanSourceForDependencyDirectives(1213 FromFile.getBuffer(), Tokens, Directives, &CI.getDiagnostics(),1214 SM.getLocForStartOfFile(SM.getMainFileID()))) {1215 assert(CI.getDiagnostics().hasErrorOccurred() &&1216 "no errors reported for failure");1217 1218 // Preprocess the source when verifying the diagnostics to capture the1219 // 'expected' comments.1220 if (CI.getDiagnosticOpts().VerifyDiagnostics) {1221 // Make sure we don't emit new diagnostics!1222 CI.getDiagnostics().setSuppressAllDiagnostics(true);1223 Preprocessor &PP = getCompilerInstance().getPreprocessor();1224 PP.EnterMainSourceFile();1225 Token Tok;1226 do {1227 PP.Lex(Tok);1228 } while (Tok.isNot(tok::eof));1229 }1230 return;1231 }1232 printDependencyDirectivesAsSource(FromFile.getBuffer(), Directives,1233 llvm::outs());1234}1235 1236//===----------------------------------------------------------------------===//1237// HLSL Specific Actions1238//===----------------------------------------------------------------------===//1239 1240class InjectRootSignatureCallback : public PPCallbacks {1241private:1242 Sema &Actions;1243 StringRef RootSigName;1244 llvm::dxbc::RootSignatureVersion Version;1245 1246 std::optional<StringLiteral *> processStringLiteral(ArrayRef<Token> Tokens) {1247 for (Token Tok : Tokens)1248 if (!tok::isStringLiteral(Tok.getKind()))1249 return std::nullopt;1250 1251 ExprResult StringResult = Actions.ActOnUnevaluatedStringLiteral(Tokens);1252 if (StringResult.isInvalid())1253 return std::nullopt;1254 1255 if (auto Signature = dyn_cast<StringLiteral>(StringResult.get()))1256 return Signature;1257 1258 return std::nullopt;1259 }1260 1261public:1262 void MacroDefined(const Token &MacroNameTok,1263 const MacroDirective *MD) override {1264 if (RootSigName != MacroNameTok.getIdentifierInfo()->getName())1265 return;1266 1267 const MacroInfo *MI = MD->getMacroInfo();1268 auto Signature = processStringLiteral(MI->tokens());1269 if (!Signature.has_value()) {1270 Actions.getDiagnostics().Report(MI->getDefinitionLoc(),1271 diag::err_expected_string_literal)1272 << /*in attributes...*/ 4 << "RootSignature";1273 return;1274 }1275 1276 IdentifierInfo *DeclIdent =1277 hlsl::ParseHLSLRootSignature(Actions, Version, *Signature);1278 Actions.HLSL().SetRootSignatureOverride(DeclIdent);1279 }1280 1281 InjectRootSignatureCallback(Sema &Actions, StringRef RootSigName,1282 llvm::dxbc::RootSignatureVersion Version)1283 : PPCallbacks(), Actions(Actions), RootSigName(RootSigName),1284 Version(Version) {}1285};1286 1287void HLSLFrontendAction::ExecuteAction() {1288 // Pre-requisites to invoke1289 CompilerInstance &CI = getCompilerInstance();1290 if (!CI.hasASTContext() || !CI.hasPreprocessor())1291 return WrapperFrontendAction::ExecuteAction();1292 1293 // InjectRootSignatureCallback requires access to invoke Sema to lookup/1294 // register a root signature declaration. The wrapped action is required to1295 // account for this by only creating a Sema if one doesn't already exist1296 // (like we have done, and, ASTFrontendAction::ExecuteAction)1297 if (!CI.hasSema())1298 CI.createSema(getTranslationUnitKind(),1299 /*CodeCompleteConsumer=*/nullptr);1300 Sema &S = CI.getSema();1301 1302 auto &TargetInfo = CI.getASTContext().getTargetInfo();1303 bool IsRootSignatureTarget =1304 TargetInfo.getTriple().getEnvironment() == llvm::Triple::RootSignature;1305 StringRef HLSLEntry = TargetInfo.getTargetOpts().HLSLEntry;1306 1307 // Register HLSL specific callbacks1308 auto LangOpts = CI.getLangOpts();1309 StringRef RootSigName =1310 IsRootSignatureTarget ? HLSLEntry : LangOpts.HLSLRootSigOverride;1311 1312 auto MacroCallback = std::make_unique<InjectRootSignatureCallback>(1313 S, RootSigName, LangOpts.HLSLRootSigVer);1314 1315 Preprocessor &PP = CI.getPreprocessor();1316 PP.addPPCallbacks(std::move(MacroCallback));1317 1318 // If we are targeting a root signature, invoke custom handling1319 if (IsRootSignatureTarget)1320 return hlsl::HandleRootSignatureTarget(S, HLSLEntry);1321 else // otherwise, invoke as normal1322 return WrapperFrontendAction::ExecuteAction();1323}1324 1325HLSLFrontendAction::HLSLFrontendAction(1326 std::unique_ptr<FrontendAction> WrappedAction)1327 : WrapperFrontendAction(std::move(WrappedAction)) {}1328