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/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_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
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(TUKind: Action.getTranslationUnitKind(),
55 CompletionConsumer: GetCodeCompletionConsumer(CI));
56}
57} // namespace
58
59//===----------------------------------------------------------------------===//
60// Custom Actions
61//===----------------------------------------------------------------------===//
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(Result&: Tok);
83 } while (Tok.isNot(K: 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 Actions
94//===----------------------------------------------------------------------===//
95
96std::unique_ptr<ASTConsumer>
97ASTPrintAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
98 if (std::unique_ptr<raw_ostream> OS =
99 CI.createDefaultOutputFile(Binary: false, BaseInput: InFile))
100 return CreateASTPrinter(OS: std::move(OS), FilterString: 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(OS: nullptr /*Dump to stdout.*/, FilterString: Opts.ASTDumpFilter,
108 DumpDecls: Opts.ASTDumpDecls, Deserialize: Opts.ASTDumpAll,
109 DumpLookups: Opts.ASTDumpLookups, DumpDeclTypes: Opts.ASTDumpDeclTypes,
110 Format: 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(x: std::make_unique<PCHGenerator>(
142 args&: CI.getPreprocessor(), args&: CI.getModuleCache(), args&: OutputFile, args&: Sysroot, args&: Buffer,
143 args&: CI.getCodeGenOpts(), args: FrontendOpts.ModuleFileExtensions,
144 args&: CI.getPreprocessorOpts().AllowPCHWithCompilerErrors,
145 args: FrontendOpts.IncludeTimestamps, args: FrontendOpts.BuildingImplicitModule));
146 Consumers.push_back(x: CI.getPCHContainerWriter().CreatePCHContainerGenerator(
147 CI, MainFileName: std::string(InFile), OutputFileName: OutputFile, OS: std::move(OS), Buffer));
148
149 return std::make_unique<MultiplexConsumer>(args: std::move(Consumers));
150}
151
152bool GeneratePCHAction::ComputeASTConsumerArguments(CompilerInstance &CI,
153 std::string &Sysroot) {
154 Sysroot = CI.getHeaderSearchOpts().Sysroot;
155 if (CI.getFrontendOpts().RelocatablePCH && Sysroot.empty()) {
156 CI.getDiagnostics().Report(DiagID: diag::err_relocatable_without_isysroot);
157 return false;
158 }
159
160 return true;
161}
162
163std::unique_ptr<llvm::raw_pwrite_stream>
164GeneratePCHAction::CreateOutputFile(CompilerInstance &CI, StringRef InFile,
165 std::string &OutputFile) {
166 // Because this is exposed via libclang we must disable RemoveFileOnSignal.
167 std::unique_ptr<raw_pwrite_stream> OS = CI.createDefaultOutputFile(
168 /*Binary=*/true, BaseInput: InFile, /*Extension=*/"", /*RemoveFileOnSignal=*/false);
169 if (!OS)
170 return nullptr;
171
172 OutputFile = CI.getFrontendOpts().OutputFile;
173 return OS;
174}
175
176bool GeneratePCHAction::shouldEraseOutputFiles() {
177 if (getCompilerInstance().getPreprocessorOpts().AllowPCHWithCompilerErrors)
178 return false;
179 return ASTFrontendAction::shouldEraseOutputFiles();
180}
181
182bool GeneratePCHAction::BeginSourceFileAction(CompilerInstance &CI) {
183 CI.getLangOpts().CompilingPCH = true;
184 return ASTFrontendAction::BeginSourceFileAction(CI);
185}
186
187std::vector<std::unique_ptr<ASTConsumer>>
188GenerateModuleAction::CreateMultiplexConsumer(CompilerInstance &CI,
189 StringRef InFile) {
190 if (!OS)
191 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(x: std::make_unique<PCHGenerator>(
202 args&: CI.getPreprocessor(), args&: CI.getModuleCache(), args&: OutputFile, args&: Sysroot, args&: Buffer,
203 args&: CI.getCodeGenOpts(), args&: CI.getFrontendOpts().ModuleFileExtensions,
204 /*AllowASTWithErrors=*/
205 args: +CI.getFrontendOpts().AllowPCMWithCompilerErrors,
206 /*IncludeTimestamps=*/
207 args: +CI.getFrontendOpts().BuildingImplicitModule &&
208 +CI.getFrontendOpts().IncludeTimestamps,
209 /*BuildingImplicitModule=*/args: +CI.getFrontendOpts().BuildingImplicitModule));
210 Consumers.push_back(x: CI.getPCHContainerWriter().CreatePCHContainerGenerator(
211 CI, MainFileName: std::string(InFile), OutputFileName: OutputFile, OS: std::move(OS), Buffer));
212 return Consumers;
213}
214
215std::unique_ptr<ASTConsumer>
216GenerateModuleAction::CreateASTConsumer(CompilerInstance &CI,
217 StringRef InFile) {
218 std::vector<std::unique_ptr<ASTConsumer>> Consumers =
219 CreateMultiplexConsumer(CI, InFile);
220 if (Consumers.empty())
221 return nullptr;
222
223 return std::make_unique<MultiplexConsumer>(args: std::move(Consumers));
224}
225
226bool GenerateModuleAction::shouldEraseOutputFiles() {
227 return !getCompilerInstance().getFrontendOpts().AllowPCMWithCompilerErrors &&
228 ASTFrontendAction::shouldEraseOutputFiles();
229}
230
231bool GenerateModuleFromModuleMapAction::BeginSourceFileAction(
232 CompilerInstance &CI) {
233 if (!CI.getLangOpts().Modules) {
234 CI.getDiagnostics().Report(DiagID: diag::err_module_build_requires_fmodules);
235 return false;
236 }
237
238 return GenerateModuleAction::BeginSourceFileAction(CI);
239}
240
241std::unique_ptr<raw_pwrite_stream>
242GenerateModuleFromModuleMapAction::CreateOutputFile(CompilerInstance &CI,
243 StringRef InFile) {
244 // If no output file was provided, figure out where this module would go
245 // in the module cache.
246 if (CI.getFrontendOpts().OutputFile.empty()) {
247 StringRef ModuleMapFile = CI.getFrontendOpts().OriginalModuleMap;
248 if (ModuleMapFile.empty())
249 ModuleMapFile = InFile;
250
251 HeaderSearch &HS = CI.getPreprocessor().getHeaderSearchInfo();
252 ModuleFileName FileName = HS.getCachedModuleFileName(
253 ModuleName: CI.getLangOpts().CurrentModule, ModuleMapPath: ModuleMapFile);
254 CI.getFrontendOpts().OutputFile = FileName.str();
255 }
256
257 // Because this is exposed via libclang we must disable RemoveFileOnSignal.
258 return CI.createDefaultOutputFile(/*Binary=*/true, BaseInput: InFile, /*Extension=*/"",
259 /*RemoveFileOnSignal=*/false,
260 /*CreateMissingDirectories=*/true,
261 /*ForceUseTemporary=*/true);
262}
263
264bool GenerateModuleInterfaceAction::PrepareToExecuteAction(
265 CompilerInstance &CI) {
266 for (const auto &FIF : CI.getFrontendOpts().Inputs) {
267 if (const auto InputFormat = FIF.getKind().getFormat();
268 InputFormat != InputKind::Format::Source) {
269 CI.getDiagnostics().Report(
270 DiagID: diag::err_frontend_action_unsupported_input_format)
271 << "module interface compilation" << FIF.getFile() << InputFormat;
272 return false;
273 }
274 }
275 return GenerateModuleAction::PrepareToExecuteAction(CI);
276}
277
278bool GenerateModuleInterfaceAction::BeginSourceFileAction(
279 CompilerInstance &CI) {
280 CI.getLangOpts().setCompilingModule(LangOptions::CMK_ModuleInterface);
281
282 return GenerateModuleAction::BeginSourceFileAction(CI);
283}
284
285std::unique_ptr<ASTConsumer>
286GenerateModuleInterfaceAction::CreateASTConsumer(CompilerInstance &CI,
287 StringRef InFile) {
288 std::vector<std::unique_ptr<ASTConsumer>> Consumers;
289
290 if (CI.getFrontendOpts().GenReducedBMI &&
291 !CI.getFrontendOpts().ModuleOutputPath.empty()) {
292 Consumers.push_back(x: std::make_unique<ReducedBMIGenerator>(
293 args&: CI.getPreprocessor(), args&: CI.getModuleCache(),
294 args&: CI.getFrontendOpts().ModuleOutputPath, args&: CI.getCodeGenOpts(),
295 args: +CI.getFrontendOpts().AllowPCMWithCompilerErrors));
296 }
297
298 Consumers.push_back(x: std::make_unique<CXX20ModulesGenerator>(
299 args&: CI.getPreprocessor(), args&: CI.getModuleCache(),
300 args&: CI.getFrontendOpts().OutputFile, args&: CI.getCodeGenOpts(),
301 args: +CI.getFrontendOpts().AllowPCMWithCompilerErrors));
302
303 return std::make_unique<MultiplexConsumer>(args: std::move(Consumers));
304}
305
306std::unique_ptr<raw_pwrite_stream>
307GenerateModuleInterfaceAction::CreateOutputFile(CompilerInstance &CI,
308 StringRef InFile) {
309 return CI.createDefaultOutputFile(/*Binary=*/true, BaseInput: InFile, Extension: "pcm");
310}
311
312std::unique_ptr<ASTConsumer>
313GenerateReducedModuleInterfaceAction::CreateASTConsumer(CompilerInstance &CI,
314 StringRef InFile) {
315 return std::make_unique<ReducedBMIGenerator>(
316 args&: CI.getPreprocessor(), args&: CI.getModuleCache(),
317 args&: CI.getFrontendOpts().OutputFile, args&: CI.getCodeGenOpts());
318}
319
320bool GenerateHeaderUnitAction::BeginSourceFileAction(CompilerInstance &CI) {
321 if (!CI.getLangOpts().CPlusPlusModules) {
322 CI.getDiagnostics().Report(DiagID: diag::err_module_interface_requires_cpp_modules);
323 return false;
324 }
325 CI.getLangOpts().setCompilingModule(LangOptions::CMK_HeaderUnit);
326 return GenerateModuleAction::BeginSourceFileAction(CI);
327}
328
329std::unique_ptr<raw_pwrite_stream>
330GenerateHeaderUnitAction::CreateOutputFile(CompilerInstance &CI,
331 StringRef InFile) {
332 return CI.createDefaultOutputFile(/*Binary=*/true, BaseInput: InFile, Extension: "pcm");
333}
334
335SyntaxOnlyAction::~SyntaxOnlyAction() {
336}
337
338std::unique_ptr<ASTConsumer>
339SyntaxOnlyAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
340 return std::make_unique<ASTConsumer>();
341}
342
343std::unique_ptr<ASTConsumer>
344DumpModuleInfoAction::CreateASTConsumer(CompilerInstance &CI,
345 StringRef InFile) {
346 return std::make_unique<ASTConsumer>();
347}
348
349std::unique_ptr<ASTConsumer>
350VerifyPCHAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
351 return std::make_unique<ASTConsumer>();
352}
353
354void VerifyPCHAction::ExecuteAction() {
355 CompilerInstance &CI = getCompilerInstance();
356 bool Preamble = CI.getPreprocessorOpts().PrecompiledPreambleBytes.first != 0;
357 const std::string &Sysroot = CI.getHeaderSearchOpts().Sysroot;
358 std::unique_ptr<ASTReader> Reader(new ASTReader(
359 CI.getPreprocessor(), CI.getModuleCache(), &CI.getASTContext(),
360 CI.getPCHContainerReader(), CI.getCodeGenOpts(),
361 CI.getFrontendOpts().ModuleFileExtensions,
362 Sysroot.empty() ? "" : Sysroot.c_str(),
363 DisableValidationForModuleKind::None,
364 /*AllowASTWithCompilerErrors*/ false,
365 /*AllowConfigurationMismatch*/ true,
366 /*ValidateSystemInputs*/ true, /*ForceValidateUserInputs*/ true));
367
368 Reader->ReadAST(FileName: ModuleFileName::makeExplicit(Name: getCurrentFile()),
369 Type: Preamble ? serialization::MK_Preamble : serialization::MK_PCH,
370 ImportLoc: SourceLocation(), ClientLoadCapabilities: ASTReader::ARR_ConfigurationMismatch);
371}
372
373namespace {
374struct TemplightEntry {
375 std::string Name;
376 std::string Kind;
377 std::string Event;
378 std::string DefinitionLocation;
379 std::string PointOfInstantiation;
380};
381} // namespace
382
383namespace llvm {
384namespace yaml {
385template <> struct MappingTraits<TemplightEntry> {
386 static void mapping(IO &io, TemplightEntry &fields) {
387 io.mapRequired(Key: "name", Val&: fields.Name);
388 io.mapRequired(Key: "kind", Val&: fields.Kind);
389 io.mapRequired(Key: "event", Val&: fields.Event);
390 io.mapRequired(Key: "orig", Val&: fields.DefinitionLocation);
391 io.mapRequired(Key: "poi", Val&: fields.PointOfInstantiation);
392 }
393};
394} // namespace yaml
395} // namespace llvm
396
397namespace {
398class DefaultTemplateInstCallback : public TemplateInstantiationCallback {
399 using CodeSynthesisContext = Sema::CodeSynthesisContext;
400
401public:
402 void initialize(const Sema &) override {}
403
404 void finalize(const Sema &) override {}
405
406 void atTemplateBegin(const Sema &TheSema,
407 const CodeSynthesisContext &Inst) override {
408 displayTemplightEntry<true>(Out&: llvm::outs(), TheSema, Inst);
409 }
410
411 void atTemplateEnd(const Sema &TheSema,
412 const CodeSynthesisContext &Inst) override {
413 displayTemplightEntry<false>(Out&: llvm::outs(), TheSema, Inst);
414 }
415
416private:
417 static std::string toString(CodeSynthesisContext::SynthesisKind Kind) {
418 switch (Kind) {
419 case CodeSynthesisContext::TemplateInstantiation:
420 return "TemplateInstantiation";
421 case CodeSynthesisContext::DefaultTemplateArgumentInstantiation:
422 return "DefaultTemplateArgumentInstantiation";
423 case CodeSynthesisContext::DefaultFunctionArgumentInstantiation:
424 return "DefaultFunctionArgumentInstantiation";
425 case CodeSynthesisContext::ExplicitTemplateArgumentSubstitution:
426 return "ExplicitTemplateArgumentSubstitution";
427 case CodeSynthesisContext::DeducedTemplateArgumentSubstitution:
428 return "DeducedTemplateArgumentSubstitution";
429 case CodeSynthesisContext::LambdaExpressionSubstitution:
430 return "LambdaExpressionSubstitution";
431 case CodeSynthesisContext::PriorTemplateArgumentSubstitution:
432 return "PriorTemplateArgumentSubstitution";
433 case CodeSynthesisContext::DefaultTemplateArgumentChecking:
434 return "DefaultTemplateArgumentChecking";
435 case CodeSynthesisContext::ExceptionSpecEvaluation:
436 return "ExceptionSpecEvaluation";
437 case CodeSynthesisContext::ExceptionSpecInstantiation:
438 return "ExceptionSpecInstantiation";
439 case CodeSynthesisContext::DeclaringSpecialMember:
440 return "DeclaringSpecialMember";
441 case CodeSynthesisContext::DeclaringImplicitEqualityComparison:
442 return "DeclaringImplicitEqualityComparison";
443 case CodeSynthesisContext::DefiningSynthesizedFunction:
444 return "DefiningSynthesizedFunction";
445 case CodeSynthesisContext::RewritingOperatorAsSpaceship:
446 return "RewritingOperatorAsSpaceship";
447 case CodeSynthesisContext::Memoization:
448 return "Memoization";
449 case CodeSynthesisContext::ConstraintsCheck:
450 return "ConstraintsCheck";
451 case CodeSynthesisContext::ConstraintSubstitution:
452 return "ConstraintSubstitution";
453 case CodeSynthesisContext::ConstraintNormalization:
454 return "ConstraintNormalization";
455 case CodeSynthesisContext::RequirementParameterInstantiation:
456 return "RequirementParameterInstantiation";
457 case CodeSynthesisContext::ParameterMappingSubstitution:
458 return "ParameterMappingSubstitution";
459 case CodeSynthesisContext::RequirementInstantiation:
460 return "RequirementInstantiation";
461 case CodeSynthesisContext::NestedRequirementConstraintsCheck:
462 return "NestedRequirementConstraintsCheck";
463 case CodeSynthesisContext::InitializingStructuredBinding:
464 return "InitializingStructuredBinding";
465 case CodeSynthesisContext::MarkingClassDllexported:
466 return "MarkingClassDllexported";
467 case CodeSynthesisContext::BuildingBuiltinDumpStructCall:
468 return "BuildingBuiltinDumpStructCall";
469 case CodeSynthesisContext::BuildingDeductionGuides:
470 return "BuildingDeductionGuides";
471 case CodeSynthesisContext::TypeAliasTemplateInstantiation:
472 return "TypeAliasTemplateInstantiation";
473 case CodeSynthesisContext::PartialOrderingTTP:
474 return "PartialOrderingTTP";
475 case CodeSynthesisContext::SYCLKernelLaunchLookup:
476 return "SYCLKernelLaunchLookup";
477 case CodeSynthesisContext::SYCLKernelLaunchOverloadResolution:
478 return "SYCLKernelLaunchOverloadResolution";
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(io&: YO, Val&: Entry, true, Ctx&: 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>(Val: Entity);
501
502 PrintingPolicy Policy = TheSema.Context.getPrintingPolicy();
503 // FIXME: Also ask for FullyQualifiedNames?
504 Policy.SuppressDefaultTemplateArgs = false;
505 NamedTemplate->getNameForDiagnostic(OS, Policy, Qualified: 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>(Val: Ctx);
512
513 if (const auto *Decl = dyn_cast<TagDecl>(Val: NamedTemplate)) {
514 if (const auto *R = dyn_cast<RecordDecl>(Val: Decl)) {
515 if (R->isLambda()) {
516 OS << "lambda at ";
517 Decl->getLocation().print(OS, SM: 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>(Val: 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, Policy: TheSema.getLangOpts(), Qualified: true);
534 return;
535 }
536
537 if (const auto *Decl = dyn_cast<TemplateTypeParmDecl>(Val: NamedTemplate)) {
538 if (const Type *Ty = Decl->getTypeForDecl()) {
539 if (const auto *TTPT = dyn_cast_or_null<TemplateTypeParmType>(Val: 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, Policy: TheSema.getLangOpts(), Qualified: true);
545 return;
546 }
547 }
548 }
549
550 if (const auto *Decl = dyn_cast<NonTypeTemplateParmDecl>(Val: 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, Policy: TheSema.getLangOpts(), Qualified: true);
556 return;
557 }
558
559 if (const auto *Decl = dyn_cast<TemplateTemplateParmDecl>(Val: 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, Policy: TheSema.getLangOpts(), Qualified: 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(Kind: Inst.Kind);
577 Entry.Event = BeginInstantiation ? "Begin" : "End";
578 llvm::raw_string_ostream OS(Entry.Name);
579 printEntryName(TheSema, Entity: Inst.Entity, OS);
580 const PresumedLoc DefLoc =
581 TheSema.getSourceManager().getPresumedLoc(Loc: Inst.Entity->getLocation());
582 if (!DefLoc.isInvalid())
583 Entry.DefinitionLocation = std::string(DefLoc.getFilename()) + ":" +
584 std::to_string(val: DefLoc.getLine()) + ":" +
585 std::to_string(val: DefLoc.getColumn());
586 const PresumedLoc PoiLoc =
587 TheSema.getSourceManager().getPresumedLoc(Loc: Inst.PointOfInstantiation);
588 if (!PoiLoc.isInvalid()) {
589 Entry.PointOfInstantiation = std::string(PoiLoc.getFilename()) + ":" +
590 std::to_string(val: PoiLoc.getLine()) + ":" +
591 std::to_string(val: PoiLoc.getColumn());
592 }
593 return Entry;
594 }
595};
596} // namespace
597
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 happen
607 // before Templight observers can be created
608 // FIXME: Move the truncation aspect of this into Sema, we delayed this till
609 // here so the source manager would be initialized.
610 EnsureSemaIsCreated(CI, Action&: *this);
611
612 CI.getSema().TemplateInstCallbacks.push_back(
613 x: std::make_unique<DefaultTemplateInstCallback>());
614 ASTFrontendAction::ExecuteAction();
615}
616
617namespace {
618 /// AST reader listener that dumps module information for a module
619 /// file.
620 class DumpModuleInfoListener : public ASTReaderListener {
621 llvm::raw_ostream &Out;
622 FileManager &FileMgr;
623
624 public:
625 DumpModuleInfoListener(llvm::raw_ostream &Out, FileManager &FileMgr)
626 : Out(Out), FileMgr(FileMgr) {}
627
628#define DUMP_BOOLEAN(Value, Text) \
629 Out.indent(4) << Text << ": " << (Value? "Yes" : "No") << "\n"
630
631 bool ReadFullVersionInformation(StringRef FullVersion) override {
632 Out.indent(NumSpaces: 2)
633 << "Generated by "
634 << (FullVersion == getClangFullRepositoryVersion()? "this"
635 : "a different")
636 << " Clang: " << FullVersion << "\n";
637 return ASTReaderListener::ReadFullVersionInformation(FullVersion);
638 }
639
640 void ReadModuleName(StringRef ModuleName) override {
641 Out.indent(NumSpaces: 2) << "Module name: " << ModuleName << "\n";
642 }
643 void ReadModuleMapFile(StringRef ModuleMapPath) override {
644 Out.indent(NumSpaces: 2) << "Module map file: " << ModuleMapPath << "\n";
645 }
646
647 bool ReadLanguageOptions(const LangOptions &LangOpts,
648 StringRef ModuleFilename, bool Complain,
649 bool AllowCompatibleDifferences) override {
650 // FIXME: Replace with C++20 `using enum LangOptions::CompatibilityKind`.
651 using CK = LangOptions::CompatibilityKind;
652
653 Out.indent(NumSpaces: 2) << "Language options:\n";
654#define LANGOPT(Name, Bits, Default, Compatibility, Description) \
655 if constexpr (CK::Compatibility != CK::Benign) \
656 DUMP_BOOLEAN(LangOpts.Name, Description);
657#define ENUM_LANGOPT(Name, Type, Bits, Default, Compatibility, Description) \
658 if constexpr (CK::Compatibility != CK::Benign) \
659 Out.indent(4) << Description << ": " \
660 << static_cast<unsigned>(LangOpts.get##Name()) << "\n";
661#define VALUE_LANGOPT(Name, Bits, Default, Compatibility, Description) \
662 if constexpr (CK::Compatibility != CK::Benign) \
663 Out.indent(4) << Description << ": " << LangOpts.Name << "\n";
664#include "clang/Basic/LangOptions.def"
665
666 if (!LangOpts.ModuleFeatures.empty()) {
667 Out.indent(NumSpaces: 4) << "Module features:\n";
668 for (StringRef Feature : LangOpts.ModuleFeatures)
669 Out.indent(NumSpaces: 6) << Feature << "\n";
670 }
671
672 return false;
673 }
674
675 bool ReadTargetOptions(const TargetOptions &TargetOpts,
676 StringRef ModuleFilename, bool Complain,
677 bool AllowCompatibleDifferences) override {
678 Out.indent(NumSpaces: 2) << "Target options:\n";
679 Out.indent(NumSpaces: 4) << " Triple: " << TargetOpts.Triple << "\n";
680 Out.indent(NumSpaces: 4) << " CPU: " << TargetOpts.CPU << "\n";
681 Out.indent(NumSpaces: 4) << " TuneCPU: " << TargetOpts.TuneCPU << "\n";
682 Out.indent(NumSpaces: 4) << " ABI: " << TargetOpts.ABI << "\n";
683
684 if (!TargetOpts.FeaturesAsWritten.empty()) {
685 Out.indent(NumSpaces: 4) << "Target features:\n";
686 for (unsigned I = 0, N = TargetOpts.FeaturesAsWritten.size();
687 I != N; ++I) {
688 Out.indent(NumSpaces: 6) << TargetOpts.FeaturesAsWritten[I] << "\n";
689 }
690 }
691
692 return false;
693 }
694
695 bool ReadDiagnosticOptions(DiagnosticOptions &DiagOpts,
696 StringRef ModuleFilename,
697 bool Complain) override {
698 Out.indent(NumSpaces: 2) << "Diagnostic options:\n";
699#define DIAGOPT(Name, Bits, Default) DUMP_BOOLEAN(DiagOpts.Name, #Name);
700#define ENUM_DIAGOPT(Name, Type, Bits, Default) \
701 Out.indent(4) << #Name << ": " << DiagOpts.get##Name() << "\n";
702#define VALUE_DIAGOPT(Name, Bits, Default) \
703 Out.indent(4) << #Name << ": " << DiagOpts.Name << "\n";
704#include "clang/Basic/DiagnosticOptions.def"
705
706 Out.indent(NumSpaces: 4) << "Diagnostic flags:\n";
707 for (const std::string &Warning : DiagOpts.Warnings)
708 Out.indent(NumSpaces: 6) << "-W" << Warning << "\n";
709 for (const std::string &Remark : DiagOpts.Remarks)
710 Out.indent(NumSpaces: 6) << "-R" << Remark << "\n";
711
712 return false;
713 }
714
715 bool ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts,
716 StringRef ModuleFilename,
717 StringRef ContextHash,
718 bool Complain) override {
719 std::string SpecificModuleCachePath = createSpecificModuleCachePath(
720 FileMgr, ModuleCachePath: HSOpts.ModuleCachePath, DisableModuleHash: HSOpts.DisableModuleHash,
721 ContextHash: std::string(ContextHash));
722
723 Out.indent(NumSpaces: 2) << "Header search options:\n";
724 Out.indent(NumSpaces: 4) << "System root [-isysroot=]: '" << HSOpts.Sysroot << "'\n";
725 Out.indent(NumSpaces: 4) << "Resource dir [ -resource-dir=]: '" << HSOpts.ResourceDir << "'\n";
726 Out.indent(NumSpaces: 4) << "Module Cache: '" << SpecificModuleCachePath << "'\n";
727 DUMP_BOOLEAN(HSOpts.UseBuiltinIncludes,
728 "Use builtin include directories [-nobuiltininc]");
729 DUMP_BOOLEAN(HSOpts.UseStandardSystemIncludes,
730 "Use standard system include directories [-nostdinc]");
731 DUMP_BOOLEAN(HSOpts.UseStandardCXXIncludes,
732 "Use standard C++ include directories [-nostdinc++]");
733 DUMP_BOOLEAN(HSOpts.UseLibcxx,
734 "Use libc++ (rather than libstdc++) [-stdlib=]");
735 return false;
736 }
737
738 bool ReadHeaderSearchPaths(const HeaderSearchOptions &HSOpts,
739 bool Complain) override {
740 Out.indent(NumSpaces: 2) << "Header search paths:\n";
741 Out.indent(NumSpaces: 4) << "User entries:\n";
742 for (const auto &Entry : HSOpts.UserEntries)
743 Out.indent(NumSpaces: 6) << Entry.Path << "\n";
744 Out.indent(NumSpaces: 4) << "System header prefixes:\n";
745 for (const auto &Prefix : HSOpts.SystemHeaderPrefixes)
746 Out.indent(NumSpaces: 6) << Prefix.Prefix << "\n";
747 Out.indent(NumSpaces: 4) << "VFS overlay files:\n";
748 for (const auto &Overlay : HSOpts.VFSOverlayFiles)
749 Out.indent(NumSpaces: 6) << Overlay << "\n";
750 return false;
751 }
752
753 bool ReadPreprocessorOptions(const PreprocessorOptions &PPOpts,
754 StringRef ModuleFilename, bool ReadMacros,
755 bool Complain,
756 std::string &SuggestedPredefines) override {
757 Out.indent(NumSpaces: 2) << "Preprocessor options:\n";
758 DUMP_BOOLEAN(PPOpts.UsePredefines,
759 "Uses compiler/target-specific predefines [-undef]");
760 DUMP_BOOLEAN(PPOpts.DetailedRecord,
761 "Uses detailed preprocessing record (for indexing)");
762
763 if (ReadMacros) {
764 Out.indent(NumSpaces: 4) << "Predefined macros:\n";
765 }
766
767 for (std::vector<std::pair<std::string, bool/*isUndef*/> >::const_iterator
768 I = PPOpts.Macros.begin(), IEnd = PPOpts.Macros.end();
769 I != IEnd; ++I) {
770 Out.indent(NumSpaces: 6);
771 if (I->second)
772 Out << "-U";
773 else
774 Out << "-D";
775 Out << I->first << "\n";
776 }
777 return false;
778 }
779
780 /// Indicates that a particular module file extension has been read.
781 void readModuleFileExtension(
782 const ModuleFileExtensionMetadata &Metadata) override {
783 Out.indent(NumSpaces: 2) << "Module file extension '"
784 << Metadata.BlockName << "' " << Metadata.MajorVersion
785 << "." << Metadata.MinorVersion;
786 if (!Metadata.UserInfo.empty()) {
787 Out << ": ";
788 Out.write_escaped(Str: Metadata.UserInfo);
789 }
790
791 Out << "\n";
792 }
793
794 /// Tells the \c ASTReaderListener that we want to receive the
795 /// input files of the AST file via \c visitInputFile.
796 bool needsInputFileVisitation() override { return true; }
797
798 /// Tells the \c ASTReaderListener that we want to receive the
799 /// input files of the AST file via \c visitInputFile.
800 bool needsSystemInputFileVisitation() override { return true; }
801
802 /// Indicates that the AST file contains particular input file.
803 ///
804 /// \returns true to continue receiving the next input file, false to stop.
805 bool visitInputFileAsRequested(StringRef FilenameAsRequested,
806 StringRef Filename, bool isSystem,
807 bool isOverridden, time_t StoredTime,
808 bool isExplicitModule) override {
809
810 Out.indent(NumSpaces: 2) << "Input file: " << FilenameAsRequested;
811
812 if (isSystem || isOverridden || isExplicitModule) {
813 Out << " [";
814 if (isSystem) {
815 Out << "System";
816 if (isOverridden || isExplicitModule)
817 Out << ", ";
818 }
819 if (isOverridden) {
820 Out << "Overridden";
821 if (isExplicitModule)
822 Out << ", ";
823 }
824 if (isExplicitModule)
825 Out << "ExplicitModule";
826
827 Out << "]";
828 }
829
830 Out << "\n";
831
832 if (StoredTime > 0)
833 Out.indent(NumSpaces: 4) << "MTime: " << llvm::itostr(X: StoredTime) << "\n";
834
835 return true;
836 }
837
838 /// Returns true if this \c ASTReaderListener wants to receive the
839 /// imports of the AST file via \c visitImport, false otherwise.
840 bool needsImportVisitation() const override { return true; }
841
842 /// If needsImportVisitation returns \c true, this is called for each
843 /// AST file imported by this AST file.
844 void visitImport(StringRef ModuleName, StringRef Filename) override {
845 Out.indent(NumSpaces: 2) << "Imports module '" << ModuleName
846 << "': " << Filename.str() << "\n";
847 }
848#undef DUMP_BOOLEAN
849 };
850}
851
852bool DumpModuleInfoAction::BeginInvocation(CompilerInstance &CI) {
853 // The Object file reader also supports raw ast files and there is no point in
854 // being strict about the module file format in -module-file-info mode.
855 CI.getHeaderSearchOpts().ModuleFormat = "obj";
856 return true;
857}
858
859static StringRef ModuleKindName(Module::ModuleKind MK) {
860 switch (MK) {
861 case Module::ModuleMapModule:
862 return "Module Map Module";
863 case Module::ModuleInterfaceUnit:
864 return "Interface Unit";
865 case Module::ModuleImplementationUnit:
866 return "Implementation Unit";
867 case Module::ModulePartitionInterface:
868 return "Partition Interface";
869 case Module::ModulePartitionImplementation:
870 return "Partition Implementation";
871 case Module::ModuleHeaderUnit:
872 return "Header Unit";
873 case Module::ExplicitGlobalModuleFragment:
874 return "Global Module Fragment";
875 case Module::ImplicitGlobalModuleFragment:
876 return "Implicit Module Fragment";
877 case Module::PrivateModuleFragment:
878 return "Private Module Fragment";
879 }
880 llvm_unreachable("unknown module kind!");
881}
882
883void DumpModuleInfoAction::ExecuteAction() {
884 CompilerInstance &CI = getCompilerInstance();
885
886 // Don't process files of type other than module to avoid crash
887 if (!isCurrentFileAST()) {
888 CI.getDiagnostics().Report(DiagID: diag::err_file_is_not_module)
889 << getCurrentFile();
890 return;
891 }
892
893 // Set up the output file.
894 StringRef OutputFileName = CI.getFrontendOpts().OutputFile;
895 if (!OutputFileName.empty() && OutputFileName != "-") {
896 std::error_code EC;
897 OutputStream.reset(p: new llvm::raw_fd_ostream(
898 OutputFileName.str(), EC, llvm::sys::fs::OF_TextWithCRLF));
899 }
900 llvm::raw_ostream &Out = OutputStream ? *OutputStream : llvm::outs();
901
902 Out << "Information for module file '" << getCurrentFile() << "':\n";
903 auto &FileMgr = CI.getFileManager();
904 auto Buffer = FileMgr.getBufferForFile(Filename: getCurrentFile());
905 StringRef Magic = (*Buffer)->getMemBufferRef().getBuffer();
906 bool IsRaw = Magic.starts_with(Prefix: "CPCH");
907 Out << " Module format: " << (IsRaw ? "raw" : "obj") << "\n";
908
909 Preprocessor &PP = CI.getPreprocessor();
910 DumpModuleInfoListener Listener(Out, CI.getFileManager());
911 const HeaderSearchOptions &HSOpts =
912 PP.getHeaderSearchInfo().getHeaderSearchOpts();
913
914 // The FrontendAction::BeginSourceFile () method loads the AST so that much
915 // of the information is already available and modules should have been
916 // loaded.
917
918 const LangOptions &LO = getCurrentASTUnit().getLangOpts();
919 if (LO.CPlusPlusModules && !LO.CurrentModule.empty()) {
920 ASTReader *R = getCurrentASTUnit().getASTReader().get();
921 unsigned SubModuleCount = R->getTotalNumSubmodules();
922 serialization::ModuleFile &MF = R->getModuleManager().getPrimaryModule();
923 Out << " ====== C++20 Module structure ======\n";
924
925 if (MF.ModuleName != LO.CurrentModule)
926 Out << " Mismatched module names : " << MF.ModuleName << " and "
927 << LO.CurrentModule << "\n";
928
929 struct SubModInfo {
930 unsigned Idx;
931 Module *Mod;
932 Module::ModuleKind Kind;
933 std::string &Name;
934 bool Seen;
935 };
936 std::map<std::string, SubModInfo> SubModMap;
937 auto PrintSubMapEntry = [&](std::string Name, Module::ModuleKind Kind) {
938 Out << " " << ModuleKindName(MK: Kind) << " '" << Name << "'";
939 auto I = SubModMap.find(x: Name);
940 if (I == SubModMap.end())
941 Out << " was not found in the sub modules!\n";
942 else {
943 I->second.Seen = true;
944 Out << " is at index #" << I->second.Idx << "\n";
945 }
946 };
947 Module *Primary = nullptr;
948 for (unsigned Idx = 0; Idx <= SubModuleCount; ++Idx) {
949 Module *M = R->getModule(ID: Idx);
950 if (!M)
951 continue;
952 if (M->Name == LO.CurrentModule) {
953 Primary = M;
954 Out << " " << ModuleKindName(MK: M->Kind) << " '" << LO.CurrentModule
955 << "' is the Primary Module at index #" << Idx << "\n";
956 SubModMap.insert(x: {M->Name, {.Idx: Idx, .Mod: M, .Kind: M->Kind, .Name: M->Name, .Seen: true}});
957 } else
958 SubModMap.insert(x: {M->Name, {.Idx: Idx, .Mod: M, .Kind: M->Kind, .Name: M->Name, .Seen: false}});
959 }
960 if (Primary) {
961 if (!Primary->submodules().empty())
962 Out << " Sub Modules:\n";
963 for (auto *MI : Primary->submodules()) {
964 PrintSubMapEntry(MI->Name, MI->Kind);
965 }
966 if (!Primary->Imports.empty())
967 Out << " Imports:\n";
968 for (auto *IMP : Primary->Imports) {
969 PrintSubMapEntry(IMP->Name, IMP->Kind);
970 }
971 if (!Primary->Exports.empty())
972 Out << " Exports:\n";
973 for (unsigned MN = 0, N = Primary->Exports.size(); MN != N; ++MN) {
974 if (Module *M = Primary->Exports[MN].getPointer()) {
975 PrintSubMapEntry(M->Name, M->Kind);
976 }
977 }
978 }
979
980 // Emit the macro definitions in the module file so that we can know how
981 // much definitions in the module file quickly.
982 // TODO: Emit the macro definition bodies completely.
983 {
984 std::vector<StringRef> MacroNames;
985 for (const auto &M : R->getPreprocessor().macros()) {
986 if (M.first->isFromAST())
987 MacroNames.push_back(x: M.first->getName());
988 }
989 llvm::sort(C&: MacroNames);
990 if (!MacroNames.empty())
991 Out << " Macro Definitions:\n";
992 for (StringRef Name : MacroNames)
993 Out << " " << Name << "\n";
994 }
995
996 // Now let's print out any modules we did not see as part of the Primary.
997 for (const auto &SM : SubModMap) {
998 if (!SM.second.Seen && SM.second.Mod) {
999 Out << " " << ModuleKindName(MK: SM.second.Kind) << " '" << SM.first
1000 << "' at index #" << SM.second.Idx
1001 << " has no direct reference in the Primary\n";
1002 }
1003 }
1004 Out << " ====== ======\n";
1005 }
1006
1007 // The reminder of the output is produced from the listener as the AST
1008 // FileCcontrolBlock is (re-)parsed.
1009 ASTReader::readASTFileControlBlock(
1010 Filename: getCurrentFile(), FileMgr, ModCache: CI.getModuleCache(),
1011 PCHContainerRdr: CI.getPCHContainerReader(),
1012 /*FindModuleFileExtensions=*/true, Listener,
1013 ValidateDiagnosticOptions: HSOpts.ModulesValidateDiagnosticOptions);
1014}
1015
1016//===----------------------------------------------------------------------===//
1017// Preprocessor Actions
1018//===----------------------------------------------------------------------===//
1019
1020void DumpRawTokensAction::ExecuteAction() {
1021 Preprocessor &PP = getCompilerInstance().getPreprocessor();
1022 SourceManager &SM = PP.getSourceManager();
1023
1024 // Start lexing the specified input file.
1025 llvm::MemoryBufferRef FromFile = SM.getBufferOrFake(FID: SM.getMainFileID());
1026 Lexer RawLex(SM.getMainFileID(), FromFile, SM, PP.getLangOpts());
1027 RawLex.SetKeepWhitespaceMode(true);
1028
1029 Token RawTok;
1030 RawLex.LexFromRawLexer(Result&: RawTok);
1031 while (RawTok.isNot(K: tok::eof)) {
1032 PP.DumpToken(Tok: RawTok, DumpFlags: true);
1033 llvm::errs() << "\n";
1034 RawLex.LexFromRawLexer(Result&: RawTok);
1035 }
1036}
1037
1038void DumpTokensAction::ExecuteAction() {
1039 Preprocessor &PP = getCompilerInstance().getPreprocessor();
1040 // Start preprocessing the specified input file.
1041 Token Tok;
1042 PP.EnterMainSourceFile();
1043 do {
1044 PP.Lex(Result&: Tok);
1045 PP.DumpToken(Tok, DumpFlags: true);
1046 llvm::errs() << "\n";
1047 } while (Tok.isNot(K: tok::eof));
1048}
1049
1050void PreprocessOnlyAction::ExecuteAction() {
1051 Preprocessor &PP = getCompilerInstance().getPreprocessor();
1052
1053 // Ignore unknown pragmas.
1054 PP.IgnorePragmas();
1055
1056 Token Tok;
1057 // Start parsing the specified input file.
1058 PP.EnterMainSourceFile();
1059 do {
1060 PP.Lex(Result&: Tok);
1061 } while (Tok.isNot(K: tok::eof));
1062}
1063
1064void PrintPreprocessedAction::ExecuteAction() {
1065 CompilerInstance &CI = getCompilerInstance();
1066 // Output file may need to be set to 'Binary', to avoid converting Unix style
1067 // line feeds (<LF>) to Microsoft style line feeds (<CR><LF>) on Windows.
1068 //
1069 // Look to see what type of line endings the file uses. If there's a
1070 // CRLF, then we won't open the file up in binary mode. If there is
1071 // just an LF or CR, then we will open the file up in binary mode.
1072 // In this fashion, the output format should match the input format, unless
1073 // the input format has inconsistent line endings.
1074 //
1075 // This should be a relatively fast operation since most files won't have
1076 // all of their source code on a single line. However, that is still a
1077 // concern, so if we scan for too long, we'll just assume the file should
1078 // be opened in binary mode.
1079
1080 bool BinaryMode = false;
1081 if (llvm::Triple(LLVM_HOST_TRIPLE).isOSWindows()) {
1082 BinaryMode = true;
1083 const SourceManager &SM = CI.getSourceManager();
1084 if (std::optional<llvm::MemoryBufferRef> Buffer =
1085 SM.getBufferOrNone(FID: SM.getMainFileID())) {
1086 const char *cur = Buffer->getBufferStart();
1087 const char *end = Buffer->getBufferEnd();
1088 const char *next = (cur != end) ? cur + 1 : end;
1089
1090 // Limit ourselves to only scanning 256 characters into the source
1091 // file. This is mostly a check in case the file has no
1092 // newlines whatsoever.
1093 if (end - cur > 256)
1094 end = cur + 256;
1095
1096 while (next < end) {
1097 if (*cur == 0x0D) { // CR
1098 if (*next == 0x0A) // CRLF
1099 BinaryMode = false;
1100
1101 break;
1102 } else if (*cur == 0x0A) // LF
1103 break;
1104
1105 ++cur;
1106 ++next;
1107 }
1108 }
1109 }
1110
1111 std::unique_ptr<raw_ostream> OS =
1112 CI.createDefaultOutputFile(Binary: BinaryMode, BaseInput: getCurrentFileOrBufferName());
1113 if (!OS) return;
1114
1115 // If we're preprocessing a module map, start by dumping the contents of the
1116 // module itself before switching to the input buffer.
1117 auto &Input = getCurrentInput();
1118 if (Input.getKind().getFormat() == InputKind::ModuleMap) {
1119 if (Input.isFile()) {
1120 (*OS) << "# 1 \"";
1121 OS->write_escaped(Str: Input.getFile());
1122 (*OS) << "\"\n";
1123 }
1124 getCurrentModule()->print(OS&: *OS);
1125 (*OS) << "#pragma clang module contents\n";
1126 }
1127
1128 DoPrintPreprocessedInput(PP&: CI.getPreprocessor(), OS: OS.get(),
1129 Opts: CI.getPreprocessorOutputOpts());
1130}
1131
1132void PrintPreambleAction::ExecuteAction() {
1133 switch (getCurrentFileKind().getLanguage()) {
1134 case Language::C:
1135 case Language::CXX:
1136 case Language::ObjC:
1137 case Language::ObjCXX:
1138 case Language::OpenCL:
1139 case Language::OpenCLCXX:
1140 case Language::CUDA:
1141 case Language::HIP:
1142 case Language::HLSL:
1143 case Language::CIR:
1144 break;
1145
1146 case Language::Unknown:
1147 case Language::Asm:
1148 case Language::LLVM_IR:
1149 // We can't do anything with these.
1150 return;
1151 }
1152
1153 // We don't expect to find any #include directives in a preprocessed input.
1154 if (getCurrentFileKind().isPreprocessed())
1155 return;
1156
1157 CompilerInstance &CI = getCompilerInstance();
1158 auto Buffer = CI.getFileManager().getBufferForFile(Filename: getCurrentFile());
1159 if (Buffer) {
1160 unsigned Preamble =
1161 Lexer::ComputePreamble(Buffer: (*Buffer)->getBuffer(), LangOpts: CI.getLangOpts()).Size;
1162 llvm::outs().write(Ptr: (*Buffer)->getBufferStart(), Size: Preamble);
1163 }
1164}
1165
1166void DumpCompilerOptionsAction::ExecuteAction() {
1167 CompilerInstance &CI = getCompilerInstance();
1168 std::unique_ptr<raw_ostream> OSP =
1169 CI.createDefaultOutputFile(Binary: false, BaseInput: getCurrentFile());
1170 if (!OSP)
1171 return;
1172
1173 raw_ostream &OS = *OSP;
1174 const Preprocessor &PP = CI.getPreprocessor();
1175 const LangOptions &LangOpts = PP.getLangOpts();
1176
1177 // FIXME: Rather than manually format the JSON (which is awkward due to
1178 // needing to remove trailing commas), this should make use of a JSON library.
1179 // FIXME: Instead of printing enums as an integral value and specifying the
1180 // type as a separate field, use introspection to print the enumerator.
1181
1182 OS << "{\n";
1183 OS << "\n\"features\" : [\n";
1184 {
1185 llvm::SmallString<128> Str;
1186#define FEATURE(Name, Predicate) \
1187 ("\t{\"" #Name "\" : " + llvm::Twine(Predicate ? "true" : "false") + "},\n") \
1188 .toVector(Str);
1189#include "clang/Basic/Features.def"
1190#undef FEATURE
1191 // Remove the newline and comma from the last entry to ensure this remains
1192 // valid JSON.
1193 OS << Str.substr(Start: 0, N: Str.size() - 2);
1194 }
1195 OS << "\n],\n";
1196
1197 OS << "\n\"extensions\" : [\n";
1198 {
1199 llvm::SmallString<128> Str;
1200#define EXTENSION(Name, Predicate) \
1201 ("\t{\"" #Name "\" : " + llvm::Twine(Predicate ? "true" : "false") + "},\n") \
1202 .toVector(Str);
1203#include "clang/Basic/Features.def"
1204#undef EXTENSION
1205 // Remove the newline and comma from the last entry to ensure this remains
1206 // valid JSON.
1207 OS << Str.substr(Start: 0, N: Str.size() - 2);
1208 }
1209 OS << "\n]\n";
1210
1211 OS << "}";
1212}
1213
1214void PrintDependencyDirectivesSourceMinimizerAction::ExecuteAction() {
1215 CompilerInstance &CI = getCompilerInstance();
1216 SourceManager &SM = CI.getPreprocessor().getSourceManager();
1217 llvm::MemoryBufferRef FromFile = SM.getBufferOrFake(FID: SM.getMainFileID());
1218
1219 llvm::SmallVector<dependency_directives_scan::Token, 16> Tokens;
1220 llvm::SmallVector<dependency_directives_scan::Directive, 32> Directives;
1221 if (scanSourceForDependencyDirectives(
1222 Input: FromFile.getBuffer(), Tokens, Directives, Diags: &CI.getDiagnostics(),
1223 InputSourceLoc: SM.getLocForStartOfFile(FID: SM.getMainFileID()))) {
1224 assert(CI.getDiagnostics().hasErrorOccurred() &&
1225 "no errors reported for failure");
1226
1227 // Preprocess the source when verifying the diagnostics to capture the
1228 // 'expected' comments.
1229 if (CI.getDiagnosticOpts().VerifyDiagnostics) {
1230 // Make sure we don't emit new diagnostics!
1231 CI.getDiagnostics().setSuppressAllDiagnostics(true);
1232 Preprocessor &PP = getCompilerInstance().getPreprocessor();
1233 PP.EnterMainSourceFile();
1234 Token Tok;
1235 do {
1236 PP.Lex(Result&: Tok);
1237 } while (Tok.isNot(K: tok::eof));
1238 }
1239 return;
1240 }
1241 printDependencyDirectivesAsSource(Source: FromFile.getBuffer(), Directives,
1242 OS&: llvm::outs());
1243}
1244
1245//===----------------------------------------------------------------------===//
1246// HLSL Specific Actions
1247//===----------------------------------------------------------------------===//
1248
1249class InjectRootSignatureCallback : public PPCallbacks {
1250private:
1251 Sema &Actions;
1252 StringRef RootSigName;
1253 llvm::dxbc::RootSignatureVersion Version;
1254
1255 std::optional<StringLiteral *> processStringLiteral(ArrayRef<Token> Tokens) {
1256 for (Token Tok : Tokens)
1257 if (!tok::isStringLiteral(K: Tok.getKind()))
1258 return std::nullopt;
1259
1260 ExprResult StringResult = Actions.ActOnUnevaluatedStringLiteral(StringToks: Tokens);
1261 if (StringResult.isInvalid())
1262 return std::nullopt;
1263
1264 if (auto Signature = dyn_cast<StringLiteral>(Val: StringResult.get()))
1265 return Signature;
1266
1267 return std::nullopt;
1268 }
1269
1270public:
1271 void MacroDefined(const Token &MacroNameTok,
1272 const MacroDirective *MD) override {
1273 if (RootSigName != MacroNameTok.getIdentifierInfo()->getName())
1274 return;
1275
1276 const MacroInfo *MI = MD->getMacroInfo();
1277 auto Signature = processStringLiteral(Tokens: MI->tokens());
1278 if (!Signature.has_value()) {
1279 Actions.getDiagnostics().Report(Loc: MI->getDefinitionLoc(),
1280 DiagID: diag::err_expected_string_literal)
1281 << /*in attributes...*/ 4 << "RootSignature";
1282 return;
1283 }
1284
1285 IdentifierInfo *DeclIdent =
1286 hlsl::ParseHLSLRootSignature(Actions, Version, Signature: *Signature);
1287 Actions.HLSL().SetRootSignatureOverride(DeclIdent);
1288 }
1289
1290 InjectRootSignatureCallback(Sema &Actions, StringRef RootSigName,
1291 llvm::dxbc::RootSignatureVersion Version)
1292 : PPCallbacks(), Actions(Actions), RootSigName(RootSigName),
1293 Version(Version) {}
1294};
1295
1296void HLSLFrontendAction::ExecuteAction() {
1297 // Pre-requisites to invoke
1298 CompilerInstance &CI = getCompilerInstance();
1299 if (!CI.hasASTContext() || !CI.hasPreprocessor())
1300 return WrapperFrontendAction::ExecuteAction();
1301
1302 // InjectRootSignatureCallback requires access to invoke Sema to lookup/
1303 // register a root signature declaration. The wrapped action is required to
1304 // account for this by only creating a Sema if one doesn't already exist
1305 // (like we have done, and, ASTFrontendAction::ExecuteAction)
1306 if (!CI.hasSema())
1307 CI.createSema(TUKind: getTranslationUnitKind(),
1308 /*CodeCompleteConsumer=*/CompletionConsumer: nullptr);
1309 Sema &S = CI.getSema();
1310
1311 auto &TargetInfo = CI.getASTContext().getTargetInfo();
1312 bool IsRootSignatureTarget =
1313 TargetInfo.getTriple().getEnvironment() == llvm::Triple::RootSignature;
1314 StringRef HLSLEntry = TargetInfo.getTargetOpts().HLSLEntry;
1315
1316 // Register HLSL specific callbacks
1317 auto LangOpts = CI.getLangOpts();
1318 StringRef RootSigName =
1319 IsRootSignatureTarget ? HLSLEntry : LangOpts.HLSLRootSigOverride;
1320
1321 auto MacroCallback = std::make_unique<InjectRootSignatureCallback>(
1322 args&: S, args&: RootSigName, args&: LangOpts.HLSLRootSigVer);
1323
1324 Preprocessor &PP = CI.getPreprocessor();
1325 PP.addPPCallbacks(C: std::move(MacroCallback));
1326
1327 // If we are targeting a root signature, invoke custom handling
1328 if (IsRootSignatureTarget)
1329 return hlsl::HandleRootSignatureTarget(S, EntryRootSig: HLSLEntry);
1330 else // otherwise, invoke as normal
1331 return WrapperFrontendAction::ExecuteAction();
1332}
1333
1334HLSLFrontendAction::HLSLFrontendAction(
1335 std::unique_ptr<FrontendAction> WrappedAction)
1336 : WrapperFrontendAction(std::move(WrappedAction)) {}
1337