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