mirror of
https://github.com/apple/swift.git
synced 2025-12-14 20:36:38 +01:00
65e4c10113
This pass has been disabled since a very long time (because it's terrible for code size). It does not work for OSSA. Therefore it cannot be enabled anymore (as is) once we have OSSA throughout the pipeline. So it's time to completely remove it.
1588 lines
74 KiB
TableGen
1588 lines
74 KiB
TableGen
//===--- FrontendOptions.td - Options for swift -frontend -----------------===//
|
|
//
|
|
// This source file is part of the Swift.org open source project
|
|
//
|
|
// Copyright (c) 2014 - 2018 Apple Inc. and the Swift project authors
|
|
// Licensed under Apache License v2.0 with Runtime Library Exception
|
|
//
|
|
// See https://swift.org/LICENSE.txt for license information
|
|
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file defines the options accepted by swift -frontend.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
let Flags = [FrontendOption, NoDriverOption, ArgumentIsFileList] in {
|
|
|
|
def filelist : Separate<["-"], "filelist">,
|
|
HelpText<"Specify source inputs in a file rather than on the command line">;
|
|
def primary_filelist : Separate<["-"], "primary-filelist">,
|
|
HelpText<"Specify primary inputs in a file rather than on the command line">;
|
|
|
|
} // end let Flags = [FrontendOption, NoDriverOption, ArgumentIsFileList]
|
|
|
|
|
|
let Flags = [FrontendOption, NoDriverOption, CacheInvariant] in {
|
|
|
|
def output_filelist : Separate<["-"], "output-filelist">,
|
|
HelpText<"Specify outputs in a file rather than on the command line">;
|
|
def supplementary_output_file_map : Separate<["-"], "supplementary-output-file-map">,
|
|
HelpText<"Specify supplementary outputs in a file rather than on the command line">;
|
|
def index_unit_output_path_filelist : Separate<["-"], "index-unit-output-path-filelist">,
|
|
HelpText<"Specify index unit output paths in a file rather than on the command line">;
|
|
|
|
def emit_module_doc_path
|
|
: Separate<["-"], "emit-module-doc-path">, MetaVarName<"<path>">,
|
|
HelpText<"Output module documentation file <path>">;
|
|
def emit_variant_module_doc_path
|
|
: Separate<["-"], "emit-variant-module-doc-path">, MetaVarName<"<path>">,
|
|
Flags<[NewDriverOnlyOption]>,
|
|
HelpText<"Output module documentation file for the target variant to <path>">;
|
|
|
|
def emit_dependencies_path
|
|
: Separate<["-"], "emit-dependencies-path">, MetaVarName<"<path>">,
|
|
HelpText<"Output basic Make-compatible dependencies file to <path>">;
|
|
def emit_reference_dependencies_path
|
|
: Separate<["-"], "emit-reference-dependencies-path">, MetaVarName<"<path>">,
|
|
HelpText<"Output Swift-style dependencies file to <path>">;
|
|
|
|
def emit_fixits_path
|
|
: Separate<["-"], "emit-fixits-path">, MetaVarName<"<path>">,
|
|
HelpText<"Output compiler fixits as source edits to <path>">;
|
|
def emit_abi_descriptor_path
|
|
: Separate<["-"], "emit-abi-descriptor-path">, MetaVarName<"<path>">,
|
|
HelpText<"Output the ABI descriptor of current module to <path>">;
|
|
def emit_variant_abi_descriptor_path
|
|
: Separate<["-"], "emit-variant-abi-descriptor-path">, MetaVarName<"<path>">,
|
|
Flags<[NewDriverOnlyOption]>,
|
|
HelpText<"Output the ABI descriptor of current target variant module to <path>">;
|
|
|
|
def emit_module_semantic_info_path
|
|
: Separate<["-"], "emit-module-semantic-info-path">, MetaVarName<"<path>">,
|
|
HelpText<"Output semantic info of current module to <path>">;
|
|
|
|
def sil_output_path
|
|
: Separate<["-"], "sil-output-path">, MetaVarName<"<path>">,
|
|
Flags<[FrontendOption, NoInteractiveOption, ArgumentIsPath,
|
|
SupplementaryOutput, CacheInvariant]>,
|
|
HelpText<"Output SIL to <path> as additional output during compilation">;
|
|
|
|
def ir_output_path
|
|
: Separate<["-"], "ir-output-path">, MetaVarName<"<path>">,
|
|
Flags<[FrontendOption, NoInteractiveOption, ArgumentIsPath,
|
|
SupplementaryOutput, CacheInvariant]>,
|
|
HelpText<"Output LLVM IR to <path> as additional output during compilation">;
|
|
|
|
def diagnostic_documentation_path
|
|
: Separate<["-"], "diagnostic-documentation-path">, MetaVarName<"<path>">,
|
|
HelpText<"Path to diagnostic documentation resources">;
|
|
|
|
def dump_api_path : Separate<["-"], "dump-api-path">,
|
|
HelpText<"The path to output swift interface files for the compiled source files">;
|
|
|
|
def group_info_path : Separate<["-"], "group-info-path">,
|
|
HelpText<"The path to collect the group information of the compiled module">;
|
|
|
|
def prebuilt_module_cache_path :
|
|
Separate<["-"], "prebuilt-module-cache-path">,
|
|
HelpText<"Directory of prebuilt modules for loading module interfaces">;
|
|
def prebuilt_module_cache_path_EQ :
|
|
Joined<["-"], "prebuilt-module-cache-path=">,
|
|
Alias<prebuilt_module_cache_path>;
|
|
|
|
def backup_module_interface_path :
|
|
Separate<["-"], "backup-module-interface-path">,
|
|
HelpText<"Directory of module interfaces as backups to those from SDKs">;
|
|
def backup_module_interface_path_EQ :
|
|
Joined<["-"], "backup-module-interface-path=">,
|
|
Alias<backup_module_interface_path>;
|
|
|
|
def frontend_parseable_output : Flag<["-"], "frontend-parseable-output">,
|
|
HelpText<"Emit textual output in a parseable format">;
|
|
|
|
} // end let Flags = [FrontendOption, NoDriverOption, CacheInvariant]
|
|
|
|
def primary_file : Separate<["-"], "primary-file">,
|
|
Flags<[FrontendOption, NoDriverOption, ArgumentIsPath]>,
|
|
HelpText<"Produce output for this file, not the whole module">;
|
|
|
|
def block_list_file
|
|
: Separate<["-"], "blocklist-file">, MetaVarName<"<path>">,
|
|
Flags<[FrontendOption, NoDriverOption, ArgumentIsPath]>,
|
|
HelpText<"The path to a blocklist configuration file">;
|
|
|
|
let Flags = [FrontendOption, NoDriverOption] in {
|
|
|
|
def triple : Separate<["-"], "triple">, Alias<target>;
|
|
|
|
def emit_module_doc : Flag<["-"], "emit-module-doc">,
|
|
HelpText<"Emit a module documentation file based on documentation "
|
|
"comments">;
|
|
|
|
def emit_module_source_info : Flag<["-"], "emit-module-source-info">,
|
|
HelpText<"Output module source info file">;
|
|
def ignore_module_source_info : Flag<["-"], "ignore-module-source-info">,
|
|
HelpText<"Avoid getting source location from .swiftsourceinfo files">;
|
|
|
|
def merge_modules
|
|
: Flag<["-"], "merge-modules">, ModeOpt,
|
|
HelpText<"Merge the input modules without otherwise processing them">;
|
|
def emit_reference_dependencies : Flag<["-"], "emit-reference-dependencies">,
|
|
HelpText<"Emit a Swift-style dependencies file">;
|
|
|
|
def serialize_module_interface_dependency_hashes
|
|
: Flag<["-"], "serialize-module-interface-dependency-hashes">,
|
|
Flags<[HelpHidden]>;
|
|
|
|
def serialize_parseable_module_interface_dependency_hashes
|
|
: Flag<["-"], "serialize-parseable-module-interface-dependency-hashes">,
|
|
Alias<serialize_module_interface_dependency_hashes>,
|
|
Flags<[HelpHidden]>;
|
|
|
|
def tbd_install_name
|
|
: Separate<["-"], "tbd-install_name">, MetaVarName<"<path>">,
|
|
HelpText<"The install_name to use in an emitted TBD file">;
|
|
|
|
def tbd_install_name_EQ : Joined<["-"], "tbd-install_name=">,
|
|
Alias<tbd_install_name>;
|
|
|
|
def tbd_current_version
|
|
: Separate<["-"], "tbd-current-version">, MetaVarName<"<version>">,
|
|
HelpText<"The current_version to use in an emitted TBD file">;
|
|
|
|
def tbd_current_version_EQ : Joined<["-"], "tbd-current-version=">,
|
|
Alias<tbd_current_version>;
|
|
|
|
def tbd_compatibility_version
|
|
: Separate<["-"], "tbd-compatibility-version">, MetaVarName<"<version>">,
|
|
HelpText<"The compatibility_version to use in an emitted TBD file">;
|
|
|
|
def tbd_compatibility_version_EQ : Joined<["-"], "tbd-compatibility-version=">,
|
|
Alias<tbd_compatibility_version>;
|
|
|
|
def tbd_is_installapi: Flag<["-"], "tbd-is-installapi">,
|
|
HelpText<"If the TBD file should indicate it's being generated during "
|
|
"InstallAPI">;
|
|
|
|
def verify : Flag<["-"], "verify">,
|
|
HelpText<"Verify diagnostics against expected-{error|warning|note} "
|
|
"annotations">;
|
|
def verify_additional_file : Separate<["-"], "verify-additional-file">,
|
|
HelpText<"Verify diagnostics in this file in addition to source files">;
|
|
def verify_additional_prefix : Separate<["-"], "verify-additional-prefix">,
|
|
HelpText<"Check for diagnostics with the prefix expected-<PREFIX> as well as expected-">;
|
|
def verify_apply_fixes : Flag<["-"], "verify-apply-fixes">,
|
|
HelpText<"Like -verify, but updates the original source file">;
|
|
def verify_ignore_unknown: Flag<["-"], "verify-ignore-unknown">,
|
|
HelpText<"Allow diagnostics for '<unknown>' location in verify mode">;
|
|
def verify_ignore_unrelated: Flag<["-"], "verify-ignore-unrelated">,
|
|
HelpText<"Allow diagnostics in files outside those with expected diagnostics in verify mode">;
|
|
def verify_generic_signatures : Separate<["-"], "verify-generic-signatures">,
|
|
MetaVarName<"<module-name>">,
|
|
HelpText<"Verify the generic signatures in the given module">;
|
|
|
|
def show_diagnostics_after_fatal : Flag<["-"], "show-diagnostics-after-fatal">,
|
|
HelpText<"Keep emitting subsequent diagnostics after a fatal error">;
|
|
|
|
def enable_cross_import_overlays : Flag<["-"], "enable-cross-import-overlays">,
|
|
HelpText<"Automatically import declared cross-import overlays.">;
|
|
def disable_cross_import_overlays : Flag<["-"], "disable-cross-import-overlays">,
|
|
HelpText<"Do not automatically import declared cross-import overlays.">;
|
|
|
|
def enable_testable_attr_requires_testable_module :
|
|
Flag<["-"], "enable-testable-attr-requires-testable-module">,
|
|
HelpText<"Enable checking of @testable">;
|
|
|
|
def disable_testable_attr_requires_testable_module :
|
|
Flag<["-"], "disable-testable-attr-requires-testable-module">,
|
|
HelpText<"Disable checking of @testable">;
|
|
|
|
def disable_clang_spi :
|
|
Flag<["-"], "disable-clang-spi">,
|
|
HelpText<"Don't import Clang SPIs as Swift SPIs">;
|
|
|
|
def enable_target_os_checking :
|
|
Flag<["-"], "enable-target-os-checking">,
|
|
HelpText<"Enable checking the target OS of serialized modules">;
|
|
|
|
def disable_target_os_checking :
|
|
Flag<["-"], "disable-target-os-checking">,
|
|
HelpText<"Disable checking the target OS of serialized modules">;
|
|
|
|
def crosscheck_unqualified_lookup : Flag<["-"], "crosscheck-unqualified-lookup">,
|
|
HelpText<"Compare legacy DeclContext- to ASTScope-based unqualified name lookup (for debugging)">;
|
|
|
|
def use_clang_function_types : Flag<["-"], "use-clang-function-types">,
|
|
HelpText<"Use stored Clang function types for computing canonical types.">;
|
|
|
|
def print_clang_stats : Flag<["-"], "print-clang-stats">,
|
|
HelpText<"Print Clang importer statistics">;
|
|
|
|
def serialize_debugging_options : Flag<["-"], "serialize-debugging-options">,
|
|
HelpText<"Always serialize options for debugging (default: only for apps)">;
|
|
|
|
def serialized_path_obfuscate : Separate<["-"], "serialized-path-obfuscate">,
|
|
HelpText<"Remap source paths in debug info">, MetaVarName<"<prefix=replacement>">;
|
|
|
|
def empty_abi_descriptor : Flag<["-"], "empty-abi-descriptor">,
|
|
HelpText<"Avoid printing actual module content into ABI descriptor file">;
|
|
|
|
def no_serialize_debugging_options :
|
|
Flag<["-"], "no-serialize-debugging-options">,
|
|
HelpText<"Never serialize options for debugging (default: only for apps)">;
|
|
|
|
def autolink_library : Separate<["-"], "autolink-library">,
|
|
HelpText<"Add dependent library">, Flags<[FrontendOption]>;
|
|
|
|
def disable_typo_correction : Flag<["-"], "disable-typo-correction">,
|
|
HelpText<"Disable typo correction">;
|
|
|
|
def disable_implicit_swift_modules: Flag<["-"], "disable-implicit-swift-modules">,
|
|
HelpText<"Disable building Swift modules implicitly by the compiler">;
|
|
|
|
def swift_module_file: Joined<["-"], "swift-module-file=">,
|
|
MetaVarName<"<name>=<path>">,
|
|
HelpText<"Specify Swift module input explicitly built from textual interface">;
|
|
|
|
def swift_module_cross_import: MultiArg<["-"], "swift-module-cross-import", 2>,
|
|
MetaVarName<"<moduleName> <crossImport.swiftoverlay>">,
|
|
HelpText<"Specify the cross import module">;
|
|
|
|
def module_can_import: Separate<["-"], "module-can-import">,
|
|
MetaVarName<"<moduleName>">,
|
|
HelpText<"Specify canImport module name">;
|
|
|
|
def module_can_import_version: MultiArg<["-"], "module-can-import-version", 3>,
|
|
MetaVarName<"<moduleName> <version> <underlyingVersion>">,
|
|
HelpText<"Specify canImport module and versions">;
|
|
|
|
def module_import_from_cas: Flag<["-"], "module-import-from-cas">,
|
|
HelpText<"Import modules from CAS instead of file system">;
|
|
|
|
def disable_cross_import_overlay_search: Flag<["-"], "disable-cross-import-overlay-search">,
|
|
HelpText<"Disable searching for cross import overlay file">;
|
|
|
|
def explicit_swift_module_map
|
|
: Separate<["-"], "explicit-swift-module-map-file">, MetaVarName<"<path>">,
|
|
HelpText<"Specify a JSON file containing information of explicit Swift modules">;
|
|
|
|
def const_gather_protocols_file
|
|
: Separate<["-"], "const-gather-protocols-file">, MetaVarName<"<path>">,
|
|
HelpText<"Specify a list of protocols for extraction of conformances' const values'">;
|
|
|
|
def import_prescan : Flag<["-"], "import-prescan">,
|
|
HelpText<"When performing a dependency scan, only identify all imports of the main Swift module sources">;
|
|
|
|
def serialize_dependency_scan_cache : Flag<["-"], "serialize-dependency-scan-cache">,
|
|
HelpText<"After performing a dependency scan, serialize the scanner's internal state.">;
|
|
|
|
def reuse_dependency_scan_cache : Flag<["-"], "load-dependency-scan-cache">,
|
|
HelpText<"For performing a dependency scan, deserialize the scanner's internal state from a prior scan.">;
|
|
|
|
def validate_prior_dependency_scan_cache : Flag<["-"], "validate-prior-dependency-scan-cache">,
|
|
HelpText<"For performing a dependency scan with a prior scanner state, validate module dependencies.">;
|
|
|
|
def dependency_scan_cache_path : Separate<["-"], "dependency-scan-cache-path">,
|
|
HelpText<"The path to output the dependency scanner's internal state.">;
|
|
|
|
def dependency_scan_cache_remarks : Flag<["-"], "Rdependency-scan-cache">,
|
|
HelpText<"Emit remarks indicating use of the serialized module dependency scanning cache.">;
|
|
|
|
def parallel_scan : Flag<["-"], "parallel-scan">,
|
|
HelpText<"Perform dependency scanning in-parallel.">;
|
|
def no_parallel_scan : Flag<["-"], "no-parallel-scan">,
|
|
HelpText<"Perform dependency scanning in a single-threaded fashion.">;
|
|
|
|
def enable_copy_propagation : Flag<["-"], "enable-copy-propagation">,
|
|
HelpText<"Always run SIL copy propagation with lexical lifetimes to shorten object "
|
|
"lifetimes while preserving variable lifetimes.">;
|
|
def copy_propagation_state_EQ :
|
|
Joined<["-"], "enable-copy-propagation=">,
|
|
HelpText<"Whether to enable copy propagation">,
|
|
MetaVarName<"always|optimizing|requested-passes-only|false">;
|
|
|
|
def disable_infer_public_concurrent_value : Flag<["-"], "disable-infer-public-sendable">,
|
|
HelpText<"Disable inference of Sendable conformances for public structs and enums">;
|
|
|
|
def Raccess_note : Separate<["-"], "Raccess-note">,
|
|
MetaVarName<"none|failures|all|all-validate">,
|
|
HelpText<"Control access note remarks (default: all)">;
|
|
def Raccess_note_EQ : Joined<["-"], "Raccess-note=">,
|
|
Alias<Raccess_note>;
|
|
} // end let Flags = [FrontendOption, NoDriverOption]
|
|
|
|
def debug_crash_Group : OptionGroup<"<automatic crashing options>">;
|
|
class DebugCrashOpt : Group<debug_crash_Group>;
|
|
|
|
let Flags = [FrontendOption, NoDriverOption, HelpHidden, ModuleInterfaceOptionIgnorable] in {
|
|
def enable_lexical_lifetimes :
|
|
Joined<["-"], "enable-lexical-lifetimes=">,
|
|
HelpText<"Whether to enable lexical lifetimes">,
|
|
MetaVarName<"true|false">;
|
|
def enable_lexical_lifetimes_noArg :
|
|
Flag<["-"], "enable-lexical-lifetimes">,
|
|
HelpText<"Enable lexical lifetimes">;
|
|
def enable_destroy_hoisting :
|
|
Joined<["-"], "enable-destroy-hoisting=">,
|
|
HelpText<"Whether to enable destroy hoisting">,
|
|
MetaVarName<"true|false">;
|
|
def formal_cxx_interoperability_mode :
|
|
Joined<["-"], "formal-cxx-interoperability-mode=">,
|
|
HelpText<"What version of C++ interoperability a textual interface was originally generated with">,
|
|
MetaVarName<"<cxx-interop-version>|off">;
|
|
def enable_assembly_vision_all
|
|
: Flag<["-"], "enable-assembly-vision-all">,
|
|
HelpText<"Enable assembly vision for all functions">;
|
|
def disable_assembly_vision_all
|
|
: Flag<["-"], "disable-assembly-vision-all">,
|
|
HelpText<"Disable assembly vision for all functions">;
|
|
}
|
|
|
|
// Flags that are saved into module interfaces
|
|
let Flags = [FrontendOption, NoDriverOption, HelpHidden, ModuleInterfaceOption] in {
|
|
def enable_objc_interop :
|
|
Flag<["-"], "enable-objc-interop">,
|
|
HelpText<"Enable Objective-C interop code generation and config directives">;
|
|
|
|
def disable_objc_interop :
|
|
Flag<["-"], "disable-objc-interop">,
|
|
HelpText<"Disable Objective-C interop code generation and config directives">;
|
|
|
|
def enable_experimental_opaque_type_erasure :
|
|
Flag<["-"], "enable-experimental-opaque-type-erasure">,
|
|
HelpText<"Type-erases opaque types that conform to @_typeEraser protocols">;
|
|
|
|
def enable_objc_attr_requires_foundation_module :
|
|
Flag<["-"], "enable-objc-attr-requires-foundation-module">,
|
|
HelpText<"Enable requiring uses of @objc to require importing the "
|
|
"Foundation module">;
|
|
|
|
def disable_objc_attr_requires_foundation_module :
|
|
Flag<["-"], "disable-objc-attr-requires-foundation-module">,
|
|
HelpText<"Disable requiring uses of @objc to require importing the "
|
|
"Foundation module">;
|
|
|
|
def enable_experimental_concurrency :
|
|
Flag<["-"], "enable-experimental-concurrency">,
|
|
HelpText<"Enable experimental concurrency model">;
|
|
|
|
def enable_experimental_move_only :
|
|
Flag<["-"], "enable-experimental-move-only">,
|
|
HelpText<"Enable experimental move only">;
|
|
|
|
def enable_experimental_distributed :
|
|
Flag<["-"], "enable-experimental-distributed">,
|
|
HelpText<"Enable experimental 'distributed' actors and functions">;
|
|
|
|
def enable_experimental_flow_sensitive_concurrent_captures :
|
|
Flag<["-"], "enable-experimental-flow-sensitive-concurrent-captures">,
|
|
HelpText<"Enable flow-sensitive concurrent captures">;
|
|
|
|
def disable_experimental_clang_importer_diagnostics :
|
|
Flag<["-"], "disable-experimental-clang-importer-diagnostics">,
|
|
HelpText<"Disable experimental diagnostics when importing C, C++, and Objective-C libraries">;
|
|
|
|
def enable_experimental_eager_clang_module_diagnostics :
|
|
Flag<["-"], "enable-experimental-eager-clang-module-diagnostics">,
|
|
HelpText<"Enable experimental eager diagnostics reporting on the importability of all referenced C, C++, and Objective-C libraries">;
|
|
|
|
def enable_experimental_pairwise_build_block :
|
|
Flag<["-"], "enable-experimental-pairwise-build-block">,
|
|
HelpText<"Enable experimental pairwise 'buildBlock' for result builders">;
|
|
|
|
def enable_resilience : Flag<["-"], "enable-resilience">,
|
|
HelpText<"Deprecated, use -enable-library-evolution instead">;
|
|
|
|
def enable_experimental_async_top_level :
|
|
Flag<["-"], "enable-experimental-async-top-level">,
|
|
HelpText<"Enable experimental concurrency in top-level code">;
|
|
|
|
def public_autolink_library :
|
|
Separate<["-"], "public-autolink-library">,
|
|
HelpText<"Add public dependent library">;
|
|
}
|
|
|
|
// HIDDEN FLAGS
|
|
let Flags = [FrontendOption, NoDriverOption, HelpHidden] in {
|
|
|
|
def checked_async_objc_bridging : Joined<["-"], "checked-async-objc-bridging=">,
|
|
HelpText<"Control whether checked continuations are used when bridging "
|
|
"async calls from Swift to ObjC: 'on', 'off' ">;
|
|
|
|
def debug_constraints : Flag<["-"], "debug-constraints">,
|
|
HelpText<"Debug the constraint-based type checker">;
|
|
|
|
def debug_constraints_attempt : Separate<["-"], "debug-constraints-attempt">,
|
|
HelpText<"Debug the constraint solver at a given attempt">;
|
|
|
|
def debug_constraints_on_line : Separate<["-"], "debug-constraints-on-line">,
|
|
HelpText<"Debug the constraint solver for expressions on <line>">,
|
|
MetaVarName<"<line>">;
|
|
def debug_constraints_on_line_EQ : Joined<["-"], "debug-constraints-on-line=">,
|
|
Alias<debug_constraints_on_line>;
|
|
|
|
def disable_named_lazy_member_loading : Flag<["-"], "disable-named-lazy-member-loading">,
|
|
HelpText<"Disable per-name lazy member loading (obsolete)">;
|
|
|
|
def disable_named_lazy_import_as_member_loading :
|
|
Flag<["-"], "disable-named-lazy-import-as-member-loading">,
|
|
HelpText<"Import all of a type's import-as-member globals together, as Swift "
|
|
"5.10 and earlier did; temporary workaround for modules that are "
|
|
"sensitive to this change">;
|
|
|
|
def dump_requirement_machine : Flag<["-"], "dump-requirement-machine">,
|
|
HelpText<"Enables dumping rewrite systems from the generics implementation">;
|
|
|
|
def debug_requirement_machine : Joined<["-"], "debug-requirement-machine=">,
|
|
HelpText<"Fine-grained debug output from the generics implementation">;
|
|
|
|
def dump_macro_expansions : Flag<["-"], "dump-macro-expansions">,
|
|
HelpText<"Dumps the results of each macro expansion">;
|
|
def emit_macro_expansion_files : Separate<["-"], "emit-macro-expansion-files">,
|
|
HelpText<"Specify when to emit macro expansion file: 'none', 'debug', or 'diagnostics'">;
|
|
|
|
def dump_source_file_imports : Flag<["-"], "dump-source-file-imports">,
|
|
HelpText<"Dumps the list of imports for each source file">;
|
|
|
|
def analyze_request_evaluator : Flag<["-"], "analyze-request-evaluator">,
|
|
Flags<[FrontendOption, HelpHidden, DoesNotAffectIncrementalBuild]>,
|
|
HelpText<"Print out request evaluator cache statistics at the end of the compilation job">;
|
|
|
|
def analyze_requirement_machine : Flag<["-"], "analyze-requirement-machine">,
|
|
Flags<[FrontendOption, HelpHidden, DoesNotAffectIncrementalBuild]>,
|
|
HelpText<"Print out requirement machine statistics at the end of the compilation job">;
|
|
|
|
def requirement_machine_max_rule_count : Joined<["-"], "requirement-machine-max-rule-count=">,
|
|
Flags<[FrontendOption, HelpHidden, DoesNotAffectIncrementalBuild]>,
|
|
HelpText<"Set the maximum number of rules before giving up">;
|
|
|
|
def requirement_machine_max_rule_length : Joined<["-"], "requirement-machine-max-rule-length=">,
|
|
Flags<[FrontendOption, HelpHidden, DoesNotAffectIncrementalBuild]>,
|
|
HelpText<"Set the maximum rule length before giving up">;
|
|
|
|
def requirement_machine_max_concrete_nesting : Joined<["-"], "requirement-machine-max-concrete-nesting=">,
|
|
Flags<[FrontendOption, HelpHidden, DoesNotAffectIncrementalBuild]>,
|
|
HelpText<"Set the maximum concrete type nesting depth before giving up">;
|
|
|
|
def requirement_machine_max_concrete_size : Joined<["-"], "requirement-machine-max-concrete-size=">,
|
|
Flags<[FrontendOption, HelpHidden, DoesNotAffectIncrementalBuild]>,
|
|
HelpText<"Set the maximum concrete type total size before giving up">;
|
|
|
|
def requirement_machine_max_type_differences : Joined<["-"], "requirement-machine-max-type-differences=">,
|
|
Flags<[FrontendOption, HelpHidden, DoesNotAffectIncrementalBuild]>,
|
|
HelpText<"Set the maximum number of type difference structures allocated before giving up">;
|
|
|
|
def requirement_machine_max_split_concrete_equiv_class_attempts : Joined<["-"], "requirement-machine-max-split-concrete-equiv-class-attempts=">,
|
|
Flags<[FrontendOption, HelpHidden, DoesNotAffectIncrementalBuild]>,
|
|
HelpText<"Set the maximum concrete number of attempts at splitting "
|
|
"concrete equivalence classes before giving up. There should "
|
|
"never be a reason to change this">;
|
|
|
|
def disable_requirement_machine_concrete_contraction : Flag<["-"], "disable-requirement-machine-concrete-contraction">,
|
|
HelpText<"Disable preprocessing pass to eliminate conformance requirements "
|
|
"on generic parameters which are made concrete">;
|
|
|
|
def disable_requirement_machine_loop_normalization : Flag<["-"], "disable-requirement-machine-loop-normalization">,
|
|
HelpText<"Disable stronger minimization algorithm, for debugging only">;
|
|
|
|
def disable_requirement_machine_reuse : Flag<["-"], "disable-requirement-machine-reuse">,
|
|
HelpText<"Disable re-use of requirement machines for minimization, for debugging only">;
|
|
|
|
def enable_requirement_machine_opaque_archetypes : Flag<["-"], "enable-requirement-machine-opaque-archetypes">,
|
|
HelpText<"Enable more correct opaque archetype support, which is off by default because it might fail to produce a convergent rewrite system">;
|
|
|
|
def max_substitution_depth : Joined<["-"], "max-substitution-depth=">,
|
|
Flags<[FrontendOption, HelpHidden, DoesNotAffectIncrementalBuild]>,
|
|
HelpText<"Set the maximum nesting depth for type substitution operations">;
|
|
|
|
def max_substitution_count : Joined<["-"], "max-substitution-count=">,
|
|
Flags<[FrontendOption, HelpHidden, DoesNotAffectIncrementalBuild]>,
|
|
HelpText<"Set the maximum step count for type substitution operations">;
|
|
|
|
def dump_type_witness_systems : Flag<["-"], "dump-type-witness-systems">,
|
|
HelpText<"Enables dumping type witness systems from associated type inference">;
|
|
|
|
def enable_round_trip_debug_types : Flag<["-"], "enable-round-trip-debug-types">,
|
|
HelpText<"Enables verification of debug info mangling">;
|
|
|
|
def disable_round_trip_debug_types : Flag<["-"], "disable-round-trip-debug-types">,
|
|
HelpText<"Disables verification of debug info mangling">;
|
|
|
|
def debug_generic_signatures : Flag<["-"], "debug-generic-signatures">,
|
|
HelpText<"Debug generic signatures">;
|
|
|
|
def debug_inverse_requirements : Flag<["-"], "debug-inverse-requirements">,
|
|
HelpText<"Print real requirements in -debug-generic-signatures output">;
|
|
|
|
def debug_forbid_typecheck_prefix : Separate<["-"], "debug-forbid-typecheck-prefix">,
|
|
HelpText<"Triggers llvm fatal_error if typechecker tries to typecheck a decl "
|
|
"with the provided prefix name">;
|
|
|
|
def experimental_lazy_typecheck : Flag<["-"], "experimental-lazy-typecheck">,
|
|
HelpText<"Type-check lazily as needed to produce requested outputs">;
|
|
|
|
def debug_emit_invalid_swiftinterface_syntax : Flag<["-"], "debug-emit-invalid-swiftinterface-syntax">,
|
|
HelpText<"Write an invalid declaration into swiftinterface files">;
|
|
|
|
def debug_cycles : Flag<["-"], "debug-cycles">,
|
|
HelpText<"Print out debug dumps when cycles are detected in evaluation">;
|
|
|
|
def debug_time_function_bodies : Flag<["-"], "debug-time-function-bodies">,
|
|
HelpText<"Dumps the time it takes to type-check each function body">;
|
|
def debug_time_expression_type_checking : Flag<["-"], "debug-time-expression-type-checking">,
|
|
HelpText<"Dumps the time it takes to type-check each expression">;
|
|
|
|
def debug_assert_immediately : Flag<["-"], "debug-assert-immediately">,
|
|
DebugCrashOpt, HelpText<"Force an assertion failure immediately">;
|
|
def debug_assert_after_parse : Flag<["-"], "debug-assert-after-parse">,
|
|
DebugCrashOpt, HelpText<"Force an assertion failure after parsing">;
|
|
def debug_crash_immediately : Flag<["-"], "debug-crash-immediately">,
|
|
DebugCrashOpt, HelpText<"Force a crash immediately">;
|
|
def debug_crash_after_parse : Flag<["-"], "debug-crash-after-parse">,
|
|
DebugCrashOpt, HelpText<"Force a crash after parsing">;
|
|
|
|
def debug_test_dependency_scan_cache_serialization: Flag<["-"], "test-dependency-scan-cache-serialization">,
|
|
HelpText<"After performing a dependency scan, serialize and then deserialize the scanner's internal state.">;
|
|
|
|
def debugger_support : Flag<["-"], "debugger-support">,
|
|
HelpText<"Process swift code as if running in the debugger">;
|
|
|
|
def disable_clangimporter_source_import : Flag<["-"],
|
|
"disable-clangimporter-source-import">,
|
|
HelpText<"Disable ClangImporter and forward all requests straight the DWARF importer.">;
|
|
|
|
def disable_const_value_importing : Flag<["-"],
|
|
"disable-const-value-importing">,
|
|
HelpText<"Disable constant value importing in ClangImporter.">;
|
|
|
|
def disable_implicit_concurrency_module_import : Flag<["-"],
|
|
"disable-implicit-concurrency-module-import">,
|
|
HelpText<"Disable the implicit import of the _Concurrency module.">;
|
|
|
|
def disable_implicit_string_processing_module_import : Flag<["-"],
|
|
"disable-implicit-string-processing-module-import">,
|
|
HelpText<"Disable the implicit import of the _StringProcessing module.">;
|
|
|
|
def disable_implicit_cxx_module_import : Flag<["-"],
|
|
"disable-implicit-cxx-module-import">,
|
|
HelpText<"Disable the implicit import of the C++ Standard Library module.">;
|
|
|
|
def disable_arc_opts : Flag<["-"], "disable-arc-opts">,
|
|
HelpText<"Don't run SIL ARC optimization passes.">;
|
|
def disable_ossa_opts : Flag<["-"], "disable-ossa-opts">,
|
|
HelpText<"Don't run SIL OSSA optimization passes.">;
|
|
|
|
def disable_sil_partial_apply : Flag<["-"], "disable-sil-partial-apply">,
|
|
HelpText<"Disable use of partial_apply in SIL generation">;
|
|
|
|
def enable_spec_devirt : Flag<["-"], "enable-spec-devirt">,
|
|
HelpText<"Deprecated, has no effect">;
|
|
|
|
def enable_async_demotion : Flag<["-"], "enable-experimental-async-demotion">,
|
|
HelpText<"Enables an optimization pass to demote async functions.">;
|
|
|
|
def enable_throws_prediction : Flag<["-"], "enable-throws-prediction">,
|
|
HelpText<"Enables optimization assumption that functions rarely throw errors.">;
|
|
def disable_throws_prediction : Flag<["-"], "disable-throws-prediction">,
|
|
HelpText<"Disables optimization assumption that functions rarely throw errors.">;
|
|
|
|
def enable_noreturn_prediction : Flag<["-"], "enable-noreturn-prediction">,
|
|
HelpText<"Enables optimization assumption that calls to no-return functions are cold.">;
|
|
def disable_noreturn_prediction : Flag<["-"], "disable-noreturn-prediction">,
|
|
HelpText<"Disables optimization assumption that calls to no-return functions are cold.">;
|
|
|
|
def disable_access_control : Flag<["-"], "disable-access-control">,
|
|
HelpText<"Don't respect access control restrictions">;
|
|
def enable_access_control : Flag<["-"], "enable-access-control">,
|
|
HelpText<"Respect access control restrictions">;
|
|
|
|
def code_complete_inits_in_postfix_expr : Flag<["-"], "code-complete-inits-in-postfix-expr">,
|
|
HelpText<"Include initializers when completing a postfix expression">;
|
|
def code_complete_call_pattern_heuristics : Flag<["-"], "code-complete-call-pattern-heuristics">,
|
|
HelpText<"Use heuristics to guess whether we want call pattern completions">;
|
|
|
|
def disable_autolink_framework : Separate<["-"],"disable-autolink-framework">,
|
|
HelpText<"Disable autolinking against the provided framework">;
|
|
|
|
def disable_autolink_library : Separate<["-"],"disable-autolink-library">,
|
|
HelpText<"Disable autolinking against the provided library">;
|
|
|
|
def disable_autolink_frameworks : Flag<["-"],"disable-autolink-frameworks">,
|
|
HelpText<"Disable autolinking against all frameworks">;
|
|
|
|
def disable_all_autolinking : Flag<["-"],"disable-all-autolinking">,
|
|
HelpText<"Disable all Swift autolink directives">;
|
|
|
|
def disable_force_load_symbols : Flag<["-"],"disable-force-load-symbols">,
|
|
Flags<[FrontendOption, HelpHidden]>,
|
|
HelpText<"Disable generation of all Swift _FORCE_LOAD symbols">;
|
|
|
|
def disable_diagnostic_passes : Flag<["-"], "disable-diagnostic-passes">,
|
|
HelpText<"Don't run diagnostic passes">;
|
|
|
|
def disable_llvm_optzns : Flag<["-"], "disable-llvm-optzns">,
|
|
HelpText<"Don't run LLVM optimization passes">;
|
|
|
|
def disable_sil_perf_optzns : Flag<["-"], "disable-sil-perf-optzns">,
|
|
HelpText<"Don't run SIL performance optimization passes">;
|
|
|
|
def disable_swift_specific_llvm_optzns : Flag<["-"], "disable-swift-specific-llvm-optzns">,
|
|
HelpText<"Don't run Swift specific LLVM optimization passes.">;
|
|
|
|
def disable_llvm_verify : Flag<["-"], "disable-llvm-verify">,
|
|
HelpText<"Don't run the LLVM IR verifier.">;
|
|
|
|
def enable_llvm_verify_each : Flag<["-"], "enable-llvm-verify-each">,
|
|
HelpText<"Run the LLVM IR verifier after every pass.">;
|
|
|
|
def disable_llvm_verify_each : Flag<["-"], "disable-llvm-verify-each">,
|
|
HelpText<"Don't run the LLVM IR verifier after every pass.">;
|
|
|
|
def disable_llvm_value_names : Flag<["-"], "disable-llvm-value-names">,
|
|
HelpText<"Don't add names to local values in LLVM IR">;
|
|
|
|
def dump_jit : JoinedOrSeparate<["-"], "dump-jit">,
|
|
HelpText<"Dump JIT contents">;
|
|
|
|
def enable_llvm_value_names : Flag<["-"], "enable-llvm-value-names">,
|
|
HelpText<"Add names to local values in LLVM IR">;
|
|
|
|
def enable_anonymous_context_mangled_names :
|
|
Flag<["-"], "enable-anonymous-context-mangled-names">,
|
|
HelpText<"Enable emission of mangled names in anonymous context descriptors">;
|
|
|
|
def disable_reflection_metadata : Flag<["-"], "disable-reflection-metadata">,
|
|
HelpText<"Disable emission of reflection metadata for nominal types">;
|
|
|
|
def reflection_metadata_for_debugger_only : Flag<["-"], "reflection-metadata-for-debugger-only">,
|
|
HelpText<"Emit reflection metadata for debugger only, don't make them available at runtime">;
|
|
|
|
def disable_reflection_names : Flag<["-"], "disable-reflection-names">,
|
|
HelpText<"Disable emission of names of stored properties and enum cases in"
|
|
"reflection metadata">;
|
|
|
|
def disable_llvm_merge_functions_pass : Flag<["-"], "disable-llvm-merge-functions-pass">,
|
|
HelpText<"Disable the MergeFunctionPass LLVM IR pass">;
|
|
|
|
def function_sections: Flag<["-"], "function-sections">,
|
|
Flags<[FrontendOption, NoInteractiveOption]>,
|
|
HelpText<"Emit functions to separate sections.">;
|
|
|
|
def enable_single_module_llvm_emission: Flag<["-"], "enable-single-module-llvm-emission">,
|
|
Flags<[FrontendOption, NoInteractiveOption]>,
|
|
HelpText<"Emit LLVM IR into a single LLVM module in multithreaded mode.">;
|
|
|
|
def emit_empty_object_file : Flag<["-"], "emit-empty-object-file">,
|
|
Flags<[FrontendOption, NoInteractiveOption]>,
|
|
HelpText<"Produce a valid but dummy object file when building a library module">;
|
|
|
|
def stack_promotion_checks : Flag<["-"], "emit-stack-promotion-checks">,
|
|
HelpText<"Emit runtime checks for correct stack promotion of objects.">;
|
|
|
|
def stack_promotion_limit : Separate<["-"], "stack-promotion-limit">,
|
|
HelpText<"Limit the size of stack promoted objects to the provided number "
|
|
"of bytes.">;
|
|
|
|
def dump_clang_diagnostics : Flag<["-"], "dump-clang-diagnostics">,
|
|
HelpText<"Dump Clang diagnostics to stderr">;
|
|
|
|
def dump_clang_lookup_tables : Flag<["-"], "dump-clang-lookup-tables">,
|
|
HelpText<"Dump the importer's Swift-name-to-Clang-name lookup tables to "
|
|
"stderr">;
|
|
|
|
def dump_availability_scopes : Flag<["-"], "dump-availability-scopes">,
|
|
HelpText<"Dump availability scopes to stderr">;
|
|
|
|
def disable_modules_validate_system_headers : Flag<["-"], "disable-modules-validate-system-headers">,
|
|
HelpText<"Disable validating system headers in the Clang importer">;
|
|
|
|
def emit_verbose_sil : Flag<["-"], "emit-verbose-sil">,
|
|
HelpText<"Emit locations during SIL emission">;
|
|
|
|
def emit_pch : Flag<["-"], "emit-pch">,
|
|
HelpText<"Emit PCH for imported Objective-C header file">, ModeOpt;
|
|
|
|
def pch_disable_validation : Flag<["-"], "pch-disable-validation">,
|
|
HelpText<"Disable validating the persistent PCH">;
|
|
|
|
def version_independent_apinotes : Flag<["-"], "version-independent-apinotes">,
|
|
HelpText<"Input clang modules carry all versioned APINotes">;
|
|
|
|
def disable_sil_ownership_verifier : Flag<["-"], "disable-sil-ownership-verifier">,
|
|
HelpText<"Do not verify ownership invariants during SIL Verification ">;
|
|
|
|
def suppress_static_exclusivity_swap : Flag<["-"], "suppress-static-exclusivity-swap">,
|
|
HelpText<"Suppress static violations of exclusive access with swap()">;
|
|
|
|
def enable_experimental_static_assert :
|
|
Flag<["-"], "enable-experimental-static-assert">,
|
|
HelpText<"Enable experimental #assert">;
|
|
|
|
def disable_subst_sil_function_types :
|
|
Flag<["-"], "disable-subst-sil-function-types">,
|
|
HelpText<"Disable substituted function types for SIL type lowering of function values">;
|
|
|
|
def enable_experimental_named_opaque_types :
|
|
Flag<["-"], "enable-experimental-named-opaque-types">,
|
|
HelpText<"Enable experimental support for named opaque result types">;
|
|
|
|
def enable_explicit_existential_types :
|
|
Flag<["-"], "enable-explicit-existential-types">,
|
|
HelpText<"Enable experimental support for explicit existential types">;
|
|
|
|
def enable_experimental_opened_existential_types :
|
|
Flag<["-"], "enable-experimental-opened-existential-types">,
|
|
HelpText<"Enable experimental support for implicitly opened existentials">;
|
|
|
|
def disable_experimental_opened_existential_types :
|
|
Flag<["-"], "disable-experimental-opened-existential-types">,
|
|
HelpText<"Disable experimental support for implicitly opened existentials">;
|
|
|
|
def enable_deserialization_recovery :
|
|
Flag<["-"], "enable-deserialization-recovery">,
|
|
HelpText<"Attempt to recover from missing xrefs (etc) in swiftmodules">;
|
|
def disable_deserialization_recovery :
|
|
Flag<["-"], "disable-deserialization-recovery">,
|
|
HelpText<"Don't attempt to recover from missing xrefs (etc) in swiftmodules">;
|
|
|
|
def enable_deserialization_safety :
|
|
Flag<["-"], "enable-deserialization-safety">,
|
|
HelpText<"Avoid reading potentially unsafe decls in swiftmodules">;
|
|
def disable_deserialization_safety :
|
|
Flag<["-"], "disable-deserialization-safety">,
|
|
HelpText<"Don't avoid reading potentially unsafe decls in swiftmodules">;
|
|
|
|
def force_workaround_broken_modules :
|
|
Flag<["-"], "experimental-force-workaround-broken-modules">,
|
|
HelpText<"Attempt unsafe recovery for imported modules with broken modularization">;
|
|
|
|
def enable_experimental_string_processing :
|
|
Flag<["-"], "enable-experimental-string-processing">,
|
|
HelpText<"Enable experimental string processing">;
|
|
def disable_experimental_string_processing :
|
|
Flag<["-"], "disable-experimental-string-processing">,
|
|
HelpText<"Disable experimental string processing">;
|
|
|
|
def enable_experimental_lifetime_dependence_inference :
|
|
Flag<["-"], "enable-experimental-lifetime-dependence-inference">,
|
|
HelpText<"Enable experimental lifetime dependence inference">;
|
|
|
|
def disable_experimental_lifetime_dependence_inference :
|
|
Flag<["-"], "disable-experimental-lifetime-dependence-inference">,
|
|
HelpText<"Disable experimental lifetime dependence inference">;
|
|
|
|
def disable_availability_checking : Flag<["-"],
|
|
"disable-availability-checking">,
|
|
HelpText<"Disable checking for potentially unavailable APIs">;
|
|
|
|
def warn_on_potentially_unavailable_enum_case : Flag<["-"],
|
|
"warn-on-potentially-unavailable-enum-case">,
|
|
HelpText<"Deprecated, will be removed in future versions">;
|
|
|
|
def warn_on_editor_placeholder : Flag<["-"],
|
|
"warn-on-editor-placeholder">,
|
|
HelpText<"Downgrade the editor placeholder error to a warning">;
|
|
|
|
def report_errors_to_debugger : Flag<["-"], "report-errors-to-debugger">,
|
|
HelpText<"Deprecated, will be removed in future versions.">;
|
|
|
|
def enable_swift3_objc_inference : Flag<["-"], "enable-swift3-objc-inference">,
|
|
Flags<[FrontendOption, HelpHidden]>,
|
|
HelpText<"Deprecated, has no effect">;
|
|
|
|
def disable_swift3_objc_inference :
|
|
Flag<["-"], "disable-swift3-objc-inference">,
|
|
Flags<[FrontendOption, HelpHidden]>,
|
|
HelpText<"Deprecated, has no effect">;
|
|
|
|
def enable_implicit_dynamic : Flag<["-"], "enable-implicit-dynamic">,
|
|
Flags<[FrontendOption, NoInteractiveOption, HelpHidden]>,
|
|
HelpText<"Add 'dynamic' to all declarations">;
|
|
|
|
def bypass_resilience : Flag<["-"], "bypass-resilience-checks">,
|
|
Flags<[FrontendOption, NoInteractiveOption, HelpHidden]>,
|
|
HelpText<"Ignore all checks for module resilience.">;
|
|
|
|
def enable_llvm_vfe : Flag<["-"], "enable-llvm-vfe">,
|
|
Flags<[FrontendOption, NoInteractiveOption, HelpHidden]>,
|
|
HelpText<"Use LLVM IR Virtual Function Elimination on Swift class virtual tables">;
|
|
|
|
def enable_llvm_wme : Flag<["-"], "enable-llvm-wme">,
|
|
Flags<[FrontendOption, NoInteractiveOption, HelpHidden]>,
|
|
HelpText<"Use LLVM IR Witness Method Elimination on Swift protocol witness tables">;
|
|
|
|
def internalize_at_link : Flag<["-"], "internalize-at-link">,
|
|
Flags<[FrontendOption, NoInteractiveOption, HelpHidden]>,
|
|
HelpText<"Allow internalizing public symbols and vtables at link time (assume"
|
|
" all client code of public types is part of the same link unit, or that"
|
|
" external symbols are explicitly requested via -exported_symbols_list)">;
|
|
|
|
def conditional_runtime_records : Flag<["-"], "conditional-runtime-records">,
|
|
Flags<[FrontendOption, NoInteractiveOption, HelpHidden]>,
|
|
HelpText<"Allow removal of runtime metadata records (public types, protocol conformances) based on whether they're used or unused">;
|
|
|
|
def mergeable_symbols : Flag<["-"], "mergeable-symbols">,
|
|
Flags<[FrontendOption, NoInteractiveOption, HelpHidden]>,
|
|
HelpText<"Emit symbol definitions as mergeable (linkonce_odr)">;
|
|
|
|
def disable_preallocated_instantiation_caches : Flag<["-"], "disable-preallocated-instantiation-caches">,
|
|
Flags<[FrontendOption, NoInteractiveOption, HelpHidden]>,
|
|
HelpText<"Avoid preallocating metadata instantiation caches in globals">;
|
|
|
|
def disable_readonly_static_objects : Flag<["-"], "disable-readonly-static-objects">,
|
|
Flags<[FrontendOption, NoInteractiveOption, HelpHidden]>,
|
|
HelpText<"Avoid allocating static objects in a read-only data section">;
|
|
|
|
def trap_function
|
|
: Separate<["-"], "trap-function">, MetaVarName<"<name>">,
|
|
HelpText<"Lower traps to calls to this function instead of trap instructions">;
|
|
|
|
def disable_previous_implementation_calls_in_dynamic_replacements :
|
|
Flag<["-"], "disable-previous-implementation-calls-in-dynamic-replacements">,
|
|
Flags<[FrontendOption, NoInteractiveOption, HelpHidden]>,
|
|
HelpText<"Disable calling the previous implementation in dynamic replacements">;
|
|
|
|
def enable_dynamic_replacement_chaining :
|
|
Flag<["-"], "enable-dynamic-replacement-chaining">,
|
|
Flags<[FrontendOption, NoInteractiveOption, HelpHidden]>,
|
|
HelpText<"Enable chaining of dynamic replacements">;
|
|
|
|
def enable_nskeyedarchiver_diagnostics :
|
|
Flag<["-"], "enable-nskeyedarchiver-diagnostics">,
|
|
HelpText<"Diagnose classes with unstable mangled names adopting NSCoding">;
|
|
def disable_nskeyedarchiver_diagnostics :
|
|
Flag<["-"], "disable-nskeyedarchiver-diagnostics">,
|
|
HelpText<"Allow classes with unstable mangled names to adopt NSCoding">;
|
|
|
|
def enable_nonfrozen_enum_exhaustivity_diagnostics :
|
|
Flag<["-"], "enable-nonfrozen-enum-exhaustivity-diagnostics">,
|
|
HelpText<"Diagnose switches over non-frozen enums without catch-all cases">;
|
|
def disable_nonfrozen_enum_exhaustivity_diagnostics :
|
|
Flag<["-"], "disable-nonfrozen-enum-exhaustivity-diagnostics">,
|
|
HelpText<"Allow switches over non-frozen enums without catch-all cases">;
|
|
|
|
def warn_long_function_bodies : Separate<["-"], "warn-long-function-bodies">,
|
|
MetaVarName<"<n>">,
|
|
HelpText<"Warns when type-checking a function takes longer than <n> ms">;
|
|
def warn_long_function_bodies_EQ : Joined<["-"], "warn-long-function-bodies=">,
|
|
Alias<warn_long_function_bodies>;
|
|
|
|
def warn_long_expression_type_checking : Separate<["-"], "warn-long-expression-type-checking">,
|
|
MetaVarName<"<n>">,
|
|
HelpText<"Warns when type-checking an expression takes longer than <n> ms">;
|
|
def warn_long_expression_type_checking_EQ : Joined<["-"], "warn-long-expression-type-checking=">,
|
|
Alias<warn_long_expression_type_checking>;
|
|
|
|
def Rmodule_interface_rebuild : Flag<["-"], "Rmodule-interface-rebuild">,
|
|
HelpText<"Emits a remark if an imported module needs to be re-compiled from its module interface">;
|
|
|
|
def downgrade_typecheck_interface_error : Flag<["-"], "downgrade-typecheck-interface-error">,
|
|
HelpText<"Downgrade error to warning when typechecking emitted module interfaces">;
|
|
|
|
def enable_volatile_modules : Flag<["-"], "enable-volatile-modules">,
|
|
HelpText<"Load Swift modules in memory">;
|
|
|
|
def solver_memory_threshold_EQ : Joined<["-"], "solver-memory-threshold=">,
|
|
HelpText<"Set the upper bound for memory consumption, in bytes, by the constraint solver">;
|
|
|
|
def solver_expression_time_threshold_EQ : Joined<["-"], "solver-expression-time-threshold=">,
|
|
HelpText<"Expression type checking timeout, in seconds">;
|
|
|
|
def solver_scope_threshold_EQ : Joined<["-"], "solver-scope-threshold=">,
|
|
HelpText<"Expression type checking scope limit">;
|
|
|
|
def solver_trail_threshold_EQ : Joined<["-"], "solver-trail-threshold=">,
|
|
HelpText<"Expression type checking trail change limit">;
|
|
|
|
def solver_disable_prepared_overloads : Flag<["-"], "solver-disable-prepared-overloads">,
|
|
HelpText<"Disable experimental prepared overloads optimization">;
|
|
|
|
def solver_enable_prepared_overloads : Flag<["-"], "solver-enable-prepared-overloads">,
|
|
HelpText<"Enable experimental prepared overloads optimization">;
|
|
|
|
def solver_disable_splitter : Flag<["-"], "solver-disable-splitter">,
|
|
HelpText<"Disable the component splitter phase of expression type checking">;
|
|
|
|
def enable_constraint_solver_performance_hacks : Flag<["-"], "enable-constraint-solver-performance-hacks">,
|
|
HelpText<"Enable all the old hacks in the constraint solver">;
|
|
|
|
def enable_operator_designated_types :
|
|
Flag<["-"], "enable-operator-designated-types">,
|
|
HelpText<"Enable operator designated types">;
|
|
|
|
def enable_invalid_ephemeralness_as_error :
|
|
Flag<["-"], "enable-invalid-ephemeralness-as-error">,
|
|
HelpText<"Diagnose invalid ephemeral to non-ephemeral conversions as errors">;
|
|
|
|
def disable_invalid_ephemeralness_as_error :
|
|
Flag<["-"], "disable-invalid-ephemeralness-as-error">,
|
|
HelpText<"Diagnose invalid ephemeral to non-ephemeral conversions as warnings">;
|
|
|
|
def switch_checking_invocation_threshold_EQ : Joined<["-"],
|
|
"switch-checking-invocation-threshold=">;
|
|
|
|
def dynamic_member_lookup_depth_limit_EQ
|
|
: Joined<["-"], "dynamic-member-lookup-depth-limit=">,
|
|
HelpText<
|
|
"The maximum number of dynamic member lookups that can be chained "
|
|
"to resolve a member reference">;
|
|
|
|
def enable_new_operator_lookup :
|
|
Flag<["-"], "enable-new-operator-lookup">,
|
|
HelpText<"Enable the new operator decl and precedencegroup lookup behavior">;
|
|
|
|
def disable_new_operator_lookup :
|
|
Flag<["-"], "disable-new-operator-lookup">,
|
|
HelpText<"Disable the new operator decl and precedencegroup lookup behavior">;
|
|
|
|
def enable_source_import : Flag<["-"], "enable-source-import">,
|
|
HelpText<"Enable importing of Swift source files">;
|
|
|
|
def enable_throw_without_try : Flag<["-"], "enable-throw-without-try">,
|
|
HelpText<"Allow throwing function calls without 'try'">;
|
|
|
|
def throws_as_traps : Flag<["-"], "throws-as-traps">,
|
|
HelpText<"Turn all throw sites into immediate traps">;
|
|
|
|
def import_module : Separate<["-"], "import-module">,
|
|
HelpText<"Implicitly import the specified module">;
|
|
|
|
def testable_import_module : Separate<["-"], "testable-import-module">,
|
|
HelpText<"Implicitly import the specified module with @testable">;
|
|
|
|
def print_stats : Flag<["-"], "print-stats">,
|
|
HelpText<"Print various statistics">;
|
|
|
|
def check_onone_completeness : Flag<["-"], "check-onone-completeness">,
|
|
HelpText<"Print errors if the compile OnoneSupport module is missing symbols">;
|
|
|
|
def debugger_testing_transform : Flag<["-"], "debugger-testing-transform">,
|
|
HelpText<"Instrument the code with calls to an intrinsic that record the expected values of "
|
|
"local variables so they can be compared against the results from the debugger.">;
|
|
|
|
def disable_debugger_shadow_copies : Flag<["-"], "disable-debugger-shadow-copies">,
|
|
HelpText<"Disable debugger shadow copies of local variables."
|
|
"This option is only useful for testing the compiler.">,
|
|
Flags<[FrontendOption, HelpHidden]>;
|
|
|
|
def disable_concrete_type_metadata_mangled_name_accessors : Flag<["-"], "disable-concrete-type-metadata-mangled-name-accessors">,
|
|
HelpText<"Disable concrete type metadata access by mangled name">,
|
|
Flags<[FrontendOption, HelpHidden]>;
|
|
|
|
def disable_standard_substitutions_in_reflection_mangling : Flag<["-"], "disable-standard-substitutions-in-reflection-mangling">,
|
|
HelpText<"Disable referencing stdlib symbols via mangled names in reflection mangling">,
|
|
Flags<[FrontendOption, HelpHidden]>;
|
|
|
|
def playground : Flag<["-"], "playground">,
|
|
HelpText<"Apply the playground semantics and transformation">;
|
|
|
|
def playground_option : Separate<["-"], "playground-option">,
|
|
Flags<[FrontendOption]>,
|
|
HelpText<"Provide an option to the playground transform (if enabled)">;
|
|
|
|
def playground_high_performance : Flag<["-"], "playground-high-performance">,
|
|
HelpText<"Omit instrumentation that has a high runtime performance impact">;
|
|
|
|
def disable_playground_transform : Flag<["-"], "disable-playground-transform">,
|
|
HelpText<"Disable playground transformation">;
|
|
|
|
def pc_macro : Flag<["-"], "pc-macro">,
|
|
HelpText<"Apply the 'program counter simulation' macro">;
|
|
|
|
def no_clang_module_breadcrumbs : Flag<["-"], "no-clang-module-breadcrumbs">,
|
|
HelpText<"Don't emit DWARF skeleton CUs for imported Clang modules. "
|
|
"Use this when building a redistributable static archive.">;
|
|
|
|
def use_jit : Flag<["-"], "use-jit">,
|
|
HelpText<"Register Objective-C classes as if the JIT were in use">;
|
|
|
|
def sil_inline_threshold : Separate<["-"], "sil-inline-threshold">,
|
|
MetaVarName<"<50>">,
|
|
HelpText<"Controls the aggressiveness of performance inlining">;
|
|
|
|
def sil_inline_caller_benefit_reduction_factor : Separate<["-"], "sil-inline-caller-benefit-reduction-factor">,
|
|
MetaVarName<"<2>">,
|
|
HelpText<"Controls the aggressiveness of performance inlining in -Osize "
|
|
"mode by reducing the base benefits of a caller (lower value "
|
|
"permits more inlining!)">;
|
|
|
|
def sil_unroll_threshold : Separate<["-"], "sil-unroll-threshold">,
|
|
MetaVarName<"<250>">,
|
|
HelpText<"Controls the aggressiveness of loop unrolling">;
|
|
|
|
def sil_verify_all : Flag<["-"], "sil-verify-all">,
|
|
HelpText<"Verify SIL after each transform">;
|
|
|
|
def sil_verify_none : Flag<["-"], "sil-verify-none">,
|
|
HelpText<"Completely disable SIL verification">;
|
|
|
|
def sil_ownership_verify_all : Flag<["-"], "sil-ownership-verify-all">,
|
|
HelpText<"Verify ownership after each transform">;
|
|
|
|
def verify_all_substitution_maps : Flag<["-"], "verify-all-substitution-maps">,
|
|
HelpText<"Verify all SubstitutionMaps on construction">;
|
|
|
|
def sil_debug_serialization : Flag<["-"], "sil-debug-serialization">,
|
|
HelpText<"Do not eliminate functions in Mandatory Inlining/SILCombine dead "
|
|
"functions. (for debugging only)">;
|
|
|
|
def sil_stop_optzns_before_lowering_ownership :
|
|
Flag<["-"], "sil-stop-optzns-before-lowering-ownership">,
|
|
HelpText<"Stop optimizing at SIL time before we lower ownership from SIL. "
|
|
"Intended only for SIL ossa tests">;
|
|
|
|
def print_inst_counts : Flag<["-"], "print-inst-counts">,
|
|
HelpText<"Before IRGen, count all the various SIL instructions. Must be used "
|
|
"in conjunction with -print-stats.">;
|
|
|
|
def debug_on_sil : Flag<["-"], "sil-based-debuginfo">,
|
|
HelpText<"Write the SIL into a file and generate debug-info to debug on SIL "
|
|
" level.">;
|
|
def legacy_gsil : Flag<["-"], "gsil">,
|
|
HelpText<"Deprecated, use '-sil-based-debuginfo' instead">;
|
|
|
|
def print_llvm_inline_tree : Flag<["-"], "print-llvm-inline-tree">,
|
|
HelpText<"Print the LLVM inline tree.">;
|
|
|
|
def disable_incremental_llvm_codegeneration :
|
|
Flag<["-"], "disable-incremental-llvm-codegen">,
|
|
HelpText<"Disable incremental llvm code generation.">;
|
|
|
|
def ignore_always_inline : Flag<["-"], "ignore-always-inline">,
|
|
HelpText<"Ignore @inline(__always) attributes.">;
|
|
|
|
def emit_sorted_sil : Flag<["-"], "emit-sorted-sil">,
|
|
HelpText<"When printing SIL, print out all sil entities sorted by name to "
|
|
"ease diffing">;
|
|
|
|
def cxx_interop_getters_setters_as_properties :
|
|
Flag<["-"], "cxx-interop-getters-setters-as-properties">,
|
|
HelpText<"Import getters and setters as computed properties in Swift">,
|
|
Flags<[FrontendOption, HelpHidden]>;
|
|
|
|
def cxx_interop_disable_requirement_at_import :
|
|
Flag<["-"], "disable-cxx-interop-requirement-at-import">,
|
|
HelpText<"Do not require C++ interoperability to be enabled when importing a Swift module that enables C++ interoperability">,
|
|
Flags<[FrontendOption, HelpHidden]>;
|
|
|
|
def cxx_interop_use_opaque_pointer_for_moveonly :
|
|
Flag<["-"], "cxx-interop-use-opaque-pointer-for-moveonly">,
|
|
HelpText<"Testing flag that will be eliminated soon. Do not use.">,
|
|
Flags<[FrontendOption, HelpHidden]>;
|
|
|
|
def use_malloc : Flag<["-"], "use-malloc">,
|
|
HelpText<"Allocate internal data structures using malloc "
|
|
"(for memory debugging)">;
|
|
|
|
def interpret : Flag<["-"], "interpret">, HelpText<"Immediate mode">, ModeOpt;
|
|
|
|
def verify_type_layout : JoinedOrSeparate<["-"], "verify-type-layout">,
|
|
HelpText<"Verify compile-time and runtime type layout information for type">,
|
|
MetaVarName<"<type>">;
|
|
|
|
def external_pass_pipeline_filename : Separate<["-"], "external-pass-pipeline-filename">,
|
|
HelpText<"Use the pass pipeline defined by <pass_pipeline_file>">,
|
|
MetaVarName<"<pass_pipeline_file>">;
|
|
|
|
def index_system_modules : Flag<["-"], "index-system-modules">,
|
|
HelpText<"Emit index data for imported serialized swift system modules">;
|
|
|
|
def index_ignore_stdlib :
|
|
Flag<["-"], "index-ignore-stdlib">,
|
|
HelpText<"Avoid emitting index data for the standard library.">;
|
|
|
|
def dump_interface_hash : Flag<["-"], "dump-interface-hash">,
|
|
HelpText<"Parse input file(s) and dump interface token hash(es)">,
|
|
ModeOpt;
|
|
|
|
def compile_module_from_interface :
|
|
Flag<["-"], "compile-module-from-interface">,
|
|
HelpText<"Treat the (single) input as a swiftinterface and produce a module">,
|
|
ModeOpt;
|
|
|
|
def explicit_interface_module_build :
|
|
Flag<["-"], "explicit-interface-module-build">,
|
|
HelpText<"Use the specified command-line to build the module from interface, instead of flags specified in the interface">;
|
|
|
|
def direct_clang_cc1_module_build :
|
|
Flag<["-"], "direct-clang-cc1-module-build">,
|
|
HelpText<"Use the specified -Xcc options to build a PCM by using Clang frontend directly, bypassing the Clang driver">;
|
|
|
|
def build_module_from_parseable_interface :
|
|
Flag<["-"], "build-module-from-parseable-interface">,
|
|
Alias<compile_module_from_interface>,
|
|
ModeOpt;
|
|
|
|
def typecheck_module_from_interface :
|
|
Flag<["-"], "typecheck-module-from-interface">,
|
|
HelpText<"Treat the (single) input as a swiftinterface and typecheck it">,
|
|
ModeOpt;
|
|
|
|
def module_interface_preserve_types_as_written :
|
|
Flag<["-"], "module-interface-preserve-types-as-written">,
|
|
HelpText<"When emitting a module interface, preserve types as they were "
|
|
"written in the source">;
|
|
|
|
def alias_module_names_in_module_interface :
|
|
Flag<["-"], "alias-module-names-in-module-interface">,
|
|
HelpText<"When emitting a module interface, disambiguate modules using "
|
|
"distinct alias names">;
|
|
def disable_alias_module_names_in_module_interface :
|
|
Flag<["-"], "disable-alias-module-names-in-module-interface">,
|
|
HelpText<"When emitting a module interface, disable disambiguating modules "
|
|
"using distinct alias names">;
|
|
|
|
def experimental_spi_imports :
|
|
Flag<["-"], "experimental-spi-imports">,
|
|
HelpText<"Enable experimental support for SPI imports">;
|
|
|
|
def disable_print_missing_imports_in_module_interface :
|
|
Flag<["-"], "disable-print-missing-imports-in-module-interface">,
|
|
HelpText<"Disable adding to the module interface imports used from API and "
|
|
"missing from the sources">;
|
|
|
|
// [FIXME: Clang-type-plumbing] Make this a SIL-only option once we start
|
|
// unconditionally emitting non-canonical Clang types in swiftinterfaces.
|
|
def experimental_print_full_convention :
|
|
Flag<["-"], "experimental-print-full-convention">,
|
|
HelpText<"When emitting a module interface or SIL, emit additional @convention"
|
|
" arguments, regardless of whether they were written in the source."
|
|
" Also requires -use-clang-function-types to be enabled.">;
|
|
|
|
def force_public_linkage : Flag<["-"], "force-public-linkage">,
|
|
HelpText<"Force public linkage for private symbols. Used by LLDB.">;
|
|
|
|
def diagnostics_editor_mode : Flag<["-"], "diagnostics-editor-mode">,
|
|
HelpText<"Diagnostics will be used in editor">;
|
|
|
|
def validate_tbd_against_ir_EQ: Joined<["-"], "validate-tbd-against-ir=">,
|
|
HelpText<"Compare the symbols in the IR against the TBD file that would be generated.">,
|
|
MetaVarName<"<level>">;
|
|
|
|
def bypass_batch_mode_checks: Flag<["-"], "bypass-batch-mode-checks">,
|
|
HelpText<"Bypass checks for batch-mode errors.">;
|
|
|
|
def enable_verify_exclusivity : Flag<["-"], "enable-verify-exclusivity">,
|
|
HelpText<"Enable verification of access markers used to enforce exclusivity.">;
|
|
|
|
def disable_verify_exclusivity : Flag<["-"], "disable-verify-exclusivity">,
|
|
HelpText<"Disable verification of access markers used to enforce exclusivity.">;
|
|
|
|
def disable_legacy_type_info : Flag<["-"], "disable-legacy-type-info">,
|
|
HelpText<"Completely disable legacy type layout">;
|
|
|
|
def disable_generic_metadata_prespecialization : Flag<["-"], "disable-generic-metadata-prespecialization">,
|
|
HelpText<"Do not statically specialize metadata for generic types at types "
|
|
"that are known to be used in source.">;
|
|
|
|
def prespecialize_generic_metadata : Flag<["-"], "prespecialize-generic-metadata">,
|
|
HelpText<"Statically specialize metadata for generic types at types that "
|
|
"are known to be used in source.">;
|
|
|
|
def emit_singleton_metadata_pointer : Flag<["-"], "emit-singleton-metadata-pointer">,
|
|
HelpText<"Emit a pointer to the corresponding type metadata into non-public "
|
|
"non-generic type descriptors.">;
|
|
|
|
def read_legacy_type_info_path_EQ : Joined<["-"], "read-legacy-type-info-path=">,
|
|
HelpText<"Read legacy type layout from the given path instead of default path">;
|
|
|
|
def type_info_dump_filter_EQ : Joined<["-"], "type-info-dump-filter=">,
|
|
Flags<[FrontendOption]>,
|
|
HelpText<"One of 'all', 'resilient' or 'fragile'">;
|
|
|
|
def swift_async_frame_pointer_EQ : Joined<["-"], "swift-async-frame-pointer=">,
|
|
Flags<[FrontendOption]>,
|
|
HelpText<"One of 'auto', 'always' or 'never'">;
|
|
|
|
def previous_module_installname_map_file
|
|
: Separate<["-"], "previous-module-installname-map-file">, MetaVarName<"<path>">,
|
|
HelpText<"Path to a Json file indicating module name to installname map for @_originallyDefinedIn">;
|
|
|
|
def enable_type_layouts : Flag<["-"], "enable-type-layout">,
|
|
HelpText<"Enable type layout based lowering">;
|
|
|
|
def disable_type_layouts : Flag<["-"], "disable-type-layout">,
|
|
HelpText<"Disable type layout based lowering">;
|
|
|
|
def force_struct_type_layouts : Flag<["-"], "force-struct-type-layouts">,
|
|
HelpText<"Force type layout based lowering for structs">;
|
|
|
|
def enable_layout_string_value_witnesses : Flag<["-"], "enable-layout-string-value-witnesses">,
|
|
HelpText<"Enable layout string based value witnesses">;
|
|
|
|
def enable_large_loadable_types_reg2mem : Flag<["-"], "enable-large-loadable-types-reg2mem">,
|
|
HelpText<"Enable large loadable types register to memory pass">;
|
|
|
|
def disable_large_loadable_types_reg2mem : Flag<["-"], "disable-large-loadable-types-reg2mem">,
|
|
HelpText<"Disable large loadable types register to memory pass">;
|
|
|
|
def enable_x86_64_corocc : Flag<["-"], "enable-x86_64-corocc">,
|
|
HelpText<"Use swiftcorocc for yield_once_2 routines on x86_64.">;
|
|
|
|
def disable_x86_64_corocc : Flag<["-"], "disable-x86_64-corocc">,
|
|
HelpText<"Don't use swiftcorocc for yield_once_2 routines on x86_64.">;
|
|
|
|
def enable_arm64_corocc : Flag<["-"], "enable-arm64-corocc">,
|
|
HelpText<"Use swiftcorocc for yield_once_2 routines on arm64 variants.">;
|
|
|
|
def disable_arm64_corocc : Flag<["-"], "disable-arm64-corocc">,
|
|
HelpText<"Don't use swiftcorocc for yield_once_2 routines on arm64 variants.">;
|
|
|
|
def enable_callee_allocated_coro_abi : Flag<["-"], "enable-callee-allocated-coro-abi">,
|
|
HelpText<"Override per-platform settings and use yield_once_2.">;
|
|
|
|
def disable_callee_allocated_coro_abi : Flag<["-"], "disable-callee-allocated-coro-abi">,
|
|
HelpText<"Override per-platform settings and don't use yield_once_2.">;
|
|
|
|
def enable_cond_fail_message_annotation : Flag<["-"], "enable-cond-fail-message-annotation">,
|
|
HelpText<"Enable cond_fail message annotation. Will serialize a .o.yaml file per .o file.">;
|
|
|
|
def disable_cond_fail_message_annotation : Flag<["-"], "dissable-cond-fail-message-annotation">,
|
|
HelpText<"Disable cond_fail message annotation.">;
|
|
|
|
def min_valid_pointer_value : Joined<["-"], "min-valid-pointer-value=">,
|
|
MetaVarName<"<value>">,
|
|
HelpText<"Overrides the target's least valid pointer value.'">;
|
|
|
|
let Flags = [FrontendOption, NoDriverOption, HelpHidden, ModuleInterfaceOptionIgnorable] in {
|
|
def enable_pack_metadata_stack_promotion :
|
|
Joined<["-"], "enable-pack-metadata-stack-promotion=">,
|
|
HelpText<"Whether to skip heapifying stack metadata packs when possible.">,
|
|
MetaVarName<"true|false">;
|
|
def enable_pack_metadata_stack_promotion_noArg :
|
|
Flag<["-"], "enable-pack-metadata-stack-promotion">,
|
|
HelpText<"Skip heapifying stack metadata packs when possible.">;
|
|
}
|
|
|
|
def disable_layout_string_value_witnesses : Flag<["-"], "disable-layout-string-value-witnesses">,
|
|
HelpText<"Disable layout string based value witnesses">;
|
|
|
|
def enable_layout_string_value_witnesses_instantiation : Flag<["-"], "enable-layout-string-value-witnesses-instantiation">,
|
|
HelpText<"Enable runtime instantiation of layout string value witnesses for generic types">;
|
|
|
|
def disable_layout_string_value_witnesses_instantiation : Flag<["-"], "disable-layout-string-value-witnesses-instantiation">,
|
|
HelpText<"Disable runtime instantiation of layout string value witnesses for generic types">;
|
|
|
|
def disable_interface_lockfile : Flag<["-"], "disable-interface-lock">,
|
|
HelpText<"Don't lock interface file when building module">;
|
|
|
|
def bridging_header_directory_for_print: Separate<["-"], "bridging-header-directory-for-print">, MetaVarName<"<path>">,
|
|
HelpText<"Directory for bridging header to be printed in compatibility header">;
|
|
|
|
def entry_point_function_name: Separate<["-"], "entry-point-function-name">, MetaVarName<"<string>">,
|
|
HelpText<"Name of the entry point function">;
|
|
|
|
def target_sdk_version : Separate<["-"], "target-sdk-version">,
|
|
HelpText<"The version of target SDK used for compilation">;
|
|
|
|
def target_variant_sdk_version : Separate<["-"], "target-variant-sdk-version">,
|
|
HelpText<"The version of target variant SDK used for compilation">;
|
|
|
|
def target_sdk_name : Separate<["-"], "target-sdk-name">,
|
|
HelpText<"Canonical name of the target SDK used for compilation">;
|
|
|
|
def candidate_module_file
|
|
: Separate<["-"], "candidate-module-file">, MetaVarName<"<path>">,
|
|
HelpText<"Specify Swift module may be ready to use for an interface">;
|
|
|
|
def use_static_resource_dir
|
|
: Flag<["-"], "use-static-resource-dir">,
|
|
HelpText<"Use resources in the static resource directory">;
|
|
|
|
def disable_building_interface
|
|
: Flag<["-"], "disable-building-interface">,
|
|
HelpText<"Disallow building binary module from textual interface">;
|
|
|
|
def experimental_skip_all_function_bodies:
|
|
Flag<["-"], "experimental-skip-all-function-bodies">,
|
|
HelpText<"Skip type-checking function bodies and all SIL generation">;
|
|
|
|
def experimental_allow_module_with_compiler_errors:
|
|
Flag<["-"], "experimental-allow-module-with-compiler-errors">,
|
|
Flags<[HelpHidden]>,
|
|
HelpText<"Attempt to output .swiftmodule, regardless of compilation errors">;
|
|
|
|
def experimental_skip_non_exportable_decls
|
|
: Flag<["-"], "experimental-skip-non-exportable-decls">,
|
|
HelpText<"Skip decls that are not exported to clients">;
|
|
|
|
def bad_file_descriptor_retry_count:
|
|
Separate<["-"], "bad-file-descriptor-retry-count">,
|
|
HelpText<"Number of retrying opening a file if previous open returns a bad "
|
|
"file descriptor error.">;
|
|
|
|
def enable_ast_verifier : Flag<["-"], "enable-ast-verifier">,
|
|
HelpText<"Run the AST verifier during compilation. NOTE: This lets the user "
|
|
"override the default behavior on whether or not the ASTVerifier "
|
|
"is run. The default behavior is to run the verifier when asserts "
|
|
"are enabled and not run it when asserts are disabled. NOTE: "
|
|
"Can not be used if disable-ast-verifier is used as well">;
|
|
|
|
def disable_ast_verifier : Flag<["-"], "disable-ast-verifier">,
|
|
HelpText<"Do not run the AST verifier during compilation. NOTE: This lets "
|
|
"the user override the default behavior on whether or not the "
|
|
"ASTVerifier is run. The default behavior is to run the verifier "
|
|
"when asserts are enabled and not run it when asserts are "
|
|
"disabled. NOTE: Can not be used if enable-ast-verifier is used "
|
|
"as well">;
|
|
|
|
let Flags = [FrontendOption, NoDriverOption, HelpHidden, ModuleInterfaceOptionIgnorable] in {
|
|
def enable_ossa_modules : Flag<["-"], "enable-ossa-modules">,
|
|
HelpText<"Obsolete. This option is ignored">;
|
|
}
|
|
|
|
def enable_recompilation_to_ossa_module : Flag<["-"], "enable-recompilation-to-ossa-module">,
|
|
HelpText<"Allow recompilation of a non-OSSA module to an OSSA module when imported from another OSSA module">;
|
|
|
|
def enable_sil_opaque_values : Flag<["-"], "enable-sil-opaque-values">,
|
|
HelpText<"Enable SIL Opaque Values">;
|
|
|
|
def disable_sil_opaque_values : Flag<["-"], "disable-sil-opaque-values">,
|
|
HelpText<"Disable SIL Opaque Values">;
|
|
|
|
def new_driver_path
|
|
: Separate<["-"], "new-driver-path">, MetaVarName<"<path>">,
|
|
HelpText<"Path of the new driver to be used">;
|
|
|
|
def disable_fine_module_tracing:
|
|
Flag<["-"], "disable-fine-module-tracing">,
|
|
HelpText<"Skip the emission of fine grained module tracing file.">;
|
|
|
|
def clang_header_expose_decls:
|
|
Joined<["-"], "clang-header-expose-decls=">,
|
|
HelpText<"Which declarations should be exposed in the generated clang header.">,
|
|
Flags<[FrontendOption, HelpHidden]>,
|
|
MetaVarName<"all-public|has-expose-attr">;
|
|
|
|
def clang_header_expose_module:
|
|
Separate<["-"], "clang-header-expose-module">,
|
|
HelpText<"Allow the compiler to assume that APIs from the specified module are exposed to C/C++/Objective-C in another generated header, so that APIs in the current module that depend on declarations from the specified module can be exposed in the generated header.">,
|
|
Flags<[FrontendOption, HelpHidden]>,
|
|
MetaVarName<"<imported-module-name>=<generated-header-name>">;
|
|
|
|
def weak_link_at_target :
|
|
Flag<["-"], "weak-link-at-target">,
|
|
HelpText<"Weakly link symbols for declarations that were introduced at the "
|
|
"deployment target. Symbols introduced before the deployment "
|
|
"target are still strongly linked.">;
|
|
|
|
def concurrency_model :
|
|
Separate<["-"], "concurrency-model">,
|
|
HelpText<"Which concurrency model is used. Defaults to standard.">,
|
|
MetaVarName<"standard|task-to-thread">;
|
|
def concurrency_model_EQ :
|
|
Joined<["-"], "concurrency-model=">,
|
|
Alias<concurrency_model>;
|
|
|
|
def enable_stack_protector :
|
|
Flag<["-"], "enable-stack-protector">,
|
|
HelpText<"Enable the stack protector">;
|
|
def disable_stack_protector :
|
|
Flag<["-"], "disable-stack-protector">,
|
|
HelpText<"Disable the stack-protector">;
|
|
def enable_move_inout_stack_protector :
|
|
Flag<["-"], "enable-move-inout-stack-protector">,
|
|
HelpText<"Enable the stack protector by moving values to temporaries">;
|
|
|
|
// This feature is enabled by default, the flag is a no-op.
|
|
def enable_import_ptrauth_field_function_pointers :
|
|
Flag<["-"], "enable-import-ptrauth-field-function-pointers">,
|
|
HelpText<"Enable import of custom ptrauth qualified field function pointers. "
|
|
"This is on by default.">;
|
|
|
|
def disable_import_ptrauth_field_function_pointers :
|
|
Flag<["-"], "disable-import-ptrauth-field-function-pointers">,
|
|
HelpText<"Disable import of custom ptrauth qualified field function pointers">;
|
|
|
|
def enable_lifetime_dependence_diagnostics :
|
|
Flag<["-"], "enable-lifetime-dependence-diagnostics">,
|
|
HelpText<"Enable lifetime dependence diagnostics for Nonescapable types.">;
|
|
def disable_lifetime_dependence_diagnostics :
|
|
Flag<["-"], "disable-lifetime-dependence-diagnostics">,
|
|
HelpText<"Disable lifetime dependence diagnostics for Nonescapable types.">;
|
|
|
|
def enable_aggressive_reg2mem :
|
|
Flag<["-"], "enable-aggressive-reg2mem">,
|
|
HelpText<"Enable a more aggressive reg2mem heuristic">;
|
|
def disable_aggressive_reg2mem :
|
|
Flag<["-"], "disable-aggressive-reg2mem">,
|
|
HelpText<"Disable a more aggressive reg2mem heuristic">;
|
|
|
|
def enable_collocate_metadata_functions :
|
|
Flag<["-"], "enable-collocate-metadata-functions">,
|
|
HelpText<"Enable collocate metadata functions">;
|
|
def disable_collocate_metadata_functions :
|
|
Flag<["-"], "disable-collocate-metadata-functions">,
|
|
HelpText<"Disable collocate metadata functions">;
|
|
|
|
def enable_colocate_type_descriptors :
|
|
Flag<["-"], "enable-colocate-type-descriptors">,
|
|
HelpText<"Enable colocate type descriptors">;
|
|
def disable_colocate_type_descriptors :
|
|
Flag<["-"], "disable-colocate-type-descriptors">,
|
|
HelpText<"Disable colocate type descriptors">;
|
|
|
|
def enable_relative_protocol_witness_tables :
|
|
Flag<["-"], "enable-relative-protocol-witness-tables">,
|
|
HelpText<"Enable relative protocol witness tables">;
|
|
def disable_relative_protocol_witness_tables :
|
|
Flag<["-"], "disable-relative-protocol-witness-tables">,
|
|
HelpText<"Disable relative protocol witness tables">;
|
|
def enable_fragile_resilient_protocol_witnesses :
|
|
Flag<["-"], "enable-fragile-relative-protocol-tables">,
|
|
HelpText<"Enable relative protocol witness tables">;
|
|
def disable_fragile_resilient_protocol_witnesses :
|
|
Flag<["-"], "disable-fragile-relative-protocol-tables">,
|
|
HelpText<"Disable relative protocol witness tables">;
|
|
|
|
def enable_async_frame_push_pop_metadata :
|
|
Flag<["-"], "enable-async-frame-push-pop-metadata">,
|
|
HelpText<"Enable async frame push pop metadata">;
|
|
def disable_async_frame_push_pop_metadata :
|
|
Flag<["-"], "disable-async-frame-push-pop-metadata">,
|
|
HelpText<"Disable async frame push pop metadata">;
|
|
|
|
def enable_emit_type_malloc_for_coro_frame :
|
|
Flag<["-"], "enable-emit-type-malloc-for-coro-frame">,
|
|
HelpText<"Enable emitting typed malloc for coroutine frame allocation">;
|
|
def disable_emit_type_malloc_for_coro_frame :
|
|
Flag<["-"], "disable-emit-type-malloc-for-coro-frame">,
|
|
HelpText<"Disable emitting typed malloc for coroutine frame allocation">;
|
|
|
|
def enable_async_frame_pointer_all :
|
|
Flag<["-"], "enable-async-frame-pointer-all">,
|
|
HelpText<"Always emit async frame stack frames (frame-pointer=all)">;
|
|
def disable_async_frame_pointer_all:
|
|
Flag<["-"], "disable-async-frame-pointer-all">,
|
|
HelpText<"Disable always emit async frame stack frames">;
|
|
|
|
def enable_split_cold_code :
|
|
Flag<["-"], "enable-split-cold-code">,
|
|
HelpText<"Enable splitting of cold code when optimizing">;
|
|
def disable_split_cold_code :
|
|
Flag<["-"], "disable-split-cold-code">,
|
|
HelpText<"Disable splitting of cold code when optimizing">;
|
|
|
|
def mergeable_traps :
|
|
Flag<["-"], "mergeable-traps">,
|
|
HelpText<"Emit mergeable traps even in optimized builds">;
|
|
|
|
def enable_new_llvm_pass_manager :
|
|
Flag<["-"], "enable-new-llvm-pass-manager">,
|
|
HelpText<"Enable the new llvm pass manager">;
|
|
def disable_new_llvm_pass_manager :
|
|
Flag<["-"], "disable-new-llvm-pass-manager">,
|
|
HelpText<"Disable the new llvm pass manager">;
|
|
|
|
def enable_profiling_marker_thunks :
|
|
Flag<["-"], "enable-profiling-marker-thunks">,
|
|
HelpText<"Enable profiling marker thunks">;
|
|
def disable_profiling_marker_thunks :
|
|
Flag<["-"], "disable-profiling-marker-thunks">,
|
|
HelpText<"Disable profiling marker thunks">;
|
|
|
|
def enable_objective_c_protocol_symbolic_references :
|
|
Flag<["-"], "enable-objective-c-protocol-symbolic-references">,
|
|
HelpText<"Enable objective-c protocol symbolic references">;
|
|
def disable_objective_c_protocol_symbolic_references :
|
|
Flag<["-"], "disable-objective-c-protocol-symbolic-references">,
|
|
HelpText<"Disable objective-c protocol symbolic references">;
|
|
|
|
def disable_emit_generic_class_ro_t_list :
|
|
Flag<["-"], "disable-emit-generic-class-ro_t-list">,
|
|
HelpText<"Disable emission of a section with references to class_ro_t of "
|
|
"generic class patterns">;
|
|
def enable_emit_generic_class_ro_t_list :
|
|
Flag<["-"], "enable-emit-generic-class-ro_t-list">,
|
|
HelpText<"Enable emission of a section with references to class_ro_t of "
|
|
"generic class patterns">;
|
|
|
|
def always_compile_output_files :
|
|
Flag<["-"], "always-compile-output-files">,
|
|
HelpText<"Always compile output files even it might not change the results">;
|
|
|
|
// CAS/Caching related options.
|
|
def input_file_key : Separate<["-"], "input-file-key">,
|
|
HelpText<"Cache Key for input file">;
|
|
def bridging_header_pch_key : Separate<["-"], "bridging-header-pch-key">,
|
|
HelpText<"Cache Key for bridging header pch">;
|
|
|
|
def no_clang_include_tree: Flag<["-"], "no-clang-include-tree">,
|
|
HelpText<"Do not use clang include tree, fallback to use CAS filesystem to build clang modules">;
|
|
|
|
def clang_include_tree_root: Separate<["-"], "clang-include-tree-root">,
|
|
HelpText<"Clang Include Tree CASID">, MetaVarName<"<cas-id>">;
|
|
def clang_include_tree_filelist: Separate<["-"], "clang-include-tree-filelist">,
|
|
HelpText<"Clang Include Tree FileList CASID">, MetaVarName<"<cas-id>">;
|
|
|
|
def experimental_spi_only_imports :
|
|
Flag<["-"], "experimental-spi-only-imports">,
|
|
HelpText<"Enable use of @_spiOnly imports">;
|
|
|
|
def enable_ossa_complete_lifetimes :
|
|
Flag<["-"], "enable-ossa-complete-lifetimes">,
|
|
HelpText<"Require linear OSSA lifetimes after SILGen">;
|
|
def disable_ossa_complete_lifetimes :
|
|
Flag<["-"], "disable-ossa-complete-lifetimes">,
|
|
HelpText<"Do not require linear OSSA lifetimes after SILGen">;
|
|
|
|
def enable_ossa_verify_complete :
|
|
Flag<["-"], "enable-ossa-verify-complete">,
|
|
HelpText<"Verify linear OSSA lifetimes after SILGen">;
|
|
def disable_ossa_verify_complete :
|
|
Flag<["-"], "disable-ossa-verify-complete">,
|
|
HelpText<"Do not verify linear OSSA lifetimes after SILGen">;
|
|
|
|
def platform_c_calling_convention :
|
|
Separate<["-"], "experimental-platform-c-calling-convention">,
|
|
HelpText<"Which calling convention is used to perform non-swift calls. "
|
|
"Defaults to llvm's standard C calling convention.">;
|
|
def platform_c_calling_convention_EQ :
|
|
Joined<["-"], "experimental-platform-c-calling-convention=">,
|
|
Alias<platform_c_calling_convention>;
|
|
|
|
|
|
def disable_sending_args_and_results_with_region_isolation : Flag<["-"],
|
|
"disable-sending-args-and-results-with-region-based-isolation">,
|
|
HelpText<"Disable sending args and results when region-based isolation is enabled. Only enabled with asserts">,
|
|
Flags<[HelpHidden]>;
|
|
|
|
def scanner_module_validation: Flag<["-"], "scanner-module-validation">,
|
|
HelpText<"Validate binary modules in the dependency scanner">;
|
|
def no_scanner_module_validation: Flag<["-"], "no-scanner-module-validation">,
|
|
HelpText<"Do not validate binary modules in scanner and delegate the validation to swift-frontend">;
|
|
def module_load_mode: Separate<["-"], "module-load-mode">,
|
|
MetaVarName<"only-interface|prefer-interface|prefer-serialized|only-serialized">,
|
|
HelpText<"Module loading mode">;
|
|
|
|
def scanner_output_dir: Separate<["-"], "scanner-output-dir">,
|
|
HelpText<"Directory for generated files from swift dependency scanner">;
|
|
def scanner_debug_write_output: Flag<["-"], "scanner-debug-write-output">,
|
|
HelpText<"Write generated output from scanner for debugging purpose">,
|
|
Flags<[HelpHidden]>;
|
|
|
|
def platform_availability_inheritance_map_path
|
|
: Separate<["-"], "platform-availability-inheritance-map-path">, MetaVarName<"<path>">,
|
|
HelpText<"Path of the platform inheritance platform map">;
|
|
|
|
def enable_address_dependencies : Flag<["-"], "enable-address-dependencies">,
|
|
HelpText<"Enable enforcement of lifetime dependencies on addressable values.">;
|
|
|
|
def disable_address_dependencies : Flag<["-"], "disable-address-dependencies">,
|
|
HelpText<"Disable enforcement of lifetime dependencies on addressable values.">;
|
|
|
|
def gen_reproducer : Flag<["-"], "gen-reproducer">,
|
|
HelpText<"Generate a reproducer for current compilation.">;
|
|
def gen_reproducer_dir
|
|
: Separate<["-"], "gen-reproducer-dir">,
|
|
HelpText<"Path to directory where reproducers write to.">;
|
|
|
|
} // end let Flags = [FrontendOption, NoDriverOption, HelpHidden]
|
|
|
|
def disable_experimental_parser_round_trip : Flag<["-"],
|
|
"disable-experimental-parser-round-trip">,
|
|
HelpText<"Disable round trip through the new swift parser">,
|
|
Flags<[FrontendOption, NoDriverOption, HelpHidden, ModuleInterfaceOptionIgnorable]>;
|