1//===--- FrontendActions.cpp ----------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
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/ASTUnit.h"
19#include "clang/Frontend/CompilerInstance.h"
20#include "clang/Frontend/MultiplexConsumer.h"
21#include "clang/Frontend/Utils.h"
22#include "clang/Lex/DependencyDirectivesScanner.h"
23#include "clang/Lex/HeaderSearch.h"
24#include "clang/Lex/Preprocessor.h"
25#include "clang/Lex/PreprocessorOptions.h"
26#include "clang/Parse/ParseHLSLRootSignature.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_TRIPLE
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"
36#include <memory>
37#include <optional>
38#include <system_error>
39
40using namespace clang;
41
42//===----------------------------------------------------------------------===//
43// Custom Actions
44//===----------------------------------------------------------------------===//
45
46std::unique_ptr<ASTConsumer>
47InitOnlyAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
48 return std::make_unique<ASTConsumer>();
49}
50
51void InitOnlyAction::ExecuteAction() {
52}
53
54// Basically PreprocessOnlyAction::ExecuteAction.
55void ReadPCHAndPreprocessAction::ExecuteAction() {
56 Preprocessor &PP = getCompilerInstance().getPreprocessor();
57
58 // Ignore unknown pragmas.
59 PP.IgnorePragmas();
60
61 Token Tok;
62 // Start parsing the specified input file.
63 PP.EnterMainSourceFile();
64 do {
65 PP.Lex(Result&: Tok);
66 } while (Tok.isNot(K: tok::eof));
67}
68
69std::unique_ptr<ASTConsumer>
70ReadPCHAndPreprocessAction::CreateASTConsumer(CompilerInstance &CI,
71 StringRef InFile) {
72 return std::make_unique<ASTConsumer>();
73}
74
75//===----------------------------------------------------------------------===//
76// AST Consumer Actions
77//===----------------------------------------------------------------------===//
78
79std::unique_ptr<ASTConsumer>
80ASTPrintAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
81 if (std::unique_ptr<raw_ostream> OS =
82 CI.createDefaultOutputFile(Binary: false, BaseInput: InFile))
83 return CreateASTPrinter(OS: std::move(OS), FilterString: CI.getFrontendOpts().ASTDumpFilter);
84 return nullptr;
85}
86
87std::unique_ptr<ASTConsumer>
88ASTDumpAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
89 // Dumping the AST shows documentation comments.
90 CI.getLangOpts().CommentOpts.RetainComments = true;
91 const FrontendOptions &Opts = CI.getFrontendOpts();
92 return CreateASTDumper(OS: nullptr /*Dump to stdout.*/, FilterString: Opts.ASTDumpFilter,
93 FilterPath: Opts.ASTDumpFilterPath, DumpDecls: Opts.ASTDumpDecls,
94 Deserialize: Opts.ASTDumpAll, DumpLookups: Opts.ASTDumpLookups,
95 DumpDeclTypes: Opts.ASTDumpDeclTypes, Format: Opts.ASTDumpFormat);
96}
97
98std::unique_ptr<ASTConsumer>
99ASTDeclListAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
100 return CreateASTDeclNodeLister();
101}
102
103std::unique_ptr<ASTConsumer>
104ASTViewAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
105 return CreateASTViewer();
106}
107
108std::unique_ptr<ASTConsumer>
109GeneratePCHAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
110 std::string Sysroot;
111 if (!ComputeASTConsumerArguments(CI, /*ref*/ Sysroot))
112 return nullptr;
113
114 std::string OutputFile;
115 std::unique_ptr<raw_pwrite_stream> OS =
116 CreateOutputFile(CI, InFile, /*ref*/ OutputFile, SetOnlyIfDifferent);
117 if (!OS)
118 return nullptr;
119
120 if (!CI.getFrontendOpts().RelocatablePCH)
121 Sysroot.clear();
122
123 const auto &FrontendOpts = CI.getFrontendOpts();
124 auto Buffer = std::make_shared<PCHBuffer>();
125 std::vector<std::unique_ptr<ASTConsumer>> Consumers;
126 Consumers.push_back(x: std::make_unique<PCHGenerator>(
127 args&: CI.getPreprocessor(), args&: CI.getModuleCache(), args&: OutputFile, args&: Sysroot, args&: Buffer,
128 args&: CI.getCodeGenOpts(), args: FrontendOpts.ModuleFileExtensions,
129 args&: CI.getPreprocessorOpts().AllowPCHWithCompilerErrors,
130 args: FrontendOpts.IncludeTimestamps, args: FrontendOpts.BuildingImplicitModule));
131 Consumers.push_back(x: CI.getPCHContainerWriter().CreatePCHContainerGenerator(
132 CI, MainFileName: std::string(InFile), OutputFileName: OutputFile, OS: std::move(OS), Buffer));
133
134 return std::make_unique<MultiplexConsumer>(args: std::move(Consumers));
135}
136
137bool GeneratePCHAction::ComputeASTConsumerArguments(CompilerInstance &CI,
138 std::string &Sysroot) {
139 Sysroot = CI.getHeaderSearchOpts().Sysroot;
140 if (CI.getFrontendOpts().RelocatablePCH &&
141 CI.getHeaderSearchOpts().PCHBaseDirIsCwd) {
142 CI.getDiagnostics().Report(DiagID: diag::err_pch_base_dir_is_cwd_relocatable);
143 return false;
144 }
145 if (CI.getFrontendOpts().RelocatablePCH && Sysroot.empty()) {
146 CI.getDiagnostics().Report(DiagID: diag::err_relocatable_without_isysroot);
147 return false;
148 }
149
150 return true;
151}
152
153std::unique_ptr<llvm::raw_pwrite_stream>
154GeneratePCHAction::CreateOutputFile(CompilerInstance &CI, StringRef InFile,
155 std::string &OutputFile,
156 bool SetOnlyIfDifferent) {
157 // Because this is exposed via libclang we must disable RemoveFileOnSignal.
158 std::unique_ptr<raw_pwrite_stream> OS = CI.createDefaultOutputFile(
159 /*Binary=*/true, BaseInput: InFile, /*Extension=*/"", /*RemoveFileOnSignal=*/false,
160 /*CreateMissingDirectories=*/false, /*ForceUseTemporary=*/false,
161 SetOnlyIfDifferent);
162 if (!OS)
163 return nullptr;
164
165 OutputFile = CI.getFrontendOpts().OutputFile;
166 return OS;
167}
168
169bool GeneratePCHAction::shouldEraseOutputFiles() {
170 if (getCompilerInstance().getPreprocessorOpts().AllowPCHWithCompilerErrors)
171 return false;
172 return ASTFrontendAction::shouldEraseOutputFiles();
173}
174
175bool GeneratePCHAction::BeginSourceFileAction(CompilerInstance &CI) {
176 CI.getLangOpts().CompilingPCH = true;
177 return ASTFrontendAction::BeginSourceFileAction(CI);
178}
179
180std::vector<std::unique_ptr<ASTConsumer>>
181GenerateModuleAction::CreateMultiplexConsumer(CompilerInstance &CI,
182 StringRef InFile) {
183 if (!OS)
184 OS = CreateOutputFile(CI, InFile);
185 if (!OS)
186 return {};
187
188 std::string OutputFile = CI.getFrontendOpts().OutputFile;
189 std::string Sysroot;
190
191 auto Buffer = std::make_shared<PCHBuffer>();
192 std::vector<std::unique_ptr<ASTConsumer>> Consumers;
193
194 Consumers.push_back(x: std::make_unique<PCHGenerator>(
195 args&: CI.getPreprocessor(), args&: CI.getModuleCache(), args&: OutputFile, args&: Sysroot, args&: Buffer,
196 args&: CI.getCodeGenOpts(), args&: CI.getFrontendOpts().ModuleFileExtensions,
197 /*AllowASTWithErrors=*/
198 args: +CI.getFrontendOpts().AllowPCMWithCompilerErrors,
199 /*IncludeTimestamps=*/
200 args: +CI.getFrontendOpts().BuildingImplicitModule &&
201 +CI.getFrontendOpts().IncludeTimestamps,
202 /*BuildingImplicitModule=*/args: +CI.getFrontendOpts().BuildingImplicitModule));
203 Consumers.push_back(x: CI.getPCHContainerWriter().CreatePCHContainerGenerator(
204 CI, MainFileName: std::string(InFile), OutputFileName: OutputFile, OS: std::move(OS), Buffer));
205 return Consumers;
206}
207
208std::unique_ptr<ASTConsumer>
209GenerateModuleAction::CreateASTConsumer(CompilerInstance &CI,
210 StringRef InFile) {
211 std::vector<std::unique_ptr<ASTConsumer>> Consumers =
212 CreateMultiplexConsumer(CI, InFile);
213 if (Consumers.empty())
214 return nullptr;
215
216 return std::make_unique<MultiplexConsumer>(args: std::move(Consumers));
217}
218
219bool GenerateModuleAction::shouldEraseOutputFiles() {
220 return !getCompilerInstance().getFrontendOpts().AllowPCMWithCompilerErrors &&
221 ASTFrontendAction::shouldEraseOutputFiles();
222}
223
224bool GenerateModuleFromModuleMapAction::BeginSourceFileAction(
225 CompilerInstance &CI) {
226 if (!CI.getLangOpts().Modules) {
227 CI.getDiagnostics().Report(DiagID: diag::err_module_build_requires_fmodules);
228 return false;
229 }
230
231 return GenerateModuleAction::BeginSourceFileAction(CI);
232}
233
234std::unique_ptr<raw_pwrite_stream>
235GenerateModuleFromModuleMapAction::CreateOutputFile(CompilerInstance &CI,
236 StringRef InFile) {
237 // If no output file was provided, figure out where this module would go
238 // in the module cache.
239 if (CI.getFrontendOpts().OutputFile.empty()) {
240 StringRef ModuleMapFile = CI.getFrontendOpts().OriginalModuleMap;
241 if (ModuleMapFile.empty())
242 ModuleMapFile = InFile;
243
244 HeaderSearch &HS = CI.getPreprocessor().getHeaderSearchInfo();
245 ModuleFileName FileName = HS.getCachedModuleFileName(
246 ModuleName: CI.getLangOpts().CurrentModule, ModuleMapPath: ModuleMapFile);
247 CI.getFrontendOpts().OutputFile = FileName.str();
248 }
249
250 // Because this is exposed via libclang we must disable RemoveFileOnSignal.
251 return CI.createDefaultOutputFile(/*Binary=*/true, BaseInput: InFile, /*Extension=*/"",
252 /*RemoveFileOnSignal=*/false,
253 /*CreateMissingDirectories=*/true,
254 /*ForceUseTemporary=*/true,
255 /*SetOnlyIfDifferent=*/SetOnlyIfDifferent);
256}
257
258bool GenerateModuleInterfaceAction::PrepareToExecuteAction(
259 CompilerInstance &CI) {
260 // Documentation comments must still be serialized into the BMI
261 // so importers can query them.
262 CI.getLangOpts().CommentOpts.RetainComments = true;
263
264 for (const auto &FIF : CI.getFrontendOpts().Inputs) {
265 if (const auto InputFormat = FIF.getKind().getFormat();
266 InputFormat != InputKind::Format::Source) {
267 CI.getDiagnostics().Report(
268 DiagID: diag::err_frontend_action_unsupported_input_format)
269 << "module interface compilation" << FIF.getFile() << InputFormat;
270 return false;
271 }
272 }
273 return GenerateModuleAction::PrepareToExecuteAction(CI);
274}
275
276bool GenerateModuleInterfaceAction::BeginSourceFileAction(
277 CompilerInstance &CI) {
278 CI.getLangOpts().setCompilingModule(LangOptions::CMK_ModuleInterface);
279
280 return GenerateModuleAction::BeginSourceFileAction(CI);
281}
282
283std::unique_ptr<ASTConsumer>
284GenerateModuleInterfaceAction::CreateASTConsumer(CompilerInstance &CI,
285 StringRef InFile) {
286 std::vector<std::unique_ptr<ASTConsumer>> Consumers;
287
288 if (CI.getFrontendOpts().GenReducedBMI &&
289 !CI.getFrontendOpts().ModuleOutputPath.empty()) {
290 Consumers.push_back(x: std::make_unique<ReducedBMIGenerator>(
291 args&: CI.getPreprocessor(), args&: CI.getModuleCache(),
292 args&: CI.getFrontendOpts().ModuleOutputPath, args&: CI.getCodeGenOpts(),
293 args: +CI.getFrontendOpts().AllowPCMWithCompilerErrors));
294 }
295
296 Consumers.push_back(x: std::make_unique<CXX20ModulesGenerator>(
297 args&: CI.getPreprocessor(), args&: CI.getModuleCache(),
298 args&: CI.getFrontendOpts().OutputFile, args&: CI.getCodeGenOpts(),
299 args: +CI.getFrontendOpts().AllowPCMWithCompilerErrors));
300
301 return std::make_unique<MultiplexConsumer>(args: std::move(Consumers));
302}
303
304std::unique_ptr<raw_pwrite_stream>
305GenerateModuleInterfaceAction::CreateOutputFile(CompilerInstance &CI,
306 StringRef InFile) {
307 return CI.createDefaultOutputFile(/*Binary=*/true, BaseInput: InFile, Extension: "pcm");
308}
309
310std::unique_ptr<ASTConsumer>
311GenerateReducedModuleInterfaceAction::CreateASTConsumer(CompilerInstance &CI,
312 StringRef InFile) {
313 return std::make_unique<ReducedBMIGenerator>(
314 args&: CI.getPreprocessor(), args&: CI.getModuleCache(),
315 args&: CI.getFrontendOpts().OutputFile, args&: CI.getCodeGenOpts());
316}
317
318bool GenerateHeaderUnitAction::BeginSourceFileAction(CompilerInstance &CI) {
319 if (!CI.getLangOpts().CPlusPlusModules) {
320 CI.getDiagnostics().Report(DiagID: diag::err_module_interface_requires_cpp_modules);
321 return false;
322 }
323 CI.getLangOpts().setCompilingModule(LangOptions::CMK_HeaderUnit);
324 return GenerateModuleAction::BeginSourceFileAction(CI);
325}
326
327std::unique_ptr<raw_pwrite_stream>
328GenerateHeaderUnitAction::CreateOutputFile(CompilerInstance &CI,
329 StringRef InFile) {
330 return CI.createDefaultOutputFile(/*Binary=*/true, BaseInput: InFile, Extension: "pcm");
331}
332
333SyntaxOnlyAction::~SyntaxOnlyAction() {
334}
335
336std::unique_ptr<ASTConsumer>
337SyntaxOnlyAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
338 return std::make_unique<ASTConsumer>();
339}
340
341std::unique_ptr<ASTConsumer>
342DumpModuleInfoAction::CreateASTConsumer(CompilerInstance &CI,
343 StringRef InFile) {
344 return std::make_unique<ASTConsumer>();
345}
346
347std::unique_ptr<ASTConsumer>
348VerifyPCHAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
349 return std::make_unique<ASTConsumer>();
350}
351
352void VerifyPCHAction::ExecuteAction() {
353 CompilerInstance &CI = getCompilerInstance();
354 bool Preamble = CI.getPreprocessorOpts().PrecompiledPreambleBytes.first != 0;
355 const std::string &Sysroot = CI.getHeaderSearchOpts().Sysroot;
356 std::unique_ptr<ASTReader> Reader(new ASTReader(
357 CI.getPreprocessor(), CI.getModuleCache(), &CI.getASTContext(),
358 CI.getPCHContainerReader(), CI.getCodeGenOpts(),
359 CI.getFrontendOpts().ModuleFileExtensions,
360 Sysroot.empty() ? "" : Sysroot.c_str(),
361 DisableValidationForModuleKind::None,
362 /*AllowASTWithCompilerErrors*/ false,
363 /*AllowConfigurationMismatch*/ true,
364 /*ValidateSystemInputs*/ true, /*ForceValidateUserInputs*/ true));
365
366 Reader->ReadAST(FileName: ModuleFileName::makeExplicit(Name: getCurrentFile()),
367 Type: Preamble ? serialization::MK_Preamble : serialization::MK_PCH,
368 ImportLoc: SourceLocation(), ClientLoadCapabilities: ASTReader::ARR_ConfigurationMismatch);
369}
370
371namespace {
372 /// AST reader listener that dumps module information for a module
373 /// file.
374 class DumpModuleInfoListener : public ASTReaderListener {
375 llvm::raw_ostream &Out;
376 FileManager &FileMgr;
377
378 public:
379 DumpModuleInfoListener(llvm::raw_ostream &Out, FileManager &FileMgr)
380 : Out(Out), FileMgr(FileMgr) {}
381
382#define DUMP_BOOLEAN(Value, Text) \
383 Out.indent(4) << Text << ": " << (Value? "Yes" : "No") << "\n"
384
385 bool ReadFullVersionInformation(StringRef FullVersion) override {
386 Out.indent(NumSpaces: 2)
387 << "Generated by "
388 << (FullVersion == getClangFullRepositoryVersion()? "this"
389 : "a different")
390 << " Clang: " << FullVersion << "\n";
391 return ASTReaderListener::ReadFullVersionInformation(FullVersion);
392 }
393
394 void ReadModuleName(StringRef ModuleName) override {
395 Out.indent(NumSpaces: 2) << "Module name: " << ModuleName << "\n";
396 }
397 void ReadModuleMapFile(StringRef ModuleMapPath) override {
398 Out.indent(NumSpaces: 2) << "Module map file: " << ModuleMapPath << "\n";
399 }
400
401 bool ReadLanguageOptions(const LangOptions &LangOpts,
402 StringRef ModuleFilename, bool Complain,
403 bool AllowCompatibleDifferences) override {
404 // FIXME: Replace with C++20 `using enum LangOptions::CompatibilityKind`.
405 using CK = LangOptions::CompatibilityKind;
406
407 Out.indent(NumSpaces: 2) << "Language options:\n";
408#define LANGOPT(Name, Bits, Default, Compatibility, Description) \
409 if constexpr (CK::Compatibility != CK::Benign) \
410 DUMP_BOOLEAN(LangOpts.Name, Description);
411#define ENUM_LANGOPT(Name, Type, Bits, Default, Compatibility, Description) \
412 if constexpr (CK::Compatibility != CK::Benign) \
413 Out.indent(4) << Description << ": " \
414 << static_cast<unsigned>(LangOpts.get##Name()) << "\n";
415#define VALUE_LANGOPT(Name, Bits, Default, Compatibility, Description) \
416 if constexpr (CK::Compatibility != CK::Benign) \
417 Out.indent(4) << Description << ": " << LangOpts.Name << "\n";
418#include "clang/Basic/LangOptions.def"
419
420 if (!LangOpts.ModuleFeatures.empty()) {
421 Out.indent(NumSpaces: 4) << "Module features:\n";
422 for (StringRef Feature : LangOpts.ModuleFeatures)
423 Out.indent(NumSpaces: 6) << Feature << "\n";
424 }
425
426 return false;
427 }
428
429 bool ReadTargetOptions(const TargetOptions &TargetOpts,
430 StringRef ModuleFilename, bool Complain,
431 bool AllowCompatibleDifferences) override {
432 Out.indent(NumSpaces: 2) << "Target options:\n";
433 Out.indent(NumSpaces: 4) << " Triple: " << TargetOpts.Triple << "\n";
434 Out.indent(NumSpaces: 4) << " CPU: " << TargetOpts.CPU << "\n";
435 Out.indent(NumSpaces: 4) << " TuneCPU: " << TargetOpts.TuneCPU << "\n";
436 Out.indent(NumSpaces: 4) << " ABI: " << TargetOpts.ABI << "\n";
437
438 if (!TargetOpts.FeaturesAsWritten.empty()) {
439 Out.indent(NumSpaces: 4) << "Target features:\n";
440 for (unsigned I = 0, N = TargetOpts.FeaturesAsWritten.size();
441 I != N; ++I) {
442 Out.indent(NumSpaces: 6) << TargetOpts.FeaturesAsWritten[I] << "\n";
443 }
444 }
445
446 return false;
447 }
448
449 bool ReadDiagnosticOptions(DiagnosticOptions &DiagOpts,
450 StringRef ModuleFilename,
451 bool Complain) override {
452 Out.indent(NumSpaces: 2) << "Diagnostic options:\n";
453#define DIAGOPT(Name, Bits, Default) DUMP_BOOLEAN(DiagOpts.Name, #Name);
454#define ENUM_DIAGOPT(Name, Type, Bits, Default) \
455 Out.indent(4) << #Name << ": " \
456 << static_cast<unsigned>(DiagOpts.get##Name()) << "\n";
457#define VALUE_DIAGOPT(Name, Bits, Default) \
458 Out.indent(4) << #Name << ": " << DiagOpts.Name << "\n";
459#include "clang/Basic/DiagnosticOptions.def"
460
461 Out.indent(NumSpaces: 4) << "Diagnostic flags:\n";
462 for (const std::string &Warning : DiagOpts.Warnings)
463 Out.indent(NumSpaces: 6) << "-W" << Warning << "\n";
464 for (const std::string &Remark : DiagOpts.Remarks)
465 Out.indent(NumSpaces: 6) << "-R" << Remark << "\n";
466
467 return false;
468 }
469
470 bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
471 StringRef ModuleFilename,
472 StringRef ContextHash,
473 bool Complain) override {
474 std::string SpecificModuleCachePath = createSpecificModuleCachePath(
475 FileMgr, ModuleCachePath: HSOpts.ModuleCachePath, DisableModuleHash: HSOpts.DisableModuleHash,
476 ContextHash: std::string(ContextHash));
477
478 Out.indent(NumSpaces: 2) << "Header search options:\n";
479 Out.indent(NumSpaces: 4) << "System root [-isysroot=]: '" << HSOpts.Sysroot << "'\n";
480 Out.indent(NumSpaces: 4) << "Resource dir [ -resource-dir=]: '" << HSOpts.ResourceDir << "'\n";
481 Out.indent(NumSpaces: 4) << "Module Cache: '" << SpecificModuleCachePath << "'\n";
482 DUMP_BOOLEAN(HSOpts.UseBuiltinIncludes,
483 "Use builtin include directories [-nobuiltininc]");
484 DUMP_BOOLEAN(HSOpts.UseStandardSystemIncludes,
485 "Use standard system include directories [-nostdinc]");
486 DUMP_BOOLEAN(HSOpts.UseStandardCXXIncludes,
487 "Use standard C++ include directories [-nostdinc++]");
488 DUMP_BOOLEAN(HSOpts.UseLibcxx,
489 "Use libc++ (rather than libstdc++) [-stdlib=]");
490 return false;
491 }
492
493 bool ReadHeaderSearchPaths(const HeaderSearchOptions &HSOpts,
494 bool Complain) override {
495 Out.indent(NumSpaces: 2) << "Header search paths:\n";
496 Out.indent(NumSpaces: 4) << "User entries:\n";
497 for (const auto &Entry : HSOpts.UserEntries)
498 Out.indent(NumSpaces: 6) << Entry.Path << "\n";
499 Out.indent(NumSpaces: 4) << "System header prefixes:\n";
500 for (const auto &Prefix : HSOpts.SystemHeaderPrefixes)
501 Out.indent(NumSpaces: 6) << Prefix.Prefix << "\n";
502 Out.indent(NumSpaces: 4) << "VFS overlay files:\n";
503 for (const auto &Overlay : HSOpts.VFSOverlayFiles)
504 Out.indent(NumSpaces: 6) << Overlay << "\n";
505 return false;
506 }
507
508 bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
509 StringRef ModuleFilename, bool ReadMacros,
510 bool Complain,
511 std::string &SuggestedPredefines) override {
512 Out.indent(NumSpaces: 2) << "Preprocessor options:\n";
513 DUMP_BOOLEAN(PPOpts.UsePredefines,
514 "Uses compiler/target-specific predefines [-undef]");
515 DUMP_BOOLEAN(PPOpts.DetailedRecord,
516 "Uses detailed preprocessing record (for indexing)");
517
518 if (ReadMacros) {
519 Out.indent(NumSpaces: 4) << "Predefined macros:\n";
520 }
521
522 for (std::vector<std::pair<std::string, bool/*isUndef*/> >::const_iterator
523 I = PPOpts.Macros.begin(), IEnd = PPOpts.Macros.end();
524 I != IEnd; ++I) {
525 Out.indent(NumSpaces: 6);
526 if (I->second)
527 Out << "-U";
528 else
529 Out << "-D";
530 Out << I->first << "\n";
531 }
532 return false;
533 }
534
535 /// Indicates that a particular module file extension has been read.
536 void readModuleFileExtension(
537 const ModuleFileExtensionMetadata &Metadata) override {
538 Out.indent(NumSpaces: 2) << "Module file extension '"
539 << Metadata.BlockName << "' " << Metadata.MajorVersion
540 << "." << Metadata.MinorVersion;
541 if (!Metadata.UserInfo.empty()) {
542 Out << ": ";
543 Out.write_escaped(Str: Metadata.UserInfo);
544 }
545
546 Out << "\n";
547 }
548
549 /// Tells the \c ASTReaderListener that we want to receive the
550 /// input files of the AST file via \c visitInputFile.
551 bool needsInputFileVisitation() override { return true; }
552
553 /// Tells the \c ASTReaderListener that we want to receive the
554 /// input files of the AST file via \c visitInputFile.
555 bool needsSystemInputFileVisitation() override { return true; }
556
557 /// Indicates that the AST file contains particular input file.
558 ///
559 /// \returns true to continue receiving the next input file, false to stop.
560 bool visitInputFileAsRequested(StringRef FilenameAsRequested,
561 StringRef Filename, bool isSystem,
562 bool isOverridden, time_t StoredTime,
563 bool isExplicitModule) override {
564
565 Out.indent(NumSpaces: 2) << "Input file: " << FilenameAsRequested;
566
567 if (isSystem || isOverridden || isExplicitModule) {
568 Out << " [";
569 if (isSystem) {
570 Out << "System";
571 if (isOverridden || isExplicitModule)
572 Out << ", ";
573 }
574 if (isOverridden) {
575 Out << "Overridden";
576 if (isExplicitModule)
577 Out << ", ";
578 }
579 if (isExplicitModule)
580 Out << "ExplicitModule";
581
582 Out << "]";
583 }
584
585 Out << "\n";
586
587 if (StoredTime > 0)
588 Out.indent(NumSpaces: 4) << "MTime: " << llvm::itostr(X: StoredTime) << "\n";
589
590 return true;
591 }
592
593 /// Returns true if this \c ASTReaderListener wants to receive the
594 /// imports of the AST file via \c visitImport, false otherwise.
595 bool needsImportVisitation() const override { return true; }
596
597 /// If needsImportVisitation returns \c true, this is called for each
598 /// AST file imported by this AST file.
599 void visitImport(StringRef ModuleName, StringRef Filename) override {
600 Out.indent(NumSpaces: 2) << "Imports module '" << ModuleName
601 << "': " << Filename.str() << "\n";
602 }
603#undef DUMP_BOOLEAN
604 };
605}
606
607bool DumpModuleInfoAction::BeginInvocation(CompilerInstance &CI) {
608 // The Object file reader also supports raw ast files and there is no point in
609 // being strict about the module file format in -module-file-info mode.
610 CI.getHeaderSearchOpts().ModuleFormat = "obj";
611 return true;
612}
613
614static StringRef ModuleKindName(Module::ModuleKind MK) {
615 switch (MK) {
616 case Module::ModuleMapModule:
617 return "Module Map Module";
618 case Module::ModuleInterfaceUnit:
619 return "Interface Unit";
620 case Module::ModuleImplementationUnit:
621 return "Implementation Unit";
622 case Module::ModulePartitionInterface:
623 return "Partition Interface";
624 case Module::ModulePartitionImplementation:
625 return "Partition Implementation";
626 case Module::ModuleHeaderUnit:
627 return "Header Unit";
628 case Module::ExplicitGlobalModuleFragment:
629 return "Global Module Fragment";
630 case Module::ImplicitGlobalModuleFragment:
631 return "Implicit Module Fragment";
632 case Module::PrivateModuleFragment:
633 return "Private Module Fragment";
634 }
635 llvm_unreachable("unknown module kind!");
636}
637
638void DumpModuleInfoAction::ExecuteAction() {
639 CompilerInstance &CI = getCompilerInstance();
640
641 // Don't process files of type other than module to avoid crash
642 if (!isCurrentFileAST()) {
643 CI.getDiagnostics().Report(DiagID: diag::err_file_is_not_module)
644 << getCurrentFile();
645 return;
646 }
647
648 // Set up the output file.
649 StringRef OutputFileName = CI.getFrontendOpts().OutputFile;
650 if (!OutputFileName.empty() && OutputFileName != "-") {
651 std::error_code EC;
652 OutputStream.reset(p: new llvm::raw_fd_ostream(
653 OutputFileName.str(), EC, llvm::sys::fs::OF_TextWithCRLF));
654 }
655 llvm::raw_ostream &Out = OutputStream ? *OutputStream : llvm::outs();
656
657 Out << "Information for module file '" << getCurrentFile() << "':\n";
658 auto &FileMgr = CI.getFileManager();
659 auto Buffer = FileMgr.getBufferForFile(Filename: getCurrentFile());
660 StringRef Magic = (*Buffer)->getMemBufferRef().getBuffer();
661 bool IsRaw = Magic.starts_with(Prefix: "CPCH");
662 Out << " Module format: " << (IsRaw ? "raw" : "obj") << "\n";
663
664 Preprocessor &PP = CI.getPreprocessor();
665 DumpModuleInfoListener Listener(Out, CI.getFileManager());
666 const HeaderSearchOptions &HSOpts =
667 PP.getHeaderSearchInfo().getHeaderSearchOpts();
668
669 // The FrontendAction::BeginSourceFile () method loads the AST so that much
670 // of the information is already available and modules should have been
671 // loaded.
672
673 const LangOptions &LO = getCurrentASTUnit().getLangOpts();
674 if (LO.CPlusPlusModules && !LO.CurrentModule.empty()) {
675 ASTReader *R = getCurrentASTUnit().getASTReader().get();
676 unsigned SubModuleCount = R->getTotalNumSubmodules();
677 serialization::ModuleFile &MF = R->getModuleManager().getPrimaryModule();
678 Out << " ====== C++20 Module structure ======\n";
679
680 if (MF.ModuleName != LO.CurrentModule)
681 Out << " Mismatched module names : " << MF.ModuleName << " and "
682 << LO.CurrentModule << "\n";
683
684 struct SubModInfo {
685 unsigned Idx;
686 Module *Mod;
687 Module::ModuleKind Kind;
688 std::string &Name;
689 bool Seen;
690 };
691 std::map<std::string, SubModInfo> SubModMap;
692 auto PrintSubMapEntry = [&](std::string Name, Module::ModuleKind Kind) {
693 Out << " " << ModuleKindName(MK: Kind) << " '" << Name << "'";
694 auto I = SubModMap.find(x: Name);
695 if (I == SubModMap.end())
696 Out << " was not found in the sub modules!\n";
697 else {
698 I->second.Seen = true;
699 Out << " is at index #" << I->second.Idx << "\n";
700 }
701 };
702 Module *Primary = nullptr;
703 for (unsigned Idx = 0; Idx <= SubModuleCount; ++Idx) {
704 Module *M = R->getModule(ID: Idx);
705 if (!M)
706 continue;
707 if (M->Name == LO.CurrentModule) {
708 Primary = M;
709 Out << " " << ModuleKindName(MK: M->Kind) << " '" << LO.CurrentModule
710 << "' is the Primary Module at index #" << Idx << "\n";
711 SubModMap.insert(x: {M->Name, {.Idx: Idx, .Mod: M, .Kind: M->Kind, .Name: M->Name, .Seen: true}});
712 } else
713 SubModMap.insert(x: {M->Name, {.Idx: Idx, .Mod: M, .Kind: M->Kind, .Name: M->Name, .Seen: false}});
714 }
715 if (Primary) {
716 if (!Primary->submodules().empty())
717 Out << " Sub Modules:\n";
718 for (Module *MI : Primary->submodules()) {
719 PrintSubMapEntry(MI->Name, MI->Kind);
720 }
721 if (!Primary->Imports.empty())
722 Out << " Imports:\n";
723 for (Module *IMP : Primary->Imports) {
724 PrintSubMapEntry(IMP->Name, IMP->Kind);
725 }
726 if (!Primary->Exports.empty())
727 Out << " Exports:\n";
728 for (unsigned MN = 0, N = Primary->Exports.size(); MN != N; ++MN) {
729 if (Module *M = Primary->Exports[MN].first) {
730 PrintSubMapEntry(M->Name, M->Kind);
731 }
732 }
733 }
734
735 // Emit the macro definitions in the module file so that we can know how
736 // much definitions in the module file quickly.
737 // TODO: Emit the macro definition bodies completely.
738 {
739 std::vector<StringRef> MacroNames;
740 for (const auto &M : R->getPreprocessor().macros()) {
741 if (M.first->isFromAST())
742 MacroNames.push_back(x: M.first->getName());
743 }
744 llvm::sort(C&: MacroNames);
745 if (!MacroNames.empty())
746 Out << " Macro Definitions:\n";
747 for (StringRef Name : MacroNames)
748 Out << " " << Name << "\n";
749 }
750
751 // Now let's print out any modules we did not see as part of the Primary.
752 for (const auto &SM : SubModMap) {
753 if (!SM.second.Seen && SM.second.Mod) {
754 Out << " " << ModuleKindName(MK: SM.second.Kind) << " '" << SM.first
755 << "' at index #" << SM.second.Idx
756 << " has no direct reference in the Primary\n";
757 }
758 }
759 Out << " ====== ======\n";
760 }
761
762 // The reminder of the output is produced from the listener as the AST
763 // FileCcontrolBlock is (re-)parsed.
764 ASTReader::readASTFileControlBlock(
765 Filename: getCurrentFile(), FileMgr, ModCache: CI.getModuleCache(),
766 PCHContainerRdr: CI.getPCHContainerReader(),
767 /*FindModuleFileExtensions=*/true, Listener,
768 ValidateDiagnosticOptions: HSOpts.ModulesValidateDiagnosticOptions);
769}
770
771//===----------------------------------------------------------------------===//
772// Preprocessor Actions
773//===----------------------------------------------------------------------===//
774
775void DumpRawTokensAction::ExecuteAction() {
776 Preprocessor &PP = getCompilerInstance().getPreprocessor();
777 SourceManager &SM = PP.getSourceManager();
778
779 // Start lexing the specified input file.
780 llvm::MemoryBufferRef FromFile = SM.getBufferOrFake(FID: SM.getMainFileID());
781 Lexer RawLex(SM.getMainFileID(), FromFile, SM, PP.getLangOpts());
782 RawLex.SetKeepWhitespaceMode(true);
783
784 Token RawTok;
785 RawLex.LexFromRawLexer(Result&: RawTok);
786 while (RawTok.isNot(K: tok::eof)) {
787 PP.DumpToken(Tok: RawTok, DumpFlags: true);
788 llvm::errs() << "\n";
789 RawLex.LexFromRawLexer(Result&: RawTok);
790 }
791}
792
793void DumpTokensAction::ExecuteAction() {
794 Preprocessor &PP = getCompilerInstance().getPreprocessor();
795 // Start preprocessing the specified input file.
796 Token Tok;
797 PP.EnterMainSourceFile();
798 do {
799 PP.Lex(Result&: Tok);
800 PP.DumpToken(Tok, DumpFlags: true);
801 llvm::errs() << "\n";
802 } while (Tok.isNot(K: tok::eof));
803}
804
805void PreprocessOnlyAction::ExecuteAction() {
806 Preprocessor &PP = getCompilerInstance().getPreprocessor();
807
808 // Ignore unknown pragmas.
809 PP.IgnorePragmas();
810
811 Token Tok;
812 // Start parsing the specified input file.
813 PP.EnterMainSourceFile();
814 do {
815 PP.Lex(Result&: Tok);
816 } while (Tok.isNot(K: tok::eof));
817}
818
819void PrintPreprocessedAction::ExecuteAction() {
820 CompilerInstance &CI = getCompilerInstance();
821 // Output file may need to be set to 'Binary', to avoid converting Unix style
822 // line feeds (<LF>) to Microsoft style line feeds (<CR><LF>) on Windows.
823 //
824 // Look to see what type of line endings the file uses. If there's a
825 // CRLF, then we won't open the file up in binary mode. If there is
826 // just an LF or CR, then we will open the file up in binary mode.
827 // In this fashion, the output format should match the input format, unless
828 // the input format has inconsistent line endings.
829 //
830 // This should be a relatively fast operation since most files won't have
831 // all of their source code on a single line. However, that is still a
832 // concern, so if we scan for too long, we'll just assume the file should
833 // be opened in binary mode.
834
835 bool BinaryMode = false;
836 if (llvm::Triple(LLVM_HOST_TRIPLE).isOSWindows()) {
837 BinaryMode = true;
838 const SourceManager &SM = CI.getSourceManager();
839 if (std::optional<llvm::MemoryBufferRef> Buffer =
840 SM.getBufferOrNone(FID: SM.getMainFileID())) {
841 const char *cur = Buffer->getBufferStart();
842 const char *end = Buffer->getBufferEnd();
843 const char *next = (cur != end) ? cur + 1 : end;
844
845 // Limit ourselves to only scanning 256 characters into the source
846 // file. This is mostly a check in case the file has no
847 // newlines whatsoever.
848 if (end - cur > 256)
849 end = cur + 256;
850
851 while (next < end) {
852 if (*cur == 0x0D) { // CR
853 if (*next == 0x0A) // CRLF
854 BinaryMode = false;
855
856 break;
857 } else if (*cur == 0x0A) // LF
858 break;
859
860 ++cur;
861 ++next;
862 }
863 }
864 }
865
866 std::unique_ptr<raw_ostream> OS =
867 CI.createDefaultOutputFile(Binary: BinaryMode, BaseInput: getCurrentFileOrBufferName());
868 if (!OS) return;
869
870 // If we're preprocessing a module map, start by dumping the contents of the
871 // module itself before switching to the input buffer.
872 auto &Input = getCurrentInput();
873 if (Input.getKind().getFormat() == InputKind::ModuleMap) {
874 if (Input.isFile()) {
875 (*OS) << "# 1 \"";
876 OS->write_escaped(Str: Input.getFile());
877 (*OS) << "\"\n";
878 }
879 getCurrentModule()->print(OS&: *OS);
880 (*OS) << "#pragma clang module contents\n";
881 }
882
883 DoPrintPreprocessedInput(PP&: CI.getPreprocessor(), OS: OS.get(),
884 Opts: CI.getPreprocessorOutputOpts());
885}
886
887void PrintPreambleAction::ExecuteAction() {
888 switch (getCurrentFileKind().getLanguage()) {
889 case Language::C:
890 case Language::CXX:
891 case Language::ObjC:
892 case Language::ObjCXX:
893 case Language::OpenCL:
894 case Language::OpenCLCXX:
895 case Language::CUDA:
896 case Language::HIP:
897 case Language::HLSL:
898 break;
899
900 case Language::Unknown:
901 case Language::Asm:
902 case Language::LLVM_IR:
903 case Language::CIR:
904 // We can't do anything with these.
905 return;
906 }
907
908 // We don't expect to find any #include directives in a preprocessed input.
909 if (getCurrentFileKind().isPreprocessed())
910 return;
911
912 CompilerInstance &CI = getCompilerInstance();
913 auto Buffer = CI.getFileManager().getBufferForFile(Filename: getCurrentFile());
914 if (Buffer) {
915 unsigned Preamble =
916 Lexer::ComputePreamble(Buffer: (*Buffer)->getBuffer(), LangOpts: CI.getLangOpts()).Size;
917 llvm::outs().write(Ptr: (*Buffer)->getBufferStart(), Size: Preamble);
918 }
919}
920
921static void writeCompilerOptionValues(raw_ostream &OS,
922 StringRef CompilerOptionNames,
923 ArrayRef<bool> CompilerOptionValues) {
924 bool FirstValue = true;
925 for (bool CompilerOptionValue : CompilerOptionValues) {
926 auto [CompilerOptionName, RemainingCompilerOptionNames] =
927 CompilerOptionNames.split(Separator: '\0');
928 CompilerOptionNames = RemainingCompilerOptionNames;
929 if (!FirstValue)
930 OS << ",\n";
931 FirstValue = false;
932 OS << "\t{\"" << CompilerOptionName
933 << "\" : " << (CompilerOptionValue ? "true" : "false") << "}";
934 }
935 assert(CompilerOptionNames.empty() && "compiler option name count mismatch");
936}
937
938void DumpCompilerOptionsAction::ExecuteAction() {
939 CompilerInstance &CI = getCompilerInstance();
940 std::unique_ptr<raw_ostream> OSP =
941 CI.createDefaultOutputFile(Binary: false, BaseInput: getCurrentFile());
942 if (!OSP)
943 return;
944
945 raw_ostream &OS = *OSP;
946 const Preprocessor &PP = CI.getPreprocessor();
947 const LangOptions &LangOpts = PP.getLangOpts();
948
949 // FIXME: Rather than manually format the JSON (which is awkward due to
950 // needing to remove trailing commas), this should make use of a JSON library.
951 // FIXME: Instead of printing enums as an integral value and specifying the
952 // type as a separate field, use introspection to print the enumerator.
953
954 OS << "{\n";
955 OS << "\n\"features\" : [\n";
956 {
957 static constexpr char FeatureNames[] = {
958#define FEATURE(Name, Predicate) #Name "\0"
959#include "clang/Basic/Features.def"
960 };
961 const bool FeatureValues[] = {
962#define FEATURE(Name, Predicate) static_cast<bool>(Predicate),
963#include "clang/Basic/Features.def"
964 };
965 writeCompilerOptionValues(
966 OS, CompilerOptionNames: StringRef(FeatureNames, sizeof(FeatureNames) - 1), CompilerOptionValues: FeatureValues);
967 }
968 OS << "\n],\n";
969
970 OS << "\n\"extensions\" : [\n";
971 {
972 static constexpr char ExtensionNames[] = {
973#define EXTENSION(Name, Predicate) #Name "\0"
974#include "clang/Basic/Features.def"
975 };
976 const bool ExtensionValues[] = {
977#define EXTENSION(Name, Predicate) static_cast<bool>(Predicate),
978#include "clang/Basic/Features.def"
979 };
980 writeCompilerOptionValues(
981 OS, CompilerOptionNames: StringRef(ExtensionNames, sizeof(ExtensionNames) - 1),
982 CompilerOptionValues: ExtensionValues);
983 }
984 OS << "\n]\n";
985
986 OS << "}";
987}
988
989void PrintDependencyDirectivesSourceMinimizerAction::ExecuteAction() {
990 CompilerInstance &CI = getCompilerInstance();
991 SourceManager &SM = CI.getPreprocessor().getSourceManager();
992 llvm::MemoryBufferRef FromFile = SM.getBufferOrFake(FID: SM.getMainFileID());
993
994 llvm::SmallVector<dependency_directives_scan::Token, 16> Tokens;
995 llvm::SmallVector<dependency_directives_scan::Directive, 32> Directives;
996 if (scanSourceForDependencyDirectives(
997 Input: FromFile.getBuffer(), Tokens, Directives, Diags: &CI.getDiagnostics(),
998 InputSourceLoc: SM.getLocForStartOfFile(FID: SM.getMainFileID()))) {
999 assert(CI.getDiagnostics().hasErrorOccurred() &&
1000 "no errors reported for failure");
1001
1002 // Preprocess the source when verifying the diagnostics to capture the
1003 // 'expected' comments.
1004 if (CI.getDiagnosticOpts().VerifyDiagnostics) {
1005 // Make sure we don't emit new diagnostics!
1006 CI.getDiagnostics().setSuppressAllDiagnostics(true);
1007 Preprocessor &PP = getCompilerInstance().getPreprocessor();
1008 PP.EnterMainSourceFile();
1009 Token Tok;
1010 do {
1011 PP.Lex(Result&: Tok);
1012 } while (Tok.isNot(K: tok::eof));
1013 }
1014 return;
1015 }
1016 printDependencyDirectivesAsSource(Source: FromFile.getBuffer(), Directives,
1017 OS&: llvm::outs());
1018}
1019
1020//===----------------------------------------------------------------------===//
1021// HLSL Specific Actions
1022//===----------------------------------------------------------------------===//
1023
1024class InjectRootSignatureCallback : public PPCallbacks {
1025private:
1026 Sema &Actions;
1027 StringRef RootSigName;
1028 llvm::dxbc::RootSignatureVersion Version;
1029
1030 std::optional<StringLiteral *> processStringLiteral(ArrayRef<Token> Tokens) {
1031 for (Token Tok : Tokens)
1032 if (!tok::isStringLiteral(K: Tok.getKind()))
1033 return std::nullopt;
1034
1035 ExprResult StringResult = Actions.ActOnUnevaluatedStringLiteral(StringToks: Tokens);
1036 if (StringResult.isInvalid())
1037 return std::nullopt;
1038
1039 if (auto Signature = dyn_cast<StringLiteral>(Val: StringResult.get()))
1040 return Signature;
1041
1042 return std::nullopt;
1043 }
1044
1045public:
1046 void MacroDefined(const Token &MacroNameTok,
1047 const MacroDirective *MD) override {
1048 if (RootSigName != MacroNameTok.getIdentifierInfo()->getName())
1049 return;
1050
1051 const MacroInfo *MI = MD->getMacroInfo();
1052 auto Signature = processStringLiteral(Tokens: MI->tokens());
1053 if (!Signature.has_value()) {
1054 Actions.getDiagnostics().Report(Loc: MI->getDefinitionLoc(),
1055 DiagID: diag::err_expected_string_literal)
1056 << /*in attributes...*/ 4 << "RootSignature";
1057 return;
1058 }
1059
1060 IdentifierInfo *DeclIdent =
1061 hlsl::ParseHLSLRootSignature(Actions, Version, Signature: *Signature);
1062 Actions.HLSL().SetRootSignatureOverride(DeclIdent);
1063 }
1064
1065 InjectRootSignatureCallback(Sema &Actions, StringRef RootSigName,
1066 llvm::dxbc::RootSignatureVersion Version)
1067 : PPCallbacks(), Actions(Actions), RootSigName(RootSigName),
1068 Version(Version) {}
1069};
1070
1071void HLSLFrontendAction::ExecuteAction() {
1072 // Pre-requisites to invoke
1073 CompilerInstance &CI = getCompilerInstance();
1074 if (!CI.hasASTContext() || !CI.hasPreprocessor())
1075 return WrapperFrontendAction::ExecuteAction();
1076
1077 // InjectRootSignatureCallback requires access to invoke Sema to lookup/
1078 // register a root signature declaration. The wrapped action is required to
1079 // account for this by only creating a Sema if one doesn't already exist
1080 // (like we have done, and, ASTFrontendAction::ExecuteAction)
1081 if (!CI.hasSema())
1082 CI.createSema(TUKind: getTranslationUnitKind(),
1083 /*CodeCompleteConsumer=*/CompletionConsumer: nullptr);
1084 Sema &S = CI.getSema();
1085
1086 auto &TargetInfo = CI.getASTContext().getTargetInfo();
1087 bool IsRootSignatureTarget =
1088 TargetInfo.getTriple().getEnvironment() == llvm::Triple::RootSignature;
1089 StringRef HLSLEntry = TargetInfo.getTargetOpts().HLSLEntry;
1090
1091 // Register HLSL specific callbacks
1092 auto LangOpts = CI.getLangOpts();
1093 StringRef RootSigName =
1094 IsRootSignatureTarget ? HLSLEntry : LangOpts.HLSLRootSigOverride;
1095
1096 auto MacroCallback = std::make_unique<InjectRootSignatureCallback>(
1097 args&: S, args&: RootSigName, args&: LangOpts.HLSLRootSigVer);
1098
1099 Preprocessor &PP = CI.getPreprocessor();
1100 PP.addPPCallbacks(C: std::move(MacroCallback));
1101
1102 // If we are targeting a root signature, invoke custom handling
1103 if (IsRootSignatureTarget)
1104 return hlsl::HandleRootSignatureTarget(S, EntryRootSig: HLSLEntry);
1105 else // otherwise, invoke as normal
1106 return WrapperFrontendAction::ExecuteAction();
1107}
1108
1109HLSLFrontendAction::HLSLFrontendAction(
1110 std::unique_ptr<FrontendAction> WrappedAction)
1111 : WrapperFrontendAction(std::move(WrappedAction)) {}
1112