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 
25 namespace llvm {
26 
27 class MemoryBuffer;
28 
29 } // namespace llvm
30 
31 namespace clang {
32 
33 namespace frontend {
34 
35 enum 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.
145 class InputKind {
146 private:
147   Language Lang;
148   unsigned Fmt : 3;
149   unsigned Preprocessed : 1;
150 
151 public:
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)
Lang(L)161       : Lang(L), Fmt(F), Preprocessed(PP) {}
162 
getLanguage()163   Language getLanguage() const { return static_cast<Language>(Lang); }
getFormat()164   Format getFormat() const { return static_cast<Format>(Fmt); }
isPreprocessed()165   bool isPreprocessed() const { return Preprocessed; }
166 
167   /// Is the input kind fully-unknown?
isUnknown()168   bool isUnknown() const { return Lang == Language::Unknown && Fmt == Source; }
169 
170   /// Is the language of the input some dialect of Objective-C?
isObjectiveC()171   bool isObjectiveC() const {
172     return Lang == Language::ObjC || Lang == Language::ObjCXX;
173   }
174 
getPreprocessed()175   InputKind getPreprocessed() const {
176     return InputKind(getLanguage(), getFormat(), true);
177   }
178 
withFormat(Format F)179   InputKind withFormat(Format F) const {
180     return InputKind(getLanguage(), F, isPreprocessed());
181   }
182 };
183 
184 /// An input file for the front end.
185 class 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 
200 public:
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)
Buffer(Buffer)206       : Buffer(Buffer), Kind(Kind), IsSystem(IsSystem) {}
207 
getKind()208   InputKind getKind() const { return Kind; }
isSystem()209   bool isSystem() const { return IsSystem; }
210 
isEmpty()211   bool isEmpty() const { return File.empty() && Buffer == None; }
isFile()212   bool isFile() const { return !isBuffer(); }
isBuffer()213   bool isBuffer() const { return Buffer != None; }
isPreprocessed()214   bool isPreprocessed() const { return Kind.isPreprocessed(); }
215 
getFile()216   StringRef getFile() const {
217     assert(isFile());
218     return File;
219   }
220 
getBuffer()221   llvm::MemoryBufferRef getBuffer() const {
222     assert(isBuffer());
223     return *Buffer;
224   }
225 };
226 
227 /// FrontendOptions - Options for controlling the behavior of the frontend.
228 class FrontendOptions {
229 public:
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 
455 public:
FrontendOptions()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