clang 19.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 /// Run migrator.
146
147 /// Just lex, no output.
149
150 /// Print the output of the dependency directives source minimizer.
153
154} // namespace frontend
155
156/// The kind of a file that we've been handed as an input.
158public:
159 /// The input file format.
160 enum Format {
164 };
165
166 // If we are building a header unit, what kind it is; this affects whether
167 // we look for the file in the user or system include search paths before
168 // flagging a missing input.
174 };
175
176private:
177 Language Lang;
178 LLVM_PREFERRED_TYPE(Format)
179 unsigned Fmt : 3;
180 LLVM_PREFERRED_TYPE(bool)
181 unsigned Preprocessed : 1;
182 LLVM_PREFERRED_TYPE(HeaderUnitKind)
183 unsigned HeaderUnit : 3;
184 LLVM_PREFERRED_TYPE(bool)
185 unsigned IsHeader : 1;
186
187public:
189 bool PP = false, HeaderUnitKind HU = HeaderUnit_None,
190 bool HD = false)
191 : Lang(L), Fmt(F), Preprocessed(PP), HeaderUnit(HU), IsHeader(HD) {}
192
193 Language getLanguage() const { return static_cast<Language>(Lang); }
194 Format getFormat() const { return static_cast<Format>(Fmt); }
196 return static_cast<HeaderUnitKind>(HeaderUnit);
197 }
198 bool isPreprocessed() const { return Preprocessed; }
199 bool isHeader() const { return IsHeader; }
200 bool isHeaderUnit() const { return HeaderUnit != HeaderUnit_None; }
201
202 /// Is the input kind fully-unknown?
203 bool isUnknown() const { return Lang == Language::Unknown && Fmt == Source; }
204
205 /// Is the language of the input some dialect of Objective-C?
206 bool isObjectiveC() const {
207 return Lang == Language::ObjC || Lang == Language::ObjCXX;
208 }
209
212 isHeader());
213 }
214
217 getHeaderUnitKind(), true);
218 }
219
222 isHeader());
223 }
224
227 isHeader());
228 }
229};
230
231/// An input file for the front end.
233 /// The file name, or "-" to read from standard input.
234 std::string File;
235
236 /// The input, if it comes from a buffer rather than a file. This object
237 /// does not own the buffer, and the caller is responsible for ensuring
238 /// that it outlives any users.
239 std::optional<llvm::MemoryBufferRef> Buffer;
240
241 /// The kind of input, e.g., C source, AST file, LLVM IR.
242 InputKind Kind;
243
244 /// Whether we're dealing with a 'system' input (vs. a 'user' input).
245 bool IsSystem = false;
246
247public:
248 FrontendInputFile() = default;
249 FrontendInputFile(StringRef File, InputKind Kind, bool IsSystem = false)
250 : File(File.str()), Kind(Kind), IsSystem(IsSystem) {}
251 FrontendInputFile(llvm::MemoryBufferRef Buffer, InputKind Kind,
252 bool IsSystem = false)
253 : Buffer(Buffer), Kind(Kind), IsSystem(IsSystem) {}
254
255 InputKind getKind() const { return Kind; }
256 bool isSystem() const { return IsSystem; }
257
258 bool isEmpty() const { return File.empty() && Buffer == std::nullopt; }
259 bool isFile() const { return !isBuffer(); }
260 bool isBuffer() const { return Buffer != std::nullopt; }
261 bool isPreprocessed() const { return Kind.isPreprocessed(); }
262 bool isHeader() const { return Kind.isHeader(); }
264 return Kind.getHeaderUnitKind();
265 }
266
267 StringRef getFile() const {
268 assert(isFile());
269 return File;
270 }
271
272 llvm::MemoryBufferRef getBuffer() const {
273 assert(isBuffer());
274 return *Buffer;
275 }
276};
277
278/// FrontendOptions - Options for controlling the behavior of the frontend.
280public:
281 /// Disable memory freeing on exit.
282 LLVM_PREFERRED_TYPE(bool)
284
285 /// When generating PCH files, instruct the AST writer to create relocatable
286 /// PCH files.
287 LLVM_PREFERRED_TYPE(bool)
288 unsigned RelocatablePCH : 1;
289
290 /// Show the -help text.
291 LLVM_PREFERRED_TYPE(bool)
292 unsigned ShowHelp : 1;
293
294 /// Show frontend performance metrics and statistics.
295 LLVM_PREFERRED_TYPE(bool)
296 unsigned ShowStats : 1;
297
298 LLVM_PREFERRED_TYPE(bool)
299 unsigned AppendStats : 1;
300
301 /// print the supported cpus for the current target
302 LLVM_PREFERRED_TYPE(bool)
303 unsigned PrintSupportedCPUs : 1;
304
305 /// Print the supported extensions for the current target.
306 LLVM_PREFERRED_TYPE(bool)
308
309 /// Show the -version text.
310 LLVM_PREFERRED_TYPE(bool)
311 unsigned ShowVersion : 1;
312
313 /// Apply fixes even if there are unfixable errors.
314 LLVM_PREFERRED_TYPE(bool)
315 unsigned FixWhatYouCan : 1;
316
317 /// Apply fixes only for warnings.
318 LLVM_PREFERRED_TYPE(bool)
319 unsigned FixOnlyWarnings : 1;
320
321 /// Apply fixes and recompile.
322 LLVM_PREFERRED_TYPE(bool)
323 unsigned FixAndRecompile : 1;
324
325 /// Apply fixes to temporary files.
326 LLVM_PREFERRED_TYPE(bool)
327 unsigned FixToTemporaries : 1;
328
329 /// Emit ARC errors even if the migrator can fix them.
330 LLVM_PREFERRED_TYPE(bool)
332
333 /// Skip over function bodies to speed up parsing in cases you do not need
334 /// them (e.g. with code completion).
335 LLVM_PREFERRED_TYPE(bool)
336 unsigned SkipFunctionBodies : 1;
337
338 /// Whether we can use the global module index if available.
339 LLVM_PREFERRED_TYPE(bool)
341
342 /// Whether we can generate the global module index if needed.
343 LLVM_PREFERRED_TYPE(bool)
345
346 /// Whether we include declaration dumps in AST dumps.
347 LLVM_PREFERRED_TYPE(bool)
348 unsigned ASTDumpDecls : 1;
349
350 /// Whether we deserialize all decls when forming AST dumps.
351 LLVM_PREFERRED_TYPE(bool)
352 unsigned ASTDumpAll : 1;
353
354 /// Whether we include lookup table dumps in AST dumps.
355 LLVM_PREFERRED_TYPE(bool)
356 unsigned ASTDumpLookups : 1;
357
358 /// Whether we include declaration type dumps in AST dumps.
359 LLVM_PREFERRED_TYPE(bool)
360 unsigned ASTDumpDeclTypes : 1;
361
362 /// Whether we are performing an implicit module build.
363 LLVM_PREFERRED_TYPE(bool)
365
366 /// Whether to use a filesystem lock when building implicit modules.
367 LLVM_PREFERRED_TYPE(bool)
369
370 /// Whether we should embed all used files into the PCM file.
371 LLVM_PREFERRED_TYPE(bool)
373
374 /// Whether timestamps should be written to the produced PCH file.
375 LLVM_PREFERRED_TYPE(bool)
376 unsigned IncludeTimestamps : 1;
377
378 /// Should a temporary file be used during compilation.
379 LLVM_PREFERRED_TYPE(bool)
380 unsigned UseTemporary : 1;
381
382 /// When using -emit-module, treat the modulemap as a system module.
383 LLVM_PREFERRED_TYPE(bool)
384 unsigned IsSystemModule : 1;
385
386 /// Output (and read) PCM files regardless of compiler errors.
387 LLVM_PREFERRED_TYPE(bool)
389
390 /// Whether to share the FileManager when building modules.
391 LLVM_PREFERRED_TYPE(bool)
393
394 /// Whether to emit symbol graph files as a side effect of compilation.
395 LLVM_PREFERRED_TYPE(bool)
396 unsigned EmitSymbolGraph : 1;
397
398 /// Whether to emit additional symbol graphs for extended modules.
399 LLVM_PREFERRED_TYPE(bool)
401
402 /// Whether to emit symbol labels for testing in generated symbol graphs
403 LLVM_PREFERRED_TYPE(bool)
405
406 /// Whether to emit symbol labels for testing in generated symbol graphs
407 LLVM_PREFERRED_TYPE(bool)
409
410 /// Whether to generate reduced BMI for C++20 named modules.
411 LLVM_PREFERRED_TYPE(bool)
412 unsigned GenReducedBMI : 1;
413
414 /// Use Clang IR pipeline to emit code
415 LLVM_PREFERRED_TYPE(bool)
416 unsigned UseClangIRPipeline : 1;
417
419
420 /// Specifies the output format of the AST.
422
423 enum {
429
430 enum {
432
433 /// Enable migration to modern ObjC literals.
435
436 /// Enable migration to modern ObjC subscripting.
438
439 /// Enable migration to modern ObjC readonly property.
441
442 /// Enable migration to modern ObjC readwrite property.
444
445 /// Enable migration to modern ObjC property.
447
448 /// Enable annotation of ObjCMethods of all kinds.
450
451 /// Enable migration of ObjC methods to 'instancetype'.
453
454 /// Enable migration to NS_ENUM/NS_OPTIONS macros.
456
457 /// Enable migration to add conforming protocols.
459
460 /// prefer 'atomic' property over 'nonatomic'.
462
463 /// annotate property with NS_RETURNS_INNER_POINTER
465
466 /// use NS_NONATOMIC_IOSONLY for property 'atomic' attribute
468
469 /// Enable inferring NS_DESIGNATED_INITIALIZER for ObjC methods.
471
472 /// Enable converting setter/getter expressions to property-dot syntx.
474
482 };
485
486 std::string MTMigrateDir;
488
489 /// The input kind, either specified via -x argument or deduced from the input
490 /// file name.
492
493 /// The input files and their types.
495
496 /// When the input is a module map, the original module map file from which
497 /// that map was inferred, if any (for umbrella modules).
498 std::string OriginalModuleMap;
499
500 /// The output file, if any.
501 std::string OutputFile;
502
503 /// If given, the new suffix for fix-it rewritten files.
504 std::string FixItSuffix;
505
506 /// If given, filter dumped AST Decl nodes by this substring.
507 std::string ASTDumpFilter;
508
509 /// If given, enable code completion at the provided location.
511
512 /// The frontend action to perform.
514
515 /// The name of the action to run when using a plugin action.
516 std::string ActionName;
517
518 // Currently this is only used as part of the `-extract-api` action.
519 /// The name of the product the input files belong too.
520 std::string ProductName;
521
522 // Currently this is only used as part of the `-extract-api` action.
523 // A comma separated list of files providing a list of APIs to
524 // ignore when extracting documentation.
525 std::vector<std::string> ExtractAPIIgnoresFileList;
526
527 // Location of output directory where symbol graph information would
528 // be dumped. This overrides regular -o output file specification
530
531 /// Args to pass to the plugins
532 std::map<std::string, std::vector<std::string>> PluginArgs;
533
534 /// The list of plugin actions to run in addition to the normal action.
535 std::vector<std::string> AddPluginActions;
536
537 /// The list of plugins to load.
538 std::vector<std::string> Plugins;
539
540 /// The list of module file extensions.
541 std::vector<std::shared_ptr<ModuleFileExtension>> ModuleFileExtensions;
542
543 /// The list of module map files to load before processing the input.
544 std::vector<std::string> ModuleMapFiles;
545
546 /// The list of additional prebuilt module files to load before
547 /// processing the input.
548 std::vector<std::string> ModuleFiles;
549
550 /// The list of files to embed into the compiled module file.
551 std::vector<std::string> ModulesEmbedFiles;
552
553 /// The list of AST files to merge.
554 std::vector<std::string> ASTMergeFiles;
555
556 /// A list of arguments to forward to LLVM's option processing; this
557 /// should only be used for debugging and experimental features.
558 std::vector<std::string> LLVMArgs;
559
560 /// File name of the file that will provide record layouts
561 /// (in the format produced by -fdump-record-layouts).
563
564 /// Auxiliary triple for CUDA/HIP compilation.
565 std::string AuxTriple;
566
567 /// Auxiliary target CPU for CUDA/HIP compilation.
568 std::optional<std::string> AuxTargetCPU;
569
570 /// Auxiliary target features for CUDA/HIP compilation.
571 std::optional<std::vector<std::string>> AuxTargetFeatures;
572
573 /// Filename to write statistics to.
574 std::string StatsFile;
575
576 /// Minimum time granularity (in microseconds) traced by time profiler.
578
579 /// Path which stores the output files for -ftime-trace
580 std::string TimeTracePath;
581
582 /// Output Path for module output file.
583 std::string ModuleOutputPath;
584
585public:
601
602 /// getInputKindForExtension - Return the appropriate input kind for a file
603 /// extension. For example, "c" would return Language::C.
604 ///
605 /// \return The input kind for the extension, or Language::Unknown if the
606 /// extension is not recognized.
607 static InputKind getInputKindForExtension(StringRef Extension);
608};
609
610} // namespace clang
611
612#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::string ObjCMTAllowListPath
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.
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.
enum clang::FrontendOptions::@198 ARCMTAction
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 ARCMTMigrateReportOut
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.
unsigned ARCMTMigrateEmitARCErrors
Emit ARC errors even if the migrator can fix them.
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 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.
@ ObjCMT_Instancetype
Enable migration of ObjC methods to 'instancetype'.
@ ObjCMT_DesignatedInitializer
Enable inferring NS_DESIGNATED_INITIALIZER for ObjC methods.
@ ObjCMT_Annotation
Enable annotation of ObjCMethods of all kinds.
@ ObjCMT_PropertyDotSyntax
Enable converting setter/getter expressions to property-dot syntx.
@ ObjCMT_ProtocolConformance
Enable migration to add conforming protocols.
@ ObjCMT_NsMacros
Enable migration to NS_ENUM/NS_OPTIONS macros.
@ ObjCMT_AtomicProperty
prefer 'atomic' property over 'nonatomic'.
@ ObjCMT_Literals
Enable migration to modern ObjC literals.
@ ObjCMT_ReadonlyProperty
Enable migration to modern ObjC readonly property.
@ ObjCMT_Subscripting
Enable migration to modern ObjC subscripting.
@ ObjCMT_NsAtomicIOSOnlyProperty
use NS_NONATOMIC_IOSONLY for property 'atomic' attribute
@ ObjCMT_Property
Enable migration to modern ObjC property.
@ ObjCMT_ReadwriteProperty
Enable migration to modern ObjC readwrite property.
@ ObjCMT_ReturnsInnerPointerProperty
annotate property with NS_RETURNS_INNER_POINTER
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
@ 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.
@ MigrateSource
Run migrator.
@ 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.