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
12#include "clang/AST/ASTDumperUtils.h"
13#include "clang/Basic/LangStandard.h"
14#include "clang/Frontend/CommandLineSourceLoc.h"
15#include "clang/Sema/CodeCompleteOptions.h"
16#include "clang/Serialization/ModuleFileExtension.h"
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
37enum ActionKind {
38 /// Parse ASTs and list Decl nodes.
39 ASTDeclList,
40
41 /// Parse ASTs and dump them.
42 ASTDump,
43
44 /// Parse ASTs and print them.
45 ASTPrint,
46
47 /// Parse ASTs and view them in Graphviz.
48 ASTView,
49
50 /// Dump the compiler configuration.
51 DumpCompilerOptions,
52
53 /// Dump out raw tokens.
54 DumpRawTokens,
55
56 /// Dump out preprocessed tokens.
57 DumpTokens,
58
59 /// Emit a .s file.
60 EmitAssembly,
61
62 /// Emit a .bc file.
63 EmitBC,
64
65 /// Translate input source into HTML.
66 EmitHTML,
67
68 /// Emit a .ll file.
69 EmitLLVM,
70
71 /// Generate LLVM IR, but do not emit anything.
72 EmitLLVMOnly,
73
74 /// Generate machine code, but don't emit anything.
75 EmitCodeGenOnly,
76
77 /// Emit a .o file.
78 EmitObj,
79
80 // Extract API information
81 ExtractAPI,
82
83 /// Parse and apply any fixits to the source.
84 FixIt,
85
86 /// Generate pre-compiled module from a module map.
87 GenerateModule,
88
89 /// Generate pre-compiled module from a standard C++ module interface unit.
90 GenerateModuleInterface,
91
92 /// Generate reduced module interface for a standard C++ module interface
93 /// unit.
94 GenerateReducedModuleInterface,
95
96 /// Generate a C++20 header unit module from a header file.
97 GenerateHeaderUnit,
98
99 /// Generate pre-compiled header.
100 GeneratePCH,
101
102 /// Generate Interface Stub Files.
103 GenerateInterfaceStubs,
104
105 /// Only execute frontend initialization.
106 InitOnly,
107
108 /// Dump information about a module file.
109 ModuleFileInfo,
110
111 /// Load and verify that a PCH file is usable.
112 VerifyPCH,
113
114 /// Parse and perform semantic analysis.
115 ParseSyntaxOnly,
116
117 /// Run a plugin action, \see ActionName.
118 PluginAction,
119
120 /// Print the "preamble" of the input file
121 PrintPreamble,
122
123 /// -E mode.
124 PrintPreprocessedInput,
125
126 /// Expand macros but not \#includes.
127 RewriteMacros,
128
129 /// ObjC->C Rewriter.
130 RewriteObjC,
131
132 /// Rewriter playground
133 RewriteTest,
134
135 /// Run one or more source code analyses.
136 RunAnalysis,
137
138 /// Dump template instantiations
139 TemplightDump,
140
141 /// Run migrator.
142 MigrateSource,
143
144 /// Just lex, no output.
145 RunPreprocessorOnly,
146
147 /// Print the output of the dependency directives source minimizer.
148 PrintDependencyDirectivesSourceMinimizerOutput
149};
150
151} // namespace frontend
152
153/// The kind of a file that we've been handed as an input.
154class InputKind {
155public:
156 /// The input file format.
157 enum Format {
158 Source,
159 ModuleMap,
160 Precompiled
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.
166 enum HeaderUnitKind {
167 HeaderUnit_None,
168 HeaderUnit_User,
169 HeaderUnit_System,
170 HeaderUnit_Abs
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:
185 constexpr InputKind(Language L = Language::Unknown, Format F = Source,
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); }
192 HeaderUnitKind getHeaderUnitKind() const {
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
207 InputKind getPreprocessed() const {
208 return InputKind(getLanguage(), getFormat(), true, getHeaderUnitKind(),
209 isHeader());
210 }
211
212 InputKind getHeader() const {
213 return InputKind(getLanguage(), getFormat(), isPreprocessed(),
214 getHeaderUnitKind(), true);
215 }
216
217 InputKind withHeaderUnit(HeaderUnitKind HU) const {
218 return InputKind(getLanguage(), getFormat(), isPreprocessed(), HU,
219 isHeader());
220 }
221
222 InputKind withFormat(Format F) const {
223 return InputKind(getLanguage(), F, isPreprocessed(), getHeaderUnitKind(),
224 isHeader());
225 }
226};
227
228/// An input file for the front end.
229class FrontendInputFile {
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(); }
260 InputKind::HeaderUnitKind getHeaderUnitKind() const {
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.
276class FrontendOptions {
277public:
278 /// Disable memory freeing on exit.
279 LLVM_PREFERRED_TYPE(bool)
280 unsigned DisableFree : 1;
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)
304 unsigned PrintSupportedExtensions : 1;
305
306 /// Show the -version text.
307 LLVM_PREFERRED_TYPE(bool)
308 unsigned ShowVersion : 1;
309
310 /// Apply fixes even if there are unfixable errors.
311 LLVM_PREFERRED_TYPE(bool)
312 unsigned FixWhatYouCan : 1;
313
314 /// Apply fixes only for warnings.
315 LLVM_PREFERRED_TYPE(bool)
316 unsigned FixOnlyWarnings : 1;
317
318 /// Apply fixes and recompile.
319 LLVM_PREFERRED_TYPE(bool)
320 unsigned FixAndRecompile : 1;
321
322 /// Apply fixes to temporary files.
323 LLVM_PREFERRED_TYPE(bool)
324 unsigned FixToTemporaries : 1;
325
326 /// Emit ARC errors even if the migrator can fix them.
327 LLVM_PREFERRED_TYPE(bool)
328 unsigned ARCMTMigrateEmitARCErrors : 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)
337 unsigned UseGlobalModuleIndex : 1;
338
339 /// Whether we can generate the global module index if needed.
340 LLVM_PREFERRED_TYPE(bool)
341 unsigned GenerateGlobalModuleIndex : 1;
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)
361 unsigned BuildingImplicitModule : 1;
362
363 /// Whether to use a filesystem lock when building implicit modules.
364 LLVM_PREFERRED_TYPE(bool)
365 unsigned BuildingImplicitModuleUsesLock : 1;
366
367 /// Whether we should embed all used files into the PCM file.
368 LLVM_PREFERRED_TYPE(bool)
369 unsigned ModulesEmbedAllFiles : 1;
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)
385 unsigned AllowPCMWithCompilerErrors : 1;
386
387 /// Whether to share the FileManager when building modules.
388 LLVM_PREFERRED_TYPE(bool)
389 unsigned ModulesShareFileManager : 1;
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)
397 unsigned EmitExtensionSymbolGraphs : 1;
398
399 /// Whether to emit symbol labels for testing in generated symbol graphs
400 LLVM_PREFERRED_TYPE(bool)
401 unsigned EmitSymbolGraphSymbolLabelsForTesting : 1;
402
403 /// Whether to emit symbol labels for testing in generated symbol graphs
404 LLVM_PREFERRED_TYPE(bool)
405 unsigned EmitPrettySymbolGraphs : 1;
406
407 /// Whether to generate reduced BMI for C++20 named modules.
408 LLVM_PREFERRED_TYPE(bool)
409 unsigned GenReducedBMI : 1;
410
411 CodeCompleteOptions CodeCompleteOpts;
412
413 /// Specifies the output format of the AST.
414 ASTDumpOutputFormat ASTDumpFormat = ADOF_Default;
415
416 enum {
417 ARCMT_None,
418 ARCMT_Check,
419 ARCMT_Modify,
420 ARCMT_Migrate
421 } ARCMTAction = ARCMT_None;
422
423 enum {
424 ObjCMT_None = 0,
425
426 /// Enable migration to modern ObjC literals.
427 ObjCMT_Literals = 0x1,
428
429 /// Enable migration to modern ObjC subscripting.
430 ObjCMT_Subscripting = 0x2,
431
432 /// Enable migration to modern ObjC readonly property.
433 ObjCMT_ReadonlyProperty = 0x4,
434
435 /// Enable migration to modern ObjC readwrite property.
436 ObjCMT_ReadwriteProperty = 0x8,
437
438 /// Enable migration to modern ObjC property.
439 ObjCMT_Property = (ObjCMT_ReadonlyProperty | ObjCMT_ReadwriteProperty),
440
441 /// Enable annotation of ObjCMethods of all kinds.
442 ObjCMT_Annotation = 0x10,
443
444 /// Enable migration of ObjC methods to 'instancetype'.
445 ObjCMT_Instancetype = 0x20,
446
447 /// Enable migration to NS_ENUM/NS_OPTIONS macros.
448 ObjCMT_NsMacros = 0x40,
449
450 /// Enable migration to add conforming protocols.
451 ObjCMT_ProtocolConformance = 0x80,
452
453 /// prefer 'atomic' property over 'nonatomic'.
454 ObjCMT_AtomicProperty = 0x100,
455
456 /// annotate property with NS_RETURNS_INNER_POINTER
457 ObjCMT_ReturnsInnerPointerProperty = 0x200,
458
459 /// use NS_NONATOMIC_IOSONLY for property 'atomic' attribute
460 ObjCMT_NsAtomicIOSOnlyProperty = 0x400,
461
462 /// Enable inferring NS_DESIGNATED_INITIALIZER for ObjC methods.
463 ObjCMT_DesignatedInitializer = 0x800,
464
465 /// Enable converting setter/getter expressions to property-dot syntx.
466 ObjCMT_PropertyDotSyntax = 0x1000,
467
468 ObjCMT_MigrateDecls = (ObjCMT_ReadonlyProperty | ObjCMT_ReadwriteProperty |
469 ObjCMT_Annotation | ObjCMT_Instancetype |
470 ObjCMT_NsMacros | ObjCMT_ProtocolConformance |
471 ObjCMT_NsAtomicIOSOnlyProperty |
472 ObjCMT_DesignatedInitializer),
473 ObjCMT_MigrateAll = (ObjCMT_Literals | ObjCMT_Subscripting |
474 ObjCMT_MigrateDecls | ObjCMT_PropertyDotSyntax)
475 };
476 unsigned ObjCMTAction = ObjCMT_None;
477 std::string ObjCMTAllowListPath;
478
479 std::string MTMigrateDir;
480 std::string ARCMTMigrateReportOut;
481
482 /// The input kind, either specified via -x argument or deduced from the input
483 /// file name.
484 InputKind DashX;
485
486 /// The input files and their types.
487 SmallVector<FrontendInputFile, 0> Inputs;
488
489 /// When the input is a module map, the original module map file from which
490 /// that map was inferred, if any (for umbrella modules).
491 std::string OriginalModuleMap;
492
493 /// The output file, if any.
494 std::string OutputFile;
495
496 /// If given, the new suffix for fix-it rewritten files.
497 std::string FixItSuffix;
498
499 /// If given, filter dumped AST Decl nodes by this substring.
500 std::string ASTDumpFilter;
501
502 /// If given, enable code completion at the provided location.
503 ParsedSourceLocation CodeCompletionAt;
504
505 /// The frontend action to perform.
506 frontend::ActionKind ProgramAction = frontend::ParseSyntaxOnly;
507
508 /// The name of the action to run when using a plugin action.
509 std::string ActionName;
510
511 // Currently this is only used as part of the `-extract-api` action.
512 /// The name of the product the input files belong too.
513 std::string ProductName;
514
515 // Currently this is only used as part of the `-extract-api` action.
516 // A comma seperated list of files providing a list of APIs to
517 // ignore when extracting documentation.
518 std::vector<std::string> ExtractAPIIgnoresFileList;
519
520 // Location of output directory where symbol graph information would
521 // be dumped. This overrides regular -o output file specification
522 std::string SymbolGraphOutputDir;
523
524 /// Args to pass to the plugins
525 std::map<std::string, std::vector<std::string>> PluginArgs;
526
527 /// The list of plugin actions to run in addition to the normal action.
528 std::vector<std::string> AddPluginActions;
529
530 /// The list of plugins to load.
531 std::vector<std::string> Plugins;
532
533 /// The list of module file extensions.
534 std::vector<std::shared_ptr<ModuleFileExtension>> ModuleFileExtensions;
535
536 /// The list of module map files to load before processing the input.
537 std::vector<std::string> ModuleMapFiles;
538
539 /// The list of additional prebuilt module files to load before
540 /// processing the input.
541 std::vector<std::string> ModuleFiles;
542
543 /// The list of files to embed into the compiled module file.
544 std::vector<std::string> ModulesEmbedFiles;
545
546 /// The list of AST files to merge.
547 std::vector<std::string> ASTMergeFiles;
548
549 /// A list of arguments to forward to LLVM's option processing; this
550 /// should only be used for debugging and experimental features.
551 std::vector<std::string> LLVMArgs;
552
553 /// File name of the file that will provide record layouts
554 /// (in the format produced by -fdump-record-layouts).
555 std::string OverrideRecordLayoutsFile;
556
557 /// Auxiliary triple for CUDA/HIP compilation.
558 std::string AuxTriple;
559
560 /// Auxiliary target CPU for CUDA/HIP compilation.
561 std::optional<std::string> AuxTargetCPU;
562
563 /// Auxiliary target features for CUDA/HIP compilation.
564 std::optional<std::vector<std::string>> AuxTargetFeatures;
565
566 /// Filename to write statistics to.
567 std::string StatsFile;
568
569 /// Minimum time granularity (in microseconds) traced by time profiler.
570 unsigned TimeTraceGranularity;
571
572 /// Path which stores the output files for -ftime-trace
573 std::string TimeTracePath;
574
575 /// Output Path for module output file.
576 std::string ModuleOutputPath;
577
578public:
579 FrontendOptions()
580 : DisableFree(false), RelocatablePCH(false), ShowHelp(false),
581 ShowStats(false), AppendStats(false), ShowVersion(false),
582 FixWhatYouCan(false), FixOnlyWarnings(false), FixAndRecompile(false),
583 FixToTemporaries(false), ARCMTMigrateEmitARCErrors(false),
584 SkipFunctionBodies(false), UseGlobalModuleIndex(true),
585 GenerateGlobalModuleIndex(true), ASTDumpDecls(false),
586 ASTDumpLookups(false), BuildingImplicitModule(false),
587 BuildingImplicitModuleUsesLock(true), ModulesEmbedAllFiles(false),
588 IncludeTimestamps(true), UseTemporary(true),
589 AllowPCMWithCompilerErrors(false), ModulesShareFileManager(true),
590 EmitSymbolGraph(false), EmitExtensionSymbolGraphs(false),
591 EmitSymbolGraphSymbolLabelsForTesting(false),
592 EmitPrettySymbolGraphs(false), GenReducedBMI(false),
593 TimeTraceGranularity(500) {}
594
595 /// getInputKindForExtension - Return the appropriate input kind for a file
596 /// extension. For example, "c" would return Language::C.
597 ///
598 /// \return The input kind for the extension, or Language::Unknown if the
599 /// extension is not recognized.
600 static InputKind getInputKindForExtension(StringRef Extension);
601};
602
603} // namespace clang
604
605#endif // LLVM_CLANG_FRONTEND_FRONTENDOPTIONS_H
606

source code of clang/include/clang/Frontend/FrontendOptions.h