clang 21.0.0git
FrontendOptions.h
Go to the documentation of this file.
1//===- FrontendOptions.h ----------------------------------------*- C++ -*-===//
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#ifndef LLVM_CLANG_FRONTEND_FRONTENDOPTIONS_H
10#define LLVM_CLANG_FRONTEND_FRONTENDOPTIONS_H
11
17#include "llvm/ADT/StringRef.h"
18#include "llvm/Support/Compiler.h"
19#include "llvm/Support/MemoryBuffer.h"
20#include <cassert>
21#include <map>
22#include <memory>
23#include <optional>
24#include <string>
25#include <vector>
26
27namespace llvm {
28
29class MemoryBuffer;
30
31} // namespace llvm
32
33namespace clang {
34
35namespace frontend {
36
38 /// Parse ASTs and list Decl nodes.
40
41 /// Parse ASTs and dump them.
43
44 /// Parse ASTs and print them.
46
47 /// Parse ASTs and view them in Graphviz.
49
50 /// Dump the compiler configuration.
52
53 /// Dump out raw tokens.
55
56 /// Dump out preprocessed tokens.
58
59 /// Emit a .s file.
61
62 /// Emit a .bc file.
64
65 /// Translate input source into HTML.
67
68 /// Emit a .cir file
70
71 /// Emit a .ll file.
73
74 /// Generate LLVM IR, but do not emit anything.
76
77 /// Generate machine code, but don't emit anything.
79
80 /// Emit a .o file.
82
83 // Extract API information
85
86 /// Parse and apply any fixits to the source.
88
89 /// Generate pre-compiled module from a module map.
91
92 /// Generate pre-compiled module from a standard C++ module interface unit.
94
95 /// Generate reduced module interface for a standard C++ module interface
96 /// unit.
98
99 /// Generate a C++20 header unit module from a header file.
101
102 /// Generate pre-compiled header.
104
105 /// Generate Interface Stub Files.
107
108 /// Only execute frontend initialization.
110
111 /// Dump information about a module file.
113
114 /// Load and verify that a PCH file is usable.
116
117 /// Parse and perform semantic analysis.
119
120 /// Run a plugin action, \see ActionName.
122
123 /// Print the "preamble" of the input file
125
126 /// -E mode.
128
129 /// Expand macros but not \#includes.
131
132 /// ObjC->C Rewriter.
134
135 /// Rewriter playground
137
138 /// Run one or more source code analyses.
140
141 /// Dump template instantiations
143
144 /// Just lex, no output.
146
147 /// Print the output of the dependency directives source minimizer.
150
151} // namespace frontend
152
153/// The kind of a file that we've been handed as an input.
155public:
156 /// The input file format.
157 enum Format {
161 };
162
163 // If we are building a header unit, what kind it is; this affects whether
164 // we look for the file in the user or system include search paths before
165 // flagging a missing input.
171 };
172
173private:
174 Language Lang;
175 LLVM_PREFERRED_TYPE(Format)
176 unsigned Fmt : 3;
177 LLVM_PREFERRED_TYPE(bool)
178 unsigned Preprocessed : 1;
179 LLVM_PREFERRED_TYPE(HeaderUnitKind)
180 unsigned HeaderUnit : 3;
181 LLVM_PREFERRED_TYPE(bool)
182 unsigned IsHeader : 1;
183
184public:
186 bool PP = false, HeaderUnitKind HU = HeaderUnit_None,
187 bool HD = false)
188 : Lang(L), Fmt(F), Preprocessed(PP), HeaderUnit(HU), IsHeader(HD) {}
189
190 Language getLanguage() const { return static_cast<Language>(Lang); }
191 Format getFormat() const { return static_cast<Format>(Fmt); }
193 return static_cast<HeaderUnitKind>(HeaderUnit);
194 }
195 bool isPreprocessed() const { return Preprocessed; }
196 bool isHeader() const { return IsHeader; }
197 bool isHeaderUnit() const { return HeaderUnit != HeaderUnit_None; }
198
199 /// Is the input kind fully-unknown?
200 bool isUnknown() const { return Lang == Language::Unknown && Fmt == Source; }
201
202 /// Is the language of the input some dialect of Objective-C?
203 bool isObjectiveC() const {
204 return Lang == Language::ObjC || Lang == Language::ObjCXX;
205 }
206
209 isHeader());
210 }
211
214 getHeaderUnitKind(), true);
215 }
216
219 isHeader());
220 }
221
224 isHeader());
225 }
226};
227
228/// An input file for the front end.
230 /// The file name, or "-" to read from standard input.
231 std::string File;
232
233 /// The input, if it comes from a buffer rather than a file. This object
234 /// does not own the buffer, and the caller is responsible for ensuring
235 /// that it outlives any users.
236 std::optional<llvm::MemoryBufferRef> Buffer;
237
238 /// The kind of input, e.g., C source, AST file, LLVM IR.
239 InputKind Kind;
240
241 /// Whether we're dealing with a 'system' input (vs. a 'user' input).
242 bool IsSystem = false;
243
244public:
245 FrontendInputFile() = default;
246 FrontendInputFile(StringRef File, InputKind Kind, bool IsSystem = false)
247 : File(File.str()), Kind(Kind), IsSystem(IsSystem) {}
248 FrontendInputFile(llvm::MemoryBufferRef Buffer, InputKind Kind,
249 bool IsSystem = false)
250 : Buffer(Buffer), Kind(Kind), IsSystem(IsSystem) {}
251
252 InputKind getKind() const { return Kind; }
253 bool isSystem() const { return IsSystem; }
254
255 bool isEmpty() const { return File.empty() && Buffer == std::nullopt; }
256 bool isFile() const { return !isBuffer(); }
257 bool isBuffer() const { return Buffer != std::nullopt; }
258 bool isPreprocessed() const { return Kind.isPreprocessed(); }
259 bool isHeader() const { return Kind.isHeader(); }
261 return Kind.getHeaderUnitKind();
262 }
263
264 StringRef getFile() const {
265 assert(isFile());
266 return File;
267 }
268
269 llvm::MemoryBufferRef getBuffer() const {
270 assert(isBuffer());
271 return *Buffer;
272 }
273};
274
275/// FrontendOptions - Options for controlling the behavior of the frontend.
277public:
278 /// Disable memory freeing on exit.
279 LLVM_PREFERRED_TYPE(bool)
281
282 /// When generating PCH files, instruct the AST writer to create relocatable
283 /// PCH files.
284 LLVM_PREFERRED_TYPE(bool)
285 unsigned RelocatablePCH : 1;
286
287 /// Show the -help text.
288 LLVM_PREFERRED_TYPE(bool)
289 unsigned ShowHelp : 1;
290
291 /// Show frontend performance metrics and statistics.
292 LLVM_PREFERRED_TYPE(bool)
293 unsigned ShowStats : 1;
294
295 LLVM_PREFERRED_TYPE(bool)
296 unsigned AppendStats : 1;
297
298 /// print the supported cpus for the current target
299 LLVM_PREFERRED_TYPE(bool)
300 unsigned PrintSupportedCPUs : 1;
301
302 /// Print the supported extensions for the current target.
303 LLVM_PREFERRED_TYPE(bool)
305
306 /// Print the extensions enabled for the current target.
307 LLVM_PREFERRED_TYPE(bool)
309
310 /// Show the -version text.
311 LLVM_PREFERRED_TYPE(bool)
312 unsigned ShowVersion : 1;
313
314 /// Apply fixes even if there are unfixable errors.
315 LLVM_PREFERRED_TYPE(bool)
316 unsigned FixWhatYouCan : 1;
317
318 /// Apply fixes only for warnings.
319 LLVM_PREFERRED_TYPE(bool)
320 unsigned FixOnlyWarnings : 1;
321
322 /// Apply fixes and recompile.
323 LLVM_PREFERRED_TYPE(bool)
324 unsigned FixAndRecompile : 1;
325
326 /// Apply fixes to temporary files.
327 LLVM_PREFERRED_TYPE(bool)
328 unsigned FixToTemporaries : 1;
329
330 /// Skip over function bodies to speed up parsing in cases you do not need
331 /// them (e.g. with code completion).
332 LLVM_PREFERRED_TYPE(bool)
333 unsigned SkipFunctionBodies : 1;
334
335 /// Whether we can use the global module index if available.
336 LLVM_PREFERRED_TYPE(bool)
338
339 /// Whether we can generate the global module index if needed.
340 LLVM_PREFERRED_TYPE(bool)
342
343 /// Whether we include declaration dumps in AST dumps.
344 LLVM_PREFERRED_TYPE(bool)
345 unsigned ASTDumpDecls : 1;
346
347 /// Whether we deserialize all decls when forming AST dumps.
348 LLVM_PREFERRED_TYPE(bool)
349 unsigned ASTDumpAll : 1;
350
351 /// Whether we include lookup table dumps in AST dumps.
352 LLVM_PREFERRED_TYPE(bool)
353 unsigned ASTDumpLookups : 1;
354
355 /// Whether we include declaration type dumps in AST dumps.
356 LLVM_PREFERRED_TYPE(bool)
357 unsigned ASTDumpDeclTypes : 1;
358
359 /// Whether we are performing an implicit module build.
360 LLVM_PREFERRED_TYPE(bool)
362
363 /// Whether to use a filesystem lock when building implicit modules.
364 LLVM_PREFERRED_TYPE(bool)
366
367 /// Whether we should embed all used files into the PCM file.
368 LLVM_PREFERRED_TYPE(bool)
370
371 /// Whether timestamps should be written to the produced PCH file.
372 LLVM_PREFERRED_TYPE(bool)
373 unsigned IncludeTimestamps : 1;
374
375 /// Should a temporary file be used during compilation.
376 LLVM_PREFERRED_TYPE(bool)
377 unsigned UseTemporary : 1;
378
379 /// When using -emit-module, treat the modulemap as a system module.
380 LLVM_PREFERRED_TYPE(bool)
381 unsigned IsSystemModule : 1;
382
383 /// Output (and read) PCM files regardless of compiler errors.
384 LLVM_PREFERRED_TYPE(bool)
386
387 /// Whether to share the FileManager when building modules.
388 LLVM_PREFERRED_TYPE(bool)
390
391 /// Whether to emit symbol graph files as a side effect of compilation.
392 LLVM_PREFERRED_TYPE(bool)
393 unsigned EmitSymbolGraph : 1;
394
395 /// Whether to emit additional symbol graphs for extended modules.
396 LLVM_PREFERRED_TYPE(bool)
398
399 /// Whether to emit symbol labels for testing in generated symbol graphs
400 LLVM_PREFERRED_TYPE(bool)
402
403 /// Whether to emit symbol labels for testing in generated symbol graphs
404 LLVM_PREFERRED_TYPE(bool)
406
407 /// Whether to generate reduced BMI for C++20 named modules.
408 LLVM_PREFERRED_TYPE(bool)
409 unsigned GenReducedBMI : 1;
410
411 /// Use Clang IR pipeline to emit code
412 LLVM_PREFERRED_TYPE(bool)
413 unsigned UseClangIRPipeline : 1;
414
416
417 /// Specifies the output format of the AST.
419
420 /// The input kind, either specified via -x argument or deduced from the input
421 /// file name.
423
424 /// The input files and their types.
426
427 /// When the input is a module map, the original module map file from which
428 /// that map was inferred, if any (for umbrella modules).
430
431 /// The output file, if any.
433
434 /// If given, the new suffix for fix-it rewritten files.
436
437 /// If given, filter dumped AST Decl nodes by this substring.
439
440 /// If given, enable code completion at the provided location.
442
443 /// The frontend action to perform.
444 frontend::ActionKind ProgramAction = frontend::ParseSyntaxOnly;
445
446 /// The name of the action to run when using a plugin action.
448
449 // Currently this is only used as part of the `-extract-api` action.
450 /// The name of the product the input files belong too.
452
453 // Currently this is only used as part of the `-extract-api` action.
454 // A comma separated list of files providing a list of APIs to
455 // ignore when extracting documentation.
457
458 // Location of output directory where symbol graph information would
459 // be dumped. This overrides regular -o output file specification
461
462 /// Args to pass to the plugins
463 std::map<std::string, std::vector<std::string>> PluginArgs;
464
465 /// The list of plugin actions to run in addition to the normal action.
466 std::vector<std::string> AddPluginActions;
467
468 /// The list of plugins to load.
469 std::vector<std::string> Plugins;
470
471 /// The list of module file extensions.
473
474 /// The list of module map files to load before processing the input.
475 std::vector<std::string> ModuleMapFiles;
476
477 /// The list of additional prebuilt module files to load before
478 /// processing the input.
479 std::vector<std::string> ModuleFiles;
480
481 /// The list of files to embed into the compiled module file.
482 std::vector<std::string> ModulesEmbedFiles;
483
484 /// The list of AST files to merge.
485 std::vector<std::string> ASTMergeFiles;
486
487 /// A list of arguments to forward to LLVM's option processing; this
488 /// should only be used for debugging and experimental features.
489 std::vector<std::string> LLVMArgs;
490
491 /// File name of the file that will provide record layouts
492 /// (in the format produced by -fdump-record-layouts).
494
495 /// Auxiliary triple for CUDA/HIP compilation.
496 std::string AuxTriple;
497
498 /// Auxiliary target CPU for CUDA/HIP compilation.
499 std::optional<std::string> AuxTargetCPU;
500
501 /// Auxiliary target features for CUDA/HIP compilation.
502 std::optional<std::vector<std::string>> AuxTargetFeatures;
503
504 /// Filename to write statistics to.
505 std::string StatsFile;
506
507 /// Minimum time granularity (in microseconds) traced by time profiler.
509
510 /// Make time trace capture verbose event details (e.g. source filenames).
511 /// This can increase the size of the output by 2-3 times.
512 LLVM_PREFERRED_TYPE(bool)
513 unsigned TimeTraceVerbose : 1;
514
515 /// Path which stores the output files for -ftime-trace
517
518 /// Output Path for module output file.
520
521public:
538
539 /// getInputKindForExtension - Return the appropriate input kind for a file
540 /// extension. For example, "c" would return Language::C.
541 ///
542 /// \return The input kind for the extension, or Language::Unknown if the
543 /// extension is not recognized.
544 static InputKind getInputKindForExtension(StringRef Extension);
545};
546
547} // namespace clang
548
549#endif // LLVM_CLANG_FRONTEND_FRONTENDOPTIONS_H
Options controlling the behavior of code completion.
An input file for the front end.
llvm::MemoryBufferRef getBuffer() const
FrontendInputFile(llvm::MemoryBufferRef Buffer, InputKind Kind, bool IsSystem=false)
InputKind getKind() const
StringRef getFile() const
InputKind::HeaderUnitKind getHeaderUnitKind() const
FrontendInputFile(StringRef File, InputKind Kind, bool IsSystem=false)
FrontendOptions - Options for controlling the behavior of the frontend.
InputKind DashX
The input kind, either specified via -x argument or deduced from the input file name.
unsigned BuildingImplicitModule
Whether we are performing an implicit module build.
unsigned TimeTraceGranularity
Minimum time granularity (in microseconds) traced by time profiler.
std::vector< std::string > ModuleFiles
The list of additional prebuilt module files to load before processing the input.
unsigned AllowPCMWithCompilerErrors
Output (and read) PCM files regardless of compiler errors.
unsigned SkipFunctionBodies
Skip over function bodies to speed up parsing in cases you do not need them (e.g.
unsigned IncludeTimestamps
Whether timestamps should be written to the produced PCH file.
unsigned EmitSymbolGraphSymbolLabelsForTesting
Whether to emit symbol labels for testing in generated symbol graphs.
unsigned EmitSymbolGraph
Whether to emit symbol graph files as a side effect of compilation.
std::map< std::string, std::vector< std::string > > PluginArgs
Args to pass to the plugins.
unsigned BuildingImplicitModuleUsesLock
Whether to use a filesystem lock when building implicit modules.
unsigned ModulesShareFileManager
Whether to share the FileManager when building modules.
std::string ASTDumpFilter
If given, filter dumped AST Decl nodes by this substring.
unsigned ASTDumpLookups
Whether we include lookup table dumps in AST dumps.
unsigned UseTemporary
Should a temporary file be used during compilation.
CodeCompleteOptions CodeCompleteOpts
unsigned IsSystemModule
When using -emit-module, treat the modulemap as a system module.
unsigned PrintSupportedCPUs
print the supported cpus for the current target
unsigned FixToTemporaries
Apply fixes to temporary files.
unsigned PrintSupportedExtensions
Print the supported extensions for the current target.
unsigned PrintEnabledExtensions
Print the extensions enabled for the current target.
std::vector< std::string > LLVMArgs
A list of arguments to forward to LLVM's option processing; this should only be used for debugging an...
unsigned ShowHelp
Show the -help text.
std::string TimeTracePath
Path which stores the output files for -ftime-trace.
unsigned FixAndRecompile
Apply fixes and recompile.
unsigned UseClangIRPipeline
Use Clang IR pipeline to emit code.
unsigned FixOnlyWarnings
Apply fixes only for warnings.
ASTDumpOutputFormat ASTDumpFormat
Specifies the output format of the AST.
std::optional< std::string > AuxTargetCPU
Auxiliary target CPU for CUDA/HIP compilation.
std::string StatsFile
Filename to write statistics to.
std::string OutputFile
The output file, if any.
unsigned ShowStats
Show frontend performance metrics and statistics.
unsigned GenReducedBMI
Whether to generate reduced BMI for C++20 named modules.
std::string ActionName
The name of the action to run when using a plugin action.
std::vector< std::shared_ptr< ModuleFileExtension > > ModuleFileExtensions
The list of module file extensions.
ParsedSourceLocation CodeCompletionAt
If given, enable code completion at the provided location.
std::string FixItSuffix
If given, the new suffix for fix-it rewritten files.
std::string OriginalModuleMap
When the input is a module map, the original module map file from which that map was inferred,...
std::vector< std::string > ModulesEmbedFiles
The list of files to embed into the compiled module file.
unsigned ShowVersion
Show the -version text.
std::string ProductName
The name of the product the input files belong too.
unsigned ModulesEmbedAllFiles
Whether we should embed all used files into the PCM file.
std::string ModuleOutputPath
Output Path for module output file.
std::vector< std::string > AddPluginActions
The list of plugin actions to run in addition to the normal action.
unsigned ASTDumpDeclTypes
Whether we include declaration type dumps in AST dumps.
unsigned FixWhatYouCan
Apply fixes even if there are unfixable errors.
static InputKind getInputKindForExtension(StringRef Extension)
getInputKindForExtension - Return the appropriate input kind for a file extension.
std::string SymbolGraphOutputDir
std::vector< std::string > ASTMergeFiles
The list of AST files to merge.
std::vector< std::string > Plugins
The list of plugins to load.
unsigned ASTDumpAll
Whether we deserialize all decls when forming AST dumps.
unsigned GenerateGlobalModuleIndex
Whether we can generate the global module index if needed.
unsigned TimeTraceVerbose
Make time trace capture verbose event details (e.g.
unsigned RelocatablePCH
When generating PCH files, instruct the AST writer to create relocatable PCH files.
unsigned EmitExtensionSymbolGraphs
Whether to emit additional symbol graphs for extended modules.
unsigned DisableFree
Disable memory freeing on exit.
SmallVector< FrontendInputFile, 0 > Inputs
The input files and their types.
frontend::ActionKind ProgramAction
The frontend action to perform.
std::optional< std::vector< std::string > > AuxTargetFeatures
Auxiliary target features for CUDA/HIP compilation.
unsigned EmitPrettySymbolGraphs
Whether to emit symbol labels for testing in generated symbol graphs.
std::string OverrideRecordLayoutsFile
File name of the file that will provide record layouts (in the format produced by -fdump-record-layou...
std::vector< std::string > ExtractAPIIgnoresFileList
std::string AuxTriple
Auxiliary triple for CUDA/HIP compilation.
unsigned UseGlobalModuleIndex
Whether we can use the global module index if available.
std::vector< std::string > ModuleMapFiles
The list of module map files to load before processing the input.
unsigned ASTDumpDecls
Whether we include declaration dumps in AST dumps.
The kind of a file that we've been handed as an input.
bool isPreprocessed() const
InputKind withHeaderUnit(HeaderUnitKind HU) const
bool isHeaderUnit() const
bool isUnknown() const
Is the input kind fully-unknown?
bool isObjectiveC() const
Is the language of the input some dialect of Objective-C?
constexpr InputKind(Language L=Language::Unknown, Format F=Source, bool PP=false, HeaderUnitKind HU=HeaderUnit_None, bool HD=false)
Format
The input file format.
InputKind getPreprocessed() const
bool isHeader() const
Format getFormat() const
HeaderUnitKind getHeaderUnitKind() const
InputKind getHeader() const
InputKind withFormat(Format F) const
Language getLanguage() const
An abstract superclass that describes a custom extension to the module/precompiled header file format...
@ GenerateHeaderUnit
Generate a C++20 header unit module from a header file.
@ VerifyPCH
Load and verify that a PCH file is usable.
@ PrintPreprocessedInput
-E mode.
@ RewriteTest
Rewriter playground.
@ ParseSyntaxOnly
Parse and perform semantic analysis.
@ TemplightDump
Dump template instantiations.
@ EmitBC
Emit a .bc file.
@ GenerateModuleInterface
Generate pre-compiled module from a standard C++ module interface unit.
@ EmitLLVM
Emit a .ll file.
@ PrintPreamble
Print the "preamble" of the input file.
@ InitOnly
Only execute frontend initialization.
@ ASTView
Parse ASTs and view them in Graphviz.
@ PluginAction
Run a plugin action,.
@ EmitObj
Emit a .o file.
@ DumpRawTokens
Dump out raw tokens.
@ PrintDependencyDirectivesSourceMinimizerOutput
Print the output of the dependency directives source minimizer.
@ RewriteObjC
ObjC->C Rewriter.
@ RunPreprocessorOnly
Just lex, no output.
@ ModuleFileInfo
Dump information about a module file.
@ EmitCIR
Emit a .cir file.
@ DumpCompilerOptions
Dump the compiler configuration.
@ RunAnalysis
Run one or more source code analyses.
@ ASTPrint
Parse ASTs and print them.
@ GenerateReducedModuleInterface
Generate reduced module interface for a standard C++ module interface unit.
@ GenerateInterfaceStubs
Generate Interface Stub Files.
@ ASTDump
Parse ASTs and dump them.
@ DumpTokens
Dump out preprocessed tokens.
@ FixIt
Parse and apply any fixits to the source.
@ EmitAssembly
Emit a .s file.
@ EmitCodeGenOnly
Generate machine code, but don't emit anything.
@ RewriteMacros
Expand macros but not #includes.
@ EmitHTML
Translate input source into HTML.
@ GeneratePCH
Generate pre-compiled header.
@ EmitLLVMOnly
Generate LLVM IR, but do not emit anything.
@ GenerateModule
Generate pre-compiled module from a module map.
@ ASTDeclList
Parse ASTs and list Decl nodes.
The JSON file list parser is used to communicate input to InstallAPI.
ASTDumpOutputFormat
Used to specify the format for printing AST dump information.
@ ADOF_Default
Language
The language for the input, used to select and validate the language standard and possible actions.
Definition: LangStandard.h:23
Diagnostic wrappers for TextAPI types for error reporting.
Definition: Dominators.h:30
#define true
Definition: stdbool.h:25
#define false
Definition: stdbool.h:26
A source location that has been parsed on the command line.