clang  7.0.0svn
FrontendOptions.h
Go to the documentation of this file.
1 //===- FrontendOptions.h ----------------------------------------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #ifndef LLVM_CLANG_FRONTEND_FRONTENDOPTIONS_H
11 #define LLVM_CLANG_FRONTEND_FRONTENDOPTIONS_H
12 
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 header.
87 
88  /// Generate pre-tokenized header.
90 
91  /// Only execute frontend initialization.
93 
94  /// Dump information about a module file.
96 
97  /// Load and verify that a PCH file is usable.
99 
100  /// Parse and perform semantic analysis.
102 
103  /// Run a plugin action, \see ActionName.
105 
106  /// Print DeclContext and their Decls.
108 
109  /// Print the "preamble" of the input file
111 
112  /// -E mode.
114 
115  /// Expand macros but not \#includes.
117 
118  /// ObjC->C Rewriter.
120 
121  /// Rewriter playground
123 
124  /// Run one or more source code analyses.
126 
127  /// Dump template instantiations
129 
130  /// Run migrator.
132 
133  /// Just lex, no output.
135 };
136 
137 } // namespace frontend
138 
139 /// The kind of a file that we've been handed as an input.
140 class InputKind {
141 private:
142  unsigned Lang : 4;
143  unsigned Fmt : 3;
144  unsigned Preprocessed : 1;
145 
146 public:
147  /// The language for the input, used to select and validate the language
148  /// standard and possible actions.
149  enum Language {
151 
152  /// Assembly: we accept this only so that we can preprocess it.
154 
155  /// LLVM IR: we accept this so that we can run the optimizer on it,
156  /// and compile it to assembly or object code.
158 
159  ///@{ Languages that the frontend can parse and compile.
160  C,
168  ///@}
169  };
170 
171  /// The input file format.
172  enum Format {
175  Precompiled
176  };
177 
178  constexpr InputKind(Language L = Unknown, Format F = Source,
179  bool PP = false)
180  : Lang(L), Fmt(F), Preprocessed(PP) {}
181 
182  Language getLanguage() const { return static_cast<Language>(Lang); }
183  Format getFormat() const { return static_cast<Format>(Fmt); }
184  bool isPreprocessed() const { return Preprocessed; }
185 
186  /// Is the input kind fully-unknown?
187  bool isUnknown() const { return Lang == Unknown && Fmt == Source; }
188 
189  /// Is the language of the input some dialect of Objective-C?
190  bool isObjectiveC() const { return Lang == ObjC || Lang == ObjCXX; }
191 
193  return InputKind(getLanguage(), getFormat(), true);
194  }
195 
197  return InputKind(getLanguage(), F, isPreprocessed());
198  }
199 };
200 
201 /// An input file for the front end.
203  /// The file name, or "-" to read from standard input.
204  std::string File;
205 
206  /// The input, if it comes from a buffer rather than a file. This object
207  /// does not own the buffer, and the caller is responsible for ensuring
208  /// that it outlives any users.
209  llvm::MemoryBuffer *Buffer = nullptr;
210 
211  /// The kind of input, e.g., C source, AST file, LLVM IR.
212  InputKind Kind;
213 
214  /// Whether we're dealing with a 'system' input (vs. a 'user' input).
215  bool IsSystem = false;
216 
217 public:
218  FrontendInputFile() = default;
219  FrontendInputFile(StringRef File, InputKind Kind, bool IsSystem = false)
220  : File(File.str()), Kind(Kind), IsSystem(IsSystem) {}
221  FrontendInputFile(llvm::MemoryBuffer *Buffer, InputKind Kind,
222  bool IsSystem = false)
223  : Buffer(Buffer), Kind(Kind), IsSystem(IsSystem) {}
224 
225  InputKind getKind() const { return Kind; }
226  bool isSystem() const { return IsSystem; }
227 
228  bool isEmpty() const { return File.empty() && Buffer == nullptr; }
229  bool isFile() const { return !isBuffer(); }
230  bool isBuffer() const { return Buffer != nullptr; }
231  bool isPreprocessed() const { return Kind.isPreprocessed(); }
232 
233  StringRef getFile() const {
234  assert(isFile());
235  return File;
236  }
237 
238  llvm::MemoryBuffer *getBuffer() const {
239  assert(isBuffer());
240  return Buffer;
241  }
242 };
243 
244 /// FrontendOptions - Options for controlling the behavior of the frontend.
246 public:
247  /// Disable memory freeing on exit.
248  unsigned DisableFree : 1;
249 
250  /// When generating PCH files, instruct the AST writer to create relocatable
251  /// PCH files.
252  unsigned RelocatablePCH : 1;
253 
254  /// Show the -help text.
255  unsigned ShowHelp : 1;
256 
257  /// Show frontend performance metrics and statistics.
258  unsigned ShowStats : 1;
259 
260  /// Show timers for individual actions.
261  unsigned ShowTimers : 1;
262 
263  /// Show the -version text.
264  unsigned ShowVersion : 1;
265 
266  /// Apply fixes even if there are unfixable errors.
267  unsigned FixWhatYouCan : 1;
268 
269  /// Apply fixes only for warnings.
270  unsigned FixOnlyWarnings : 1;
271 
272  /// Apply fixes and recompile.
273  unsigned FixAndRecompile : 1;
274 
275  /// Apply fixes to temporary files.
276  unsigned FixToTemporaries : 1;
277 
278  /// Emit ARC errors even if the migrator can fix them.
280 
281  /// Skip over function bodies to speed up parsing in cases you do not need
282  /// them (e.g. with code completion).
283  unsigned SkipFunctionBodies : 1;
284 
285  /// Whether we can use the global module index if available.
286  unsigned UseGlobalModuleIndex : 1;
287 
288  /// Whether we can generate the global module index if needed.
290 
291  /// Whether we include declaration dumps in AST dumps.
292  unsigned ASTDumpDecls : 1;
293 
294  /// Whether we deserialize all decls when forming AST dumps.
295  unsigned ASTDumpAll : 1;
296 
297  /// Whether we include lookup table dumps in AST dumps.
298  unsigned ASTDumpLookups : 1;
299 
300  /// Whether we are performing an implicit module build.
302 
303  /// Whether we should embed all used files into the PCM file.
304  unsigned ModulesEmbedAllFiles : 1;
305 
306  /// Whether timestamps should be written to the produced PCH file.
307  unsigned IncludeTimestamps : 1;
308 
310 
311  enum {
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;
376 
377  /// The input files and their types.
378  std::vector<FrontendInputFile> 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.
395 
396  /// The frontend action to perform.
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).
434 
435  /// Auxiliary triple for CUDA compilation.
436  std::string AuxTriple;
437 
438  /// If non-empty, search the pch input file as if it was a header
439  /// included by this file.
440  std::string FindPchSource;
441 
442  /// Filename to write statistics to.
443  std::string StatsFile;
444 
445 public:
447  : DisableFree(false), RelocatablePCH(false), ShowHelp(false),
448  ShowStats(false), ShowTimers(false), ShowVersion(false),
449  FixWhatYouCan(false), FixOnlyWarnings(false), FixAndRecompile(false),
450  FixToTemporaries(false), ARCMTMigrateEmitARCErrors(false),
451  SkipFunctionBodies(false), UseGlobalModuleIndex(true),
452  GenerateGlobalModuleIndex(true), ASTDumpDecls(false),
453  ASTDumpLookups(false), BuildingImplicitModule(false),
454  ModulesEmbedAllFiles(false), IncludeTimestamps(true) {}
455 
456  /// getInputKindForExtension - Return the appropriate input kind for a file
457  /// extension. For example, "c" would return InputKind::C.
458  ///
459  /// \return The input kind for the extension, or InputKind::Unknown if the
460  /// extension is not recognized.
461  static InputKind getInputKindForExtension(StringRef Extension);
462 };
463 
464 } // namespace clang
465 
466 #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)
Parse and perform semantic analysis.
DominatorTree GraphTraits specialization so the DominatorTree can be iterable by generic graph iterat...
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.
std::string FindPchSource
If non-empty, search the pch input file as if it was a header included by this file.
FrontendInputFile(llvm::MemoryBuffer *Buffer, InputKind Kind, bool IsSystem=false)
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.
Print DeclContext and their Decls.
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.
llvm::MemoryBuffer * getBuffer() const
std::vector< std::string > Plugins
The list of plugins to load.
StringRef getFile() const
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:33
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.
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.
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.
Generate pre-tokenized header.
#define true
Definition: stdbool.h:32
std::vector< std::string > ModuleMapFiles
The list of module map files to load before processing the input.