Skip to main content

apple_binary

name​

def name(
    *,
    name: str,
    default_target_platform: None | str = ...,
    target_compatible_with: list[str] = ...,
    compatible_with: list[str] = ...,
    exec_compatible_with: list[str] = ...,
    visibility: list[str] = ...,
    within_view: list[str] = ...,
    metadata: OpaqueMetadata = ...,
    tests: list[str] = ...,
    modifiers: OpaqueMetadata = ...,
    _apple_platforms: dict[str, str] = ...,
    _apple_toolchain: str = ...,
    _apple_tools: str = ...,
    _apple_xctoolchain: str = ...,
    _apple_xctoolchain_bundle_id: str = ...,
    _dsymutil_extra_flags: list[str],
    _dsymutil_verify_dwarf: str,
    _enable_library_evolution: bool = ...,
    _stripped_default: bool = ...,
    _swift_enable_testing: bool = ...,
    allow_cache_upload: None | bool = ...,
    application_extension: bool = ...,
    attrs_validators: None | list[str] = ...,
    binary_linker_flags: list[str] = ...,
    bridging_header: None | str = ...,
    can_be_asset: None | bool = ...,
    compiler_flags: list[str] = ...,
    constraint_overrides: list[str] = ...,
    contacts: list[str] = ...,
    cxx_runtime_type: None | str = ...,
    default_host_platform: None | str = ...,
    default_platform: None | str = ...,
    defaults: dict[str, str] = ...,
    deps: list[str] = ...,
    devirt_enabled: bool = ...,
    diagnostics: dict[str, str] = ...,
    dist_thin_lto_codegen_flags: list[str] = ...,
    dsym_uses_parallel_linker: bool = ...,
    enable_cxx_interop: bool = ...,
    enable_distributed_thinlto: bool = ...,
    enable_library_evolution: None | bool = ...,
    entitlements_file: None | str = ...,
    executable_name: None | str = ...,
    exported_header_style: str = ...,
    exported_headers: list[str] | dict[str, str] = ...,
    exported_lang_platform_preprocessor_flags: dict[str, list[(str, list[str])]] = ...,
    exported_lang_preprocessor_flags: dict[str, list[str]] = ...,
    exported_linker_flags: list[str] = ...,
    exported_platform_deps: list[(str, list[str])] = ...,
    exported_platform_headers: list[(str, list[str] | dict[str, str])] = ...,
    exported_platform_linker_flags: list[(str, list[str])] = ...,
    exported_platform_preprocessor_flags: list[(str, list[str])] = ...,
    exported_post_linker_flags: list[str] = ...,
    exported_post_platform_linker_flags: list[(str, list[str])] = ...,
    exported_preprocessor_flags: list[str] = ...,
    extra_xcode_files: list[str] = ...,
    extra_xcode_sources: list[str] = ...,
    fat_lto: bool = ...,
    focused_list_target: None | str = ...,
    force_static: None | bool = ...,
    frameworks: list[str] = ...,
    header_namespace: None | str = ...,
    header_path_prefix: None | str = ...,
    headers: list[str] | dict[str, str] = ...,
    headers_as_raw_headers_mode: None | str = ...,
    include_directories: list[str] = ...,
    info_plist: None | str = ...,
    info_plist_substitutions: dict[str, str] = ...,
    labels: list[str] = ...,
    lang_compiler_flags: dict[str, list[str]] = ...,
    lang_platform_compiler_flags: dict[str, list[(str, list[str])]] = ...,
    lang_platform_preprocessor_flags: dict[str, list[(str, list[str])]] = ...,
    lang_preprocessor_flags: dict[str, list[str]] = ...,
    libraries: list[str] = ...,
    licenses: list[str] = ...,
    link_execution_preference: None | str = ...,
    link_group: None | str = ...,
    link_group_map: None | str | list[(str, list[(None | str | list[None | str], str, None | str | list[str], None | str)], None | dict[str, typing.Any])] = ...,
    link_group_public_deps_label: None | str = ...,
    link_ordering: None | str = ...,
    link_style: None | str = ...,
    link_whole: None | bool = ...,
    linker_extra_outputs: list[str] = ...,
    linker_flags: list[str] = ...,
    modular: bool = ...,
    module_name: None | str = ...,
    module_requires_cxx: bool = ...,
    platform_compiler_flags: list[(str, list[str])] = ...,
    platform_deps: list[(str, list[str])] = ...,
    platform_headers: list[(str, list[str] | dict[str, str])] = ...,
    platform_linker_flags: list[(str, list[str])] = ...,
    platform_override: None | str = ...,
    platform_preprocessor_flags: list[(str, list[str])] = ...,
    platform_srcs: list[(str, list[str | (str, list[str])])] = ...,
    post_linker_flags: list[str] = ...,
    post_platform_linker_flags: list[(str, list[str])] = ...,
    precompiled_header: None | str = ...,
    prefer_stripped_objects: bool = ...,
    preferred_linkage: str = ...,
    prefix_header: None | str = ...,
    preprocessor_flags: list[str] = ...,
    propagated_target_sdk_version: None | str = ...,
    public_include_directories: list[str] = ...,
    public_system_include_directories: list[str] = ...,
    raw_headers: list[str] = ...,
    reexport_all_header_dependencies: None | bool = ...,
    sanitizer_runtime_enabled: None | bool = ...,
    sdk_modules: list[str] = ...,
    serialize_debugging_options: None | bool = ...,
    soname: None | str = ...,
    srcs: list[str | (str, list[str])] = ...,
    static_library_basename: None | str = ...,
    stripped: None | bool = ...,
    supported_platforms_regex: None | str = ...,
    supports_merged_linking: None | bool = ...,
    swift_compilation_mode: str = ...,
    swift_compiler_flags: list[str] = ...,
    swift_interface_compilation_enabled: bool = ...,
    swift_module_skip_function_bodies: bool = ...,
    swift_package_name: None | str = ...,
    swift_version: None | str = ...,
    target_sdk_version: None | str = ...,
    thin_lto: bool = ...,
    use_submodules: bool = ...,
    uses_cxx_explicit_modules: bool = ...,
    uses_explicit_modules: bool = ...,
    uses_modules: bool = ...,
    validation_deps: list[str] = ...,
) -> None

An apple_binary() rule builds a native executable - such as an iOS or OSX app - from the supplied set of Objective-C/C++ source files and dependencies. It is similar to a cxx_binary() rule with which it shares many attributes. In addition to those common attributes, apple_binary() has a some additional attributes that are specific to binaries intended to be built using the Apple toolchain. Note, however, that apple_binary() and cxx_binary() differ in the way that they import header files, in order to better accommodate existing conventions. See the sections for the headers and exported_headers attributes for more details.

Parameters​

  • name: name of the target

  • default_target_platform: specifies the default target platform, used when no platforms are specified on the command line

  • target_compatible_with: a list of constraints that are required to be satisfied for this target to be compatible with a configuration

  • compatible_with: a list of constraints that are required to be satisfied for this target to be compatible with a configuration

  • exec_compatible_with: a list of constraints that are required to be satisfied for this target to be compatible with an execution platform

  • visibility: a list of visibility patterns restricting what targets can depend on this one

  • within_view: a list of visibility patterns restricting what this target can depend on

  • metadata: a key-value map of metadata associated with this target

  • tests: a list of targets that provide tests for this one

  • modifiers: an array of modifiers associated with this target

  • allow_cache_upload: Whether to allow uploading the output of this rule to be uploaded to cache when the action is executed locally if the configuration allows (i.e. there is a cache configured and the client has permission to write to it).

  • compiler_flags: Flags to use when compiling any of the above sources (which require compilation).

  • entitlements_file: An optional name of a plist file to be embedded in the binary. Some platforms like iphonesimulator require this to run properly.

  • exported_headers: The set of header files that are made available for inclusion to the source files in this target and all targets that transitively depend on this one. These should be specified as either a list of header files or a dictionary of header names to header files. The header names can contain forward slashes (/). If a list of header files is specified, the headers can be imported with #import "$HEADER_PATH_PREFIX/$HEADER_NAME" or, if a header file that belongs to the same rule is being imported, with #import "$HEADER_NAME", where $HEADER_PATH_PREFIX is the value of the target's header_path_prefix attribute, and $HEADER_NAME is the filename of the header file. If a dictionary is specified, each header can be imported with #import "$HEADER_NAME", where $HEADER_NAME is the key corresponding to this file. In this case, the header_path_prefix attribute is ignored. In either case, quotes in the import statements can be replaced with angle brackets.

  • exported_linker_flags: Flags to add to the linker command line when the output from this rule, or the output from any rule that transitively depends on this rule, is used in a link operation.

  • extra_xcode_files: When the project is generated, this is the list of files that will added to the project. Those files won't be added to the build phase "Compile Sources".

  • frameworks: A list of system frameworks that the code in this target uses. Each entry should be a path starting with $SDKROOT or $PLATFORM_DIR to denote that the rest of the path is relative to the root of the SDK used for the build or to the platform toolchain directory.

  • header_path_prefix: A path prefix when including headers of this target. For example, headers from a library defined using

    apple_library(
        name = "Library",
        headers = glob(["**/*.h"]),
        header_path_prefix = "Lib",
    )

    can be imported using following mapping

    Library/SubDir/Header1.h -> Lib/Header1.h
    Library/Header2.h -> Lib/Header2.h

    Defaults to the short name of the target. Can contain forward slashes (/), but cannot start with one. See headers for more information.

  • headers: The set of header files that are made available for inclusion to the source files in this target. These should be specified as either a list of header files or a dictionary of header names to header files. The header names can contain forward slashes (/). If a list of header files is specified, the headers can be imported with #import "$HEADER_PATH_PREFIX/$HEADER_NAME" or #import "$HEADER_NAME", where $HEADER_PATH_PREFIX is the value of the target's header_path_prefix attribute, and $HEADER_NAME is the filename of the header file. If a dictionary is specified, each header can be imported with #import "$HEADER_NAME", where $HEADER_NAME is the key corresponding to this file. In this case, the header_path_prefix attribute is ignored. In either case, quotes in the import statements can be replaced with angle brackets.

  • link_execution_preference: The execution preference for linking. Options are:

    • any : No preference is set, and the link action will be performed based on buck2's executor configuration.
    • full_hybrid : The link action will execute both locally and remotely, regardless of buck2's executor configuration (if the executor is capable of hybrid execution). The use_limited_hybrid setting of the hybrid executor is ignored.
    • local : The link action will execute locally if compatible on current host platform.
    • local_only : The link action will execute locally, and error if the current platform is not compatible.
    • remote : The link action will execute remotely if a compatible remote platform exists, otherwise locally.

    The default is None, expressing that no preference has been set on the target itself.

  • link_group_public_deps_label: Surface nodes with this label as "public" nodes in the main executable when linking with with link groups.

  • link_style: Determines whether to build and link this rule's dependencies statically or dynamically. Can be either static, static_pic or shared.

  • linker_extra_outputs: Declares extra outputs that the linker emits. These identifiers can be used in $(output ...) macros in linker_flags to interpolate the output path into the linker command line. Useful for custom linkers that emit extra output files.

  • linker_flags: Flags to add to the linker command line whenever the output from this rule is used in a link operation, such as linked into an executable or a shared library.

  • platform_compiler_flags: Platform specific compiler flags. These should be specified as a list of pairs where the first element is an un-anchored regex (in java.util.regex.Pattern syntax) against which the platform name is matched, and the second element is a list of flags to use when compiling the target's sources. See compiler_flags for more information.

  • platform_linker_flags: Platform-specific linker flags. This argument is specified as a list of pairs where the first element in each pair is an un-anchored regex against which the platform name is matched. The regex should use java.util.regex.Pattern syntax. The second element in each pair is a list of linker flags. If the regex matches the platform, these flags are added to the linker command line when the output from this rule is used in a link operation.

  • platform_srcs: Platform specific source files. These should be specified as a list of pairs where the first element is an un-anchored regex (in java.util.regex.Pattern syntax) against which the platform name is matched, and the second element is either a list of source files or a list of tuples of source files and a list of compilation flags to be preprocessed, compiled and assembled if the platform matches the regex. See srcs for more information.

  • preprocessor_flags: Flags to use when preprocessing any of the above sources (which require preprocessing).

  • srcs: The set of C, C++, Objective-C, Objective-C++, or assembly source files to be preprocessed, compiled, and assembled by this rule. We determine which stages to run on each input source based on its file extension. See the GCC documentation for more detail on how file extensions are interpreted. Each element can be either a string specifying a source file (e.g. '') or a tuple of a string specifying a source file and a list of compilation flags (e.g. ('', ['-Wall', '-Werror']) ). In the latter case the specified flags will be used in addition to the rule's other flags when preprocessing and compiling that file (if applicable).

  • target_sdk_version: The minimum OS version that the library target should support, overriding the minimum set in .buckconfig. When set, Buck will automatically add flags to both Objective-C and Swift compilation that will allow the use of the new APIs without guarding code inside availability checks.

Details​

Buck enables you to override components of the Apple toolchain with alternate tools, either from the Xcode search paths or from directories that you specify. See .buckconfig and .buckconfig for more information.

Examples:


apple_binary(
  name = 'MyBinary',
  deps = [
    ':MyLibrary',
    '//Libraries:AnotherLibrary',
  ],
  preprocessor_flags = ['-fobjc-arc'],
  headers = [
    'MyHeader.h',
  ],
  srcs = [
    'MySource.m',
  ],
  frameworks = [
    '$SDKROOT/System/Library/Frameworks/UIKit.framework',
    '$SDKROOT/System/Library/Frameworks/Foundation.framework',
  ],
)