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