Darwin Options (Using the GNU Compiler Collection (GCC))

#### 3.20.12 Darwin Options ¶

These options are defined for all architectures running the Darwin operating system.

FSF GCC on Darwin does not create “fat” object files; it creates an object file for the single architecture that GCC was built to target. Apple’s GCC on Darwin does create “fat” files if multiple `-arch` options are used; it does so by running the compiler or linker multiple times and joining the results together with `lipo`.

The subtype of the file created (like ‘`ppc7400`’ or ‘`ppc970`’ or ‘`i686`’) is determined by the flags that specify the ISA that GCC is targeting, like `-mcpu` or `-march`. The `-force_cpusubtype_ALL` option can be used to override this.

The Darwin tools vary in their behavior when presented with an ISA mismatch. The assembler, `as`, only permits instructions to be used that are valid for the subtype of the file it is generating, so you cannot put 64-bit instructions in a ‘`ppc750`’ object file. The linker for shared libraries, `/usr/bin/libtool`, fails and prints an error if asked to create a shared library with a less restrictive subtype than its input files (for instance, trying to put a ‘`ppc970`’ object file in a ‘`ppc7400`’ library). The linker for executables, `ld`, quietly gives the executable the most restrictive subtype of any of its input files.

`-Fdir` ¶

  Add the framework directory dir to the head of the list of directories to be searched for header files. These directories are interleaved with those specified by `-I` options and are scanned in a left-to-right order.

  A framework directory is a directory with frameworks in it. A framework is a directory with a `Headers` and/or `PrivateHeaders` directory contained directly in it that ends in `.framework`. The name of a framework is the name of this directory excluding the `.framework`. Headers associated with the framework are found in one of those two directories, with `Headers` being searched first. A subframework is a framework directory that is in a framework’s `Frameworks` directory. Includes of subframework headers can only appear in a header of a framework that contains the subframework, or in a sibling subframework header. Two subframeworks are siblings if they occur in the same framework. A subframework should not have the same name as a framework; a warning is issued if this is violated. Currently a subframework cannot have subframeworks; in the future, the mechanism may be extended to support this. The standard frameworks can be found in `/System/Library/Frameworks` and `/Library/Frameworks`. An example include looks like `#include <Framework/header.h>`, where `Framework` denotes the name of the framework and `header.h` is found in the `PrivateHeaders` or `Headers` directory.

`-iframeworkdir` ¶

  Like `-F` except the directory is a treated as a system directory. The main difference between this `-iframework` and `-F` is that with `-iframework` the compiler does not warn about constructs contained within header files found via dir. This option is valid only for the C family of languages.

`-arch name` ¶

  Generate output for architecture name. As described above, GCC generates output for the architecture it was configured for, using its usual options to select subarchitecture variants. The `-arch` option is accepted for compatibility, but an error is diagnosed if name is inconsistent with GCC’s own idea of the target architecture.

`-dependency-file filename` ¶

  Alias for the preprocessor option `-MF filename`. See Options Controlling the Preprocessor.

`-fapple-kext` ¶

  Generate code for Darwin loadable kernel extensions.

`-gused` ¶

  Emit debugging information for symbols that are used. For stabs debugging format, this enables `-feliminate-unused-debug-symbols`. This is by default ON.

`-gfull` ¶

  Emit debugging information for all symbols and types.

`-matt-stubs` ¶
`-mno-att-stubs`

  Enable AT&T-style PIC stubs. This is the default when supported by the target architecture (currently x86 only).

`-mconstant-cfstrings` ¶
`-fconstant-cfstrings`

  When the NeXT runtime is being used (the default on these systems), override any `-fconstant-string-class` setting and cause `@"…"` literals to be laid out as constant CoreFoundation strings.

  `-fconstant-cfstrings` is an alias for `-mconstant-cfstrings`.

`-mdynamic-no-pic` ¶

  Generate code suitable for executables (not shared libraries). This option is incompatible with `-fpic`, `-fPIC`, `-fpie`, or `-fPIE`.

`-mfix-and-continue` ¶
`-ffix-and-continue`
`-findirect-data`

  Generate code suitable for fast turnaround development, such as to allow GDB to dynamically load `.o` files into already-running programs. `-findirect-data` and `-ffix-and-continue` are provided for backwards compatibility.

`-mkernel` ¶

  Enable kernel development mode. The `-mkernel` option sets `-static`, `-fno-common`, `-fno-use-cxa-atexit`, `-fno-exceptions`, `-fno-non-call-exceptions`, `-fapple-kext`, `-fno-weak` and `-fno-rtti` where applicable. This mode also sets `-mno-altivec`, `-msoft-float`, `-fno-builtin` and `-mlong-branch` for PowerPC targets.

`-mmacosx-version-min=version` ¶
`-asm_macosx_version_min=version`

  The `-mmacosx-version-min` option specifies the earliest version of MacOS X that this executable will run on is version. Typical values supported for version include `12`, `10.12`, and `10.5.8`.

  If the compiler was built to use the system’s headers by default, then the default for this option is the system version on which the compiler is running, otherwise the default is to make choices that are compatible with as many systems and code bases as possible.

  `-asm_macosx_version_min=version` is similar, but the GCC driver passes its version information only to the assembler.

`-mone-byte-bool` ¶

  Override the defaults for `bool` so that `sizeof(bool)==1`. By default `sizeof(bool)` is `4` when compiling for Darwin/PowerPC and `1` when compiling for Darwin/x86, so this option has no effect on x86.

  Warning: The `-mone-byte-bool` switch causes GCC to generate code that is not binary compatible with code generated without that switch. Using this switch may require recompiling all other modules in a program, including system libraries. Use this switch to conform to a non-default data model.

`-msymbol-stubs` ¶
`-mno-symbol-stubs`

  Force generation of external symbol indirection stubs for PIC references. By default, this option is enabled automatically if the target linker version (`-mtarget-linker`) is old enough to require them.

`-mtarget-linker=version` ¶
`-mtarget-linker version`

  Specify the target `ld64` version, overriding any version specified in the GCC configuration. Newer linker versions support improved code generation in some cases, for example for PIC code.

`-ObjC` ¶

  Equivalent to ‘`-x objective-c`’; specifies that the input is is Objective-C source code.

`-ObjC++` ¶

  Equivalent to ‘`-x objective-c++`’; specifies that the input is is Objective-C++ source code.

`-Wnonportable-cfstrings` ¶
`-Wno-nonportable-cfstrings`

  Warn if constant CoreFoundation string objects contain non-portable characters. This warning is enabled by default.

`-all_load` ¶

  Loads all members of static archive libraries. See man ld(1) for more information.

`-arch_errors_fatal` ¶

  Cause the errors having to do with files that have the wrong architecture to be fatal.

`-bind_at_load` ¶

  Causes the output file to be marked such that the dynamic linker will bind all undefined references when the file is loaded or launched.

`-bundle` ¶

  Produce a Mach-o bundle format file. See man ld(1) for more information.

`-bundle_loader executable` ¶

  This option specifies the executable that will load the build output file being linked. See man ld(1) for more information.

`-dynamiclib` ¶

  When passed this option, GCC produces a dynamic library instead of an executable when linking, using the Darwin `libtool` command.

`-force_cpusubtype_ALL` ¶

  This causes GCC’s output file to have the ‘`ALL`’ subtype, instead of one controlled by the `-mcpu` or `-march` option.

`-nodefaultrpaths` ¶

  Do not add default run paths for the compiler library directories to executables, modules or dynamic libraries. On macOS 10.5 and later, the embedded runpath is added by default unless the user adds `-nodefaultrpaths` to the link line. Run paths are needed (and therefore enforced) to build on macOS version 10.11 or later.

`-nodefaultexport` ¶

  Do not add default symbol exports to modules or dynamic libraries.

`-allowable_client client_name` ¶
`-client_name`
`-compatibility_version`
`-current_version`
`-dead_strip`
`-dylib_file`
`-dylinker`
`-dylinker_install_name`
`-dynamic`
`-exported_symbols_list`
`-filelist`
`-flat_namespace`
`-force_flat_namespace`
`-framework`
`-headerpad_max_install_names`
`-image_base`
`-init symbol-name`
`-install_name`
`-keep_private_externs`
`-pagezero_size`
`-preload`
`-read_only_relocs`
`-sectalign`
`-sectcreate`
`-seg_addr_table`
`-seg1addr`
`-segaddr`
`-segprot`
`-segs_read_only_addr`
`-segs_read_write_addr`
`-sub_library`
`-sub_umbrella`
`-twolevel_namespace`
`-twolevel_namespace_hints`
`-umbrella`
`-undefined`
`-unexported_symbols_list`
`-weak_framework`
`-weak_reference_mismatches`
`-whatsloaded`
`-whyload`

  These options are passed to the Darwin linker. The Darwin linker man page describes them in detail.