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 24namespace llvm { 25 26class MemoryBuffer; 27 28} // namespace llvm 29 30namespace clang { 31 32namespace frontend { 33 34enum 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 GenerateInterfaceIfsExpV1, 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. 144class InputKind { 145private: 146 Language Lang; 147 unsigned Fmt : 3; 148 unsigned Preprocessed : 1; 149 150public: 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 : Lang(L), Fmt(F), Preprocessed(PP) {} 161 162 Language getLanguage() const { return static_cast<Language>(Lang); } 163 Format getFormat() const { return static_cast<Format>(Fmt); } 164 bool isPreprocessed() const { return Preprocessed; } 165 166 /// Is the input kind fully-unknown? 167 bool isUnknown() const { return Lang == Language::Unknown && Fmt == Source; } 168 169 /// Is the language of the input some dialect of Objective-C? 170 bool isObjectiveC() const { 171 return Lang == Language::ObjC || Lang == Language::ObjCXX; 172 } 173 174 InputKind getPreprocessed() const { 175 return InputKind(getLanguage(), getFormat(), true); 176 } 177 178 InputKind withFormat(Format F) const { 179 return InputKind(getLanguage(), F, isPreprocessed()); 180 } 181}; 182 183/// An input file for the front end. 184class 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 const llvm::MemoryBuffer *Buffer = nullptr; 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 199public: 200 FrontendInputFile() = default; 201 FrontendInputFile(StringRef File, InputKind Kind, bool IsSystem = false) 202 : File(File.str()), Kind(Kind), IsSystem(IsSystem) {} 203 FrontendInputFile(const llvm::MemoryBuffer *Buffer, InputKind Kind, 204 bool IsSystem = false) 205 : Buffer(Buffer), Kind(Kind), IsSystem(IsSystem) {} 206 207 InputKind getKind() const { return Kind; } 208 bool isSystem() const { return IsSystem; } 209 210 bool isEmpty() const { return File.empty() && Buffer == nullptr; } 211 bool isFile() const { return !isBuffer(); } 212 bool isBuffer() const { return Buffer != nullptr; } 213 bool isPreprocessed() const { return Kind.isPreprocessed(); } 214 215 StringRef getFile() const { 216 assert(isFile()); 217 return File; 218 } 219 220 const llvm::MemoryBuffer *getBuffer() const { 221 assert(isBuffer()); 222 return Buffer; 223 } 224}; 225 226/// FrontendOptions - Options for controlling the behavior of the frontend. 227class FrontendOptions { 228public: 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 /// Show timers for individual actions. 243 unsigned ShowTimers : 1; 244 245 /// print the supported cpus for the current target 246 unsigned PrintSupportedCPUs : 1; 247 248 /// Output time trace profile. 249 unsigned TimeTrace : 1; 250 251 /// Show the -version text. 252 unsigned ShowVersion : 1; 253 254 /// Apply fixes even if there are unfixable errors. 255 unsigned FixWhatYouCan : 1; 256 257 /// Apply fixes only for warnings. 258 unsigned FixOnlyWarnings : 1; 259 260 /// Apply fixes and recompile. 261 unsigned FixAndRecompile : 1; 262 263 /// Apply fixes to temporary files. 264 unsigned FixToTemporaries : 1; 265 266 /// Emit ARC errors even if the migrator can fix them. 267 unsigned ARCMTMigrateEmitARCErrors : 1; 268 269 /// Skip over function bodies to speed up parsing in cases you do not need 270 /// them (e.g. with code completion). 271 unsigned SkipFunctionBodies : 1; 272 273 /// Whether we can use the global module index if available. 274 unsigned UseGlobalModuleIndex : 1; 275 276 /// Whether we can generate the global module index if needed. 277 unsigned GenerateGlobalModuleIndex : 1; 278 279 /// Whether we include declaration dumps in AST dumps. 280 unsigned ASTDumpDecls : 1; 281 282 /// Whether we deserialize all decls when forming AST dumps. 283 unsigned ASTDumpAll : 1; 284 285 /// Whether we include lookup table dumps in AST dumps. 286 unsigned ASTDumpLookups : 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 CodeCompleteOptions CodeCompleteOpts; 301 302 /// Specifies the output format of the AST. 303 ASTDumpOutputFormat ASTDumpFormat = ADOF_Default; 304 305 enum { 306 ARCMT_None, 307 ARCMT_Check, 308 ARCMT_Modify, 309 ARCMT_Migrate 310 } ARCMTAction = ARCMT_None; 311 312 enum { 313 ObjCMT_None = 0, 314 315 /// Enable migration to modern ObjC literals. 316 ObjCMT_Literals = 0x1, 317 318 /// Enable migration to modern ObjC subscripting. 319 ObjCMT_Subscripting = 0x2, 320 321 /// Enable migration to modern ObjC readonly property. 322 ObjCMT_ReadonlyProperty = 0x4, 323 324 /// Enable migration to modern ObjC readwrite property. 325 ObjCMT_ReadwriteProperty = 0x8, 326 327 /// Enable migration to modern ObjC property. 328 ObjCMT_Property = (ObjCMT_ReadonlyProperty | ObjCMT_ReadwriteProperty), 329 330 /// Enable annotation of ObjCMethods of all kinds. 331 ObjCMT_Annotation = 0x10, 332 333 /// Enable migration of ObjC methods to 'instancetype'. 334 ObjCMT_Instancetype = 0x20, 335 336 /// Enable migration to NS_ENUM/NS_OPTIONS macros. 337 ObjCMT_NsMacros = 0x40, 338 339 /// Enable migration to add conforming protocols. 340 ObjCMT_ProtocolConformance = 0x80, 341 342 /// prefer 'atomic' property over 'nonatomic'. 343 ObjCMT_AtomicProperty = 0x100, 344 345 /// annotate property with NS_RETURNS_INNER_POINTER 346 ObjCMT_ReturnsInnerPointerProperty = 0x200, 347 348 /// use NS_NONATOMIC_IOSONLY for property 'atomic' attribute 349 ObjCMT_NsAtomicIOSOnlyProperty = 0x400, 350 351 /// Enable inferring NS_DESIGNATED_INITIALIZER for ObjC methods. 352 ObjCMT_DesignatedInitializer = 0x800, 353 354 /// Enable converting setter/getter expressions to property-dot syntx. 355 ObjCMT_PropertyDotSyntax = 0x1000, 356 357 ObjCMT_MigrateDecls = (ObjCMT_ReadonlyProperty | ObjCMT_ReadwriteProperty | 358 ObjCMT_Annotation | ObjCMT_Instancetype | 359 ObjCMT_NsMacros | ObjCMT_ProtocolConformance | 360 ObjCMT_NsAtomicIOSOnlyProperty | 361 ObjCMT_DesignatedInitializer), 362 ObjCMT_MigrateAll = (ObjCMT_Literals | ObjCMT_Subscripting | 363 ObjCMT_MigrateDecls | ObjCMT_PropertyDotSyntax) 364 }; 365 unsigned ObjCMTAction = ObjCMT_None; 366 std::string ObjCMTWhiteListPath; 367 368 std::string MTMigrateDir; 369 std::string ARCMTMigrateReportOut; 370 371 /// The input files and their types. 372 SmallVector<FrontendInputFile, 0> Inputs; 373 374 /// When the input is a module map, the original module map file from which 375 /// that map was inferred, if any (for umbrella modules). 376 std::string OriginalModuleMap; 377 378 /// The output file, if any. 379 std::string OutputFile; 380 381 /// If given, the new suffix for fix-it rewritten files. 382 std::string FixItSuffix; 383 384 /// If given, filter dumped AST Decl nodes by this substring. 385 std::string ASTDumpFilter; 386 387 /// If given, enable code completion at the provided location. 388 ParsedSourceLocation CodeCompletionAt; 389 390 /// The frontend action to perform. 391 frontend::ActionKind ProgramAction = frontend::ParseSyntaxOnly; 392 393 /// The name of the action to run when using a plugin action. 394 std::string ActionName; 395 396 /// Args to pass to the plugins 397 std::unordered_map<std::string,std::vector<std::string>> PluginArgs; 398 399 /// The list of plugin actions to run in addition to the normal action. 400 std::vector<std::string> AddPluginActions; 401 402 /// The list of plugins to load. 403 std::vector<std::string> Plugins; 404 405 /// The list of module file extensions. 406 std::vector<std::shared_ptr<ModuleFileExtension>> ModuleFileExtensions; 407 408 /// The list of module map files to load before processing the input. 409 std::vector<std::string> ModuleMapFiles; 410 411 /// The list of additional prebuilt module files to load before 412 /// processing the input. 413 std::vector<std::string> ModuleFiles; 414 415 /// The list of files to embed into the compiled module file. 416 std::vector<std::string> ModulesEmbedFiles; 417 418 /// The list of AST files to merge. 419 std::vector<std::string> ASTMergeFiles; 420 421 /// A list of arguments to forward to LLVM's option processing; this 422 /// should only be used for debugging and experimental features. 423 std::vector<std::string> LLVMArgs; 424 425 /// File name of the file that will provide record layouts 426 /// (in the format produced by -fdump-record-layouts). 427 std::string OverrideRecordLayoutsFile; 428 429 /// Auxiliary triple for CUDA compilation. 430 std::string AuxTriple; 431 432 /// Filename to write statistics to. 433 std::string StatsFile; 434 435 /// Minimum time granularity (in microseconds) traced by time profiler. 436 unsigned TimeTraceGranularity; 437 438public: 439 FrontendOptions() 440 : DisableFree(false), RelocatablePCH(false), ShowHelp(false), 441 ShowStats(false), ShowTimers(false), TimeTrace(false), 442 ShowVersion(false), FixWhatYouCan(false), FixOnlyWarnings(false), 443 FixAndRecompile(false), FixToTemporaries(false), 444 ARCMTMigrateEmitARCErrors(false), SkipFunctionBodies(false), 445 UseGlobalModuleIndex(true), GenerateGlobalModuleIndex(true), 446 ASTDumpDecls(false), ASTDumpLookups(false), 447 BuildingImplicitModule(false), ModulesEmbedAllFiles(false), 448 IncludeTimestamps(true), UseTemporary(true), TimeTraceGranularity(500) {} 449 450 /// getInputKindForExtension - Return the appropriate input kind for a file 451 /// extension. For example, "c" would return Language::C. 452 /// 453 /// \return The input kind for the extension, or Language::Unknown if the 454 /// extension is not recognized. 455 static InputKind getInputKindForExtension(StringRef Extension); 456}; 457 458} // namespace clang 459 460#endif // LLVM_CLANG_FRONTEND_FRONTENDOPTIONS_H 461