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/MemoryBuffer.h"
19#include <cassert>
20#include <map>
21#include <memory>
22#include <string>
23#include <vector>
24
25namespace llvm {
26
27class MemoryBuffer;
28
29} // namespace llvm
30
31namespace clang {
32
33namespace frontend {
34
35enum ActionKind {
36 /// Parse ASTs and list Decl nodes.
37 ASTDeclList,
38
39 /// Parse ASTs and dump them.
40 ASTDump,
41
42 /// Parse ASTs and print them.
43 ASTPrint,
44
45 /// Parse ASTs and view them in Graphviz.
46 ASTView,
47
48 /// Dump the compiler configuration.
49 DumpCompilerOptions,
50
51 /// Dump out raw tokens.
52 DumpRawTokens,
53
54 /// Dump out preprocessed tokens.
55 DumpTokens,
56
57 /// Emit a .s file.
58 EmitAssembly,
59
60 /// Emit a .bc file.
61 EmitBC,
62
63 /// Translate input source into HTML.
64 EmitHTML,
65
66 /// Emit a .ll file.
67 EmitLLVM,
68
69 /// Generate LLVM IR, but do not emit anything.
70 EmitLLVMOnly,
71
72 /// Generate machine code, but don't emit anything.
73 EmitCodeGenOnly,
74
75 /// Emit a .o file.
76 EmitObj,
77
78 /// Parse and apply any fixits to the source.
79 FixIt,
80
81 /// Generate pre-compiled module from a module map.
82 GenerateModule,
83
84 /// Generate pre-compiled module from a C++ module interface file.
85 GenerateModuleInterface,
86
87 /// Generate pre-compiled module from a set of header files.
88 GenerateHeaderModule,
89
90 /// Generate pre-compiled header.
91 GeneratePCH,
92
93 /// Generate Interface Stub Files.
94 GenerateInterfaceStubs,
95
96 /// Only execute frontend initialization.
97 InitOnly,
98
99 /// Dump information about a module file.
100 ModuleFileInfo,
101
102 /// Load and verify that a PCH file is usable.
103 VerifyPCH,
104
105 /// Parse and perform semantic analysis.
106 ParseSyntaxOnly,
107
108 /// Run a plugin action, \see ActionName.
109 PluginAction,
110
111 /// Print the "preamble" of the input file
112 PrintPreamble,
113
114 /// -E mode.
115 PrintPreprocessedInput,
116
117 /// Expand macros but not \#includes.
118 RewriteMacros,
119
120 /// ObjC->C Rewriter.
121 RewriteObjC,
122
123 /// Rewriter playground
124 RewriteTest,
125
126 /// Run one or more source code analyses.
127 RunAnalysis,
128
129 /// Dump template instantiations
130 TemplightDump,
131
132 /// Run migrator.
133 MigrateSource,
134
135 /// Just lex, no output.
136 RunPreprocessorOnly,
137
138 /// Print the output of the dependency directives source minimizer.
139 PrintDependencyDirectivesSourceMinimizerOutput
140};
141
142} // namespace frontend
143
144/// The kind of a file that we've been handed as an input.
145class InputKind {
146private:
147 Language Lang;
148 unsigned Fmt : 3;
149 unsigned Preprocessed : 1;
150
151public:
152 /// The input file format.
153 enum Format {
154 Source,
155 ModuleMap,
156 Precompiled
157 };
158
159 constexpr InputKind(Language L = Language::Unknown, Format F = Source,
160 bool PP = false)
161 : Lang(L), Fmt(F), Preprocessed(PP) {}
162
163 Language getLanguage() const { return static_cast<Language>(Lang); }
164 Format getFormat() const { return static_cast<Format>(Fmt); }
165 bool isPreprocessed() const { return Preprocessed; }
166
167 /// Is the input kind fully-unknown?
168 bool isUnknown() const { return Lang == Language::Unknown && Fmt == Source; }
169
170 /// Is the language of the input some dialect of Objective-C?
171 bool isObjectiveC() const {
172 return Lang == Language::ObjC || Lang == Language::ObjCXX;
173 }
174
175 InputKind getPreprocessed() const {
176 return InputKind(getLanguage(), getFormat(), true);
177 }
178
179 InputKind withFormat(Format F) const {
180 return InputKind(getLanguage(), F, isPreprocessed());
181 }
182};
183
184/// An input file for the front end.
185class FrontendInputFile {
186 /// The file name, or "-" to read from standard input.
187 std::string File;
188
189 /// The input, if it comes from a buffer rather than a file. This object
190 /// does not own the buffer, and the caller is responsible for ensuring
191 /// that it outlives any users.
192 llvm::Optional<llvm::MemoryBufferRef> Buffer;
193
194 /// The kind of input, e.g., C source, AST file, LLVM IR.
195 InputKind Kind;
196
197 /// Whether we're dealing with a 'system' input (vs. a 'user' input).
198 bool IsSystem = false;
199
200public:
201 FrontendInputFile() = default;
202 FrontendInputFile(StringRef File, InputKind Kind, bool IsSystem = false)
203 : File(File.str()), Kind(Kind), IsSystem(IsSystem) {}
204 FrontendInputFile(llvm::MemoryBufferRef Buffer, InputKind Kind,
205 bool IsSystem = false)
206 : Buffer(Buffer), Kind(Kind), IsSystem(IsSystem) {}
207
208 InputKind getKind() const { return Kind; }
209 bool isSystem() const { return IsSystem; }
210
211 bool isEmpty() const { return File.empty() && Buffer == None; }
212 bool isFile() const { return !isBuffer(); }
213 bool isBuffer() const { return Buffer != None; }
214 bool isPreprocessed() const { return Kind.isPreprocessed(); }
215
216 StringRef getFile() const {
217 assert(isFile());
218 return File;
219 }
220
221 llvm::MemoryBufferRef getBuffer() const {
222 assert(isBuffer());
223 return *Buffer;
224 }
225};
226
227/// FrontendOptions - Options for controlling the behavior of the frontend.
228class FrontendOptions {
229public:
230 /// Disable memory freeing on exit.
231 unsigned DisableFree : 1;
232
233 /// When generating PCH files, instruct the AST writer to create relocatable
234 /// PCH files.
235 unsigned RelocatablePCH : 1;
236
237 /// Show the -help text.
238 unsigned ShowHelp : 1;
239
240 /// Show frontend performance metrics and statistics.
241 unsigned ShowStats : 1;
242
243 /// print the supported cpus for the current target
244 unsigned PrintSupportedCPUs : 1;
245
246 /// Output time trace profile.
247 unsigned TimeTrace : 1;
248
249 /// Show the -version text.
250 unsigned ShowVersion : 1;
251
252 /// Apply fixes even if there are unfixable errors.
253 unsigned FixWhatYouCan : 1;
254
255 /// Apply fixes only for warnings.
256 unsigned FixOnlyWarnings : 1;
257
258 /// Apply fixes and recompile.
259 unsigned FixAndRecompile : 1;
260
261 /// Apply fixes to temporary files.
262 unsigned FixToTemporaries : 1;
263
264 /// Emit ARC errors even if the migrator can fix them.
265 unsigned ARCMTMigrateEmitARCErrors : 1;
266
267 /// Skip over function bodies to speed up parsing in cases you do not need
268 /// them (e.g. with code completion).
269 unsigned SkipFunctionBodies : 1;
270
271 /// Whether we can use the global module index if available.
272 unsigned UseGlobalModuleIndex : 1;
273
274 /// Whether we can generate the global module index if needed.
275 unsigned GenerateGlobalModuleIndex : 1;
276
277 /// Whether we include declaration dumps in AST dumps.
278 unsigned ASTDumpDecls : 1;
279
280 /// Whether we deserialize all decls when forming AST dumps.
281 unsigned ASTDumpAll : 1;
282
283 /// Whether we include lookup table dumps in AST dumps.
284 unsigned ASTDumpLookups : 1;
285
286 /// Whether we include declaration type dumps in AST dumps.
287 unsigned ASTDumpDeclTypes : 1;
288
289 /// Whether we are performing an implicit module build.
290 unsigned BuildingImplicitModule : 1;
291
292 /// Whether we should embed all used files into the PCM file.
293 unsigned ModulesEmbedAllFiles : 1;
294
295 /// Whether timestamps should be written to the produced PCH file.
296 unsigned IncludeTimestamps : 1;
297
298 /// Should a temporary file be used during compilation.
299 unsigned UseTemporary : 1;
300
301 /// When using -emit-module, treat the modulemap as a system module.
302 unsigned IsSystemModule : 1;
303
304 /// Output (and read) PCM files regardless of compiler errors.
305 unsigned AllowPCMWithCompilerErrors : 1;
306
307 CodeCompleteOptions CodeCompleteOpts;
308
309 /// Specifies the output format of the AST.
310 ASTDumpOutputFormat ASTDumpFormat = ADOF_Default;
311
312 enum {
313 ARCMT_None,
314 ARCMT_Check,
315 ARCMT_Modify,
316 ARCMT_Migrate
317 } ARCMTAction = ARCMT_None;
318
319 enum {
320 ObjCMT_None = 0,
321
322 /// Enable migration to modern ObjC literals.
323 ObjCMT_Literals = 0x1,
324
325 /// Enable migration to modern ObjC subscripting.
326 ObjCMT_Subscripting = 0x2,
327
328 /// Enable migration to modern ObjC readonly property.
329 ObjCMT_ReadonlyProperty = 0x4,
330
331 /// Enable migration to modern ObjC readwrite property.
332 ObjCMT_ReadwriteProperty = 0x8,
333
334 /// Enable migration to modern ObjC property.
335 ObjCMT_Property = (ObjCMT_ReadonlyProperty | ObjCMT_ReadwriteProperty),
336
337 /// Enable annotation of ObjCMethods of all kinds.
338 ObjCMT_Annotation = 0x10,
339
340 /// Enable migration of ObjC methods to 'instancetype'.
341 ObjCMT_Instancetype = 0x20,
342
343 /// Enable migration to NS_ENUM/NS_OPTIONS macros.
344 ObjCMT_NsMacros = 0x40,
345
346 /// Enable migration to add conforming protocols.
347 ObjCMT_ProtocolConformance = 0x80,
348
349 /// prefer 'atomic' property over 'nonatomic'.
350 ObjCMT_AtomicProperty = 0x100,
351
352 /// annotate property with NS_RETURNS_INNER_POINTER
353 ObjCMT_ReturnsInnerPointerProperty = 0x200,
354
355 /// use NS_NONATOMIC_IOSONLY for property 'atomic' attribute
356 ObjCMT_NsAtomicIOSOnlyProperty = 0x400,
357
358 /// Enable inferring NS_DESIGNATED_INITIALIZER for ObjC methods.
359 ObjCMT_DesignatedInitializer = 0x800,
360
361 /// Enable converting setter/getter expressions to property-dot syntx.
362 ObjCMT_PropertyDotSyntax = 0x1000,
363
364 ObjCMT_MigrateDecls = (ObjCMT_ReadonlyProperty | ObjCMT_ReadwriteProperty |
365 ObjCMT_Annotation | ObjCMT_Instancetype |
366 ObjCMT_NsMacros | ObjCMT_ProtocolConformance |
367 ObjCMT_NsAtomicIOSOnlyProperty |
368 ObjCMT_DesignatedInitializer),
369 ObjCMT_MigrateAll = (ObjCMT_Literals | ObjCMT_Subscripting |
370 ObjCMT_MigrateDecls | ObjCMT_PropertyDotSyntax)
371 };
372 unsigned ObjCMTAction = ObjCMT_None;
373 std::string ObjCMTWhiteListPath;
374
375 std::string MTMigrateDir;
376 std::string ARCMTMigrateReportOut;
377
378 /// The input kind, either specified via -x argument or deduced from the input
379 /// file name.
380 InputKind DashX;
381
382 /// The input files and their types.
383 SmallVector<FrontendInputFile, 0> Inputs;
384
385 /// When the input is a module map, the original module map file from which
386 /// that map was inferred, if any (for umbrella modules).
387 std::string OriginalModuleMap;
388
389 /// The output file, if any.
390 std::string OutputFile;
391
392 /// If given, the new suffix for fix-it rewritten files.
393 std::string FixItSuffix;
394
395 /// If given, filter dumped AST Decl nodes by this substring.
396 std::string ASTDumpFilter;
397
398 /// If given, enable code completion at the provided location.
399 ParsedSourceLocation CodeCompletionAt;
400
401 /// The frontend action to perform.
402 frontend::ActionKind ProgramAction = frontend::ParseSyntaxOnly;
403
404 /// The name of the action to run when using a plugin action.
405 std::string ActionName;
406
407 /// Args to pass to the plugins
408 std::map<std::string, std::vector<std::string>> PluginArgs;
409
410 /// The list of plugin actions to run in addition to the normal action.
411 std::vector<std::string> AddPluginActions;
412
413 /// The list of plugins to load.
414 std::vector<std::string> Plugins;
415
416 /// The list of module file extensions.
417 std::vector<std::shared_ptr<ModuleFileExtension>> ModuleFileExtensions;
418
419 /// The list of module map files to load before processing the input.
420 std::vector<std::string> ModuleMapFiles;
421
422 /// The list of additional prebuilt module files to load before
423 /// processing the input.
424 std::vector<std::string> ModuleFiles;
425
426 /// The list of files to embed into the compiled module file.
427 std::vector<std::string> ModulesEmbedFiles;
428
429 /// The list of AST files to merge.
430 std::vector<std::string> ASTMergeFiles;
431
432 /// A list of arguments to forward to LLVM's option processing; this
433 /// should only be used for debugging and experimental features.
434 std::vector<std::string> LLVMArgs;
435
436 /// File name of the file that will provide record layouts
437 /// (in the format produced by -fdump-record-layouts).
438 std::string OverrideRecordLayoutsFile;
439
440 /// Auxiliary triple for CUDA/HIP compilation.
441 std::string AuxTriple;
442
443 /// Auxiliary target CPU for CUDA/HIP compilation.
444 Optional<std::string> AuxTargetCPU;
445
446 /// Auxiliary target features for CUDA/HIP compilation.
447 Optional<std::vector<std::string>> AuxTargetFeatures;
448
449 /// Filename to write statistics to.
450 std::string StatsFile;
451
452 /// Minimum time granularity (in microseconds) traced by time profiler.
453 unsigned TimeTraceGranularity;
454
455public:
456 FrontendOptions()
457 : DisableFree(false), RelocatablePCH(false), ShowHelp(false),
458 ShowStats(false), TimeTrace(false), ShowVersion(false),
459 FixWhatYouCan(false), FixOnlyWarnings(false), FixAndRecompile(false),
460 FixToTemporaries(false), ARCMTMigrateEmitARCErrors(false),
461 SkipFunctionBodies(false), UseGlobalModuleIndex(true),
462 GenerateGlobalModuleIndex(true), ASTDumpDecls(false),
463 ASTDumpLookups(false), BuildingImplicitModule(false),
464 ModulesEmbedAllFiles(false), IncludeTimestamps(true),
465 UseTemporary(true), AllowPCMWithCompilerErrors(false),
466 TimeTraceGranularity(500) {}
467
468 /// getInputKindForExtension - Return the appropriate input kind for a file
469 /// extension. For example, "c" would return Language::C.
470 ///
471 /// \return The input kind for the extension, or Language::Unknown if the
472 /// extension is not recognized.
473 static InputKind getInputKindForExtension(StringRef Extension);
474};
475
476} // namespace clang
477
478#endif // LLVM_CLANG_FRONTEND_FRONTENDOPTIONS_H
479