zVx2fRVZ

1## Build settings reference
2
3#### Active Build Action (`ACTION`)
4A string identifying the build system action being performed.
5
6#### Additional SDKs (`ADDITIONAL_SDKS`)
7The locations of any sparse SDKs that should be layered on top of the one specified by Base SDK (`SDKROOT`). If more than one SDK is listed, the first one has highest precedence. Every SDK specified in this setting should be a "sparse" SDK, for example, not an SDK for an entire macOS release.
8
9#### Alternate Install Group (`ALTERNATE_GROUP`)
10The group name or `gid` for the files listed under the Alternate Permissions Files (`ALTERNATE_PERMISSIONS_FILES`) setting.
11
12#### Alternate Install Permissions (`ALTERNATE_MODE`)
13Permissions used for the files listed under the Alternate Permissions Files (`ALTERNATE_PERMISSIONS_FILES`) setting.
14
15#### Alternate Install Owner (`ALTERNATE_OWNER`)
16The owner name or `uid` for the files listed under the Alternate Permissions Files (`ALTERNATE_PERMISSIONS_FILES`) setting.
17
18#### Alternate Permissions Files (`ALTERNATE_PERMISSIONS_FILES`)
19List of files to which the alternate owner, group and permissions are applied.
20
21#### Always Search User Paths (`ALWAYS_SEARCH_USER_PATHS`)
22If enabled, both `#include <header.h>`-style and `#include "header.h"`-style directives search the paths in User Header Search Paths (`USER_HEADER_SEARCH_PATHS`) before Header Search Paths (`HEADER_SEARCH_PATHS`). As a consequence, user headers, such as your own String.h header, have precedence over system headers when using `#include <header.h>`. This is done using the `-iquote` flag for the paths provided in User Header Search Paths. If disabled and your compiler fully supports separate user paths, user headers are only accessible with `#include "header.h"`-style preprocessor directives.
23
24For backwards compatibility reasons, this setting is enabled by default. Disabling it is strongly recommended.
25
26#### Require Only App-Extension-Safe API (`APPLICATION_EXTENSION_API_ONLY`)
27When enabled, this causes the compiler and linker to disallow use of APIs that are not available to app extensions and to disallow linking to frameworks that have not been built with this setting enabled.
28
29#### Convert Copied Files (`APPLY_RULES_IN_COPY_FILES`)
30Files copied with a Copy Files build phase are unchanged by default. Setting this to `TRUE` causes property list files (`.plist`) and Strings files to be converted as specified by Property List Output Encoding (`PLIST_FILE_OUTPUT_FORMAT`) and Strings File Output Encoding (`STRINGS_FILE_OUTPUT_ENCODING`).
31
32#### Architectures (`ARCHS`)
33A list of the architectures for which the product will be built. This is usually set to a predefined build setting provided by the platform. If more than one architecture is specified, a universal binary will be produced.
34
35#### Asset Catalog App Icon Set Name (`ASSETCATALOG_COMPILER_APPICON_NAME`)
36Name of the asset catalog app icon set whose contents will be merged into the `Info.plist`.
37
38#### Watch Complication Name (`ASSETCATALOG_COMPILER_COMPLICATION_NAME`)
39The name of a watch complication to use from the asset catalog.
40
41#### Asset Catalog Launch Image Set Name (`ASSETCATALOG_COMPILER_LAUNCHIMAGE_NAME`)
42Name of an asset catalog launch image set whose contents will be merged into the `Info.plist`.
43
44#### Leaderboard Identifier Prefix (`ASSETCATALOG_COMPILER_LEADERBOARD_IDENTIFIER_PREFIX`)
45Leaderboards in the asset catalog may optionally specify a Game Center identifier. If they do not, their name will be prefixed by this value to form an automatically generated identifier.
46
47#### Leaderboard Set Identifier Prefix (`ASSETCATALOG_COMPILER_LEADERBOARD_SET_IDENTIFIER_PREFIX`)
48Leaderboard sets in the asset catalog may optionally specify a Game Center identifier. If they do not, their name will be prefixed by this value to form an automatically generated identifier.
49
50#### Optimization (`ASSETCATALOG_COMPILER_OPTIMIZATION`)
51With no value, the compiler uses the default optimization. You can also specify time to optimize for speed of access or space to optimize for a smaller compiled asset catalogs.
52
53#### Sticker Pack Identifier Prefix (`ASSETCATALOG_COMPILER_STICKER_PACK_IDENTIFIER_PREFIX`)
54Sticker Packs in the asset catalog may optionally specify an identifier. If they do not, their name will be prefixed by this value to form an automatically generated identifier.
55
56#### Show Notices (`ASSETCATALOG_NOTICES`)
57Show notices encountered during the compilation of asset catalogs.
58
59#### Asset Catalog Other Flags (`ASSETCATALOG_OTHER_FLAGS`)
60Pass additional flags through to the asset catalog compiler.
61
62#### Show Warnings (`ASSETCATALOG_WARNINGS`)
63Show warnings encountered during the compilation of asset catalogs.
64
65#### Asset Pack Manifest URL Prefix (`ASSET_PACK_MANIFEST_URL_PREFIX`)
66If set to anything other than the empty string, every URL in the `AssetPackManifest.plist` file will consist of this string with the name of the asset pack appended. If not set, the URLs in the `AssetPackManifest.plist` will be formed as appropriate for the build location of the asset packs. The prefix string is not escaped or quoted in any way, so any necessary escaping must be part of the URL string. This setting affects only URLs in the `AssetPackManifest.plist` file — it does not affect where asset packs are built in the local file system.
67
68#### Active Build Components (`BUILD_COMPONENTS`)
69A list of components being built during this action.
70
71#### Build Variants (`BUILD_VARIANTS`)
72A list of the build variants of the linked binary that will be produced. By default, only the normal variant is produced. Other common values include debug and profile.
73
74#### BUILT_PRODUCTS_DIR
75Identifies the directory under which all the product’s files can be found. This directory contains either product files or symbolic links to them. Run Script build phases can use the value of this build setting as a convenient way to refer to the product files built by one or more targets even when these files are scattered throughout a directory hierarchy (for example, when `DEPLOYMENT_LOCATION` is set to `YES`.
76
77#### Bundle Loader (`BUNDLE_LOADER`)
78Specifies the executable that will load the bundle output file being linked. Undefined symbols from the bundle are checked against the specified executable as if it is one of the dynamic libraries the bundle was linked with.
79
80#### Enable C++ Container Overflow Checks for Address Sanitizer (`CLANG_ADDRESS_SANITIZER_CONTAINER_OVERFLOW`)
81Check for C++ container overflow when Address Sanitizer is enabled. This check requires the entire application to be built with Address Sanitizer. If not, it may report false positives.
82
83#### Allow Non-modular Includes In Framework Modules (`CLANG_ALLOW_NON_MODULAR_INCLUDES_IN_FRAMEWORK_MODULES`)
84Enabling this setting allows non-modular includes to be used from within framework modules. This is inherently unsafe, as such headers might cause duplicate definitions when used by any client that imports both the framework and the non-modular includes.
85
86#### Dead Stores (`CLANG_ANALYZER_DEADCODE_DEADSTORES`)
87Check for values stored to variables and never read again.
88
89#### Misuse of Grand Central Dispatch (`CLANG_ANALYZER_GCD`)
90Check for misuses of the Grand Central Dispatch API.
91
92#### Missing Localization Context Comment (`CLANG_ANALYZER_LOCALIZABILITY_EMPTY_CONTEXT`)
93Warn when a call to an `NSLocalizedString()` macro is missing a context comment for the localizer.
94
95#### Missing Localizability (`CLANG_ANALYZER_LOCALIZABILITY_NONLOCALIZED`)
96Warn when a nonlocalized string is passed to a user interface method expecting a localized string.
97
98#### Improper Memory Management (`CLANG_ANALYZER_MEMORY_MANAGEMENT`)
99Warn about memory leaks, use-after-free, and other API misuses.
100
101#### Misuse of `nonnull` (`CLANG_ANALYZER_NONNULL`)
102Check for misuses of `nonnull` parameter and return types.
103
104#### `@synchronized` with `nil` mutex (`CLANG_ANALYZER_OBJC_ATSYNC`)
105Warn on `nil` pointers used as mutexes for `@synchronized`.
106
107#### Misuse of Collections API (`CLANG_ANALYZER_OBJC_COLLECTIONS`)
108Warn if CF collections are created with non-pointer-size values. Check if NS collections are initialized with non-Objective-C-type elements.
109
110#### Improper Instance Cleanup in `-dealloc` (`CLANG_ANALYZER_OBJC_DEALLOC`)
111Warn when an instance is improperly cleaned up in `-dealloc`.
112
113#### Misuse of Objective-C generics (`CLANG_ANALYZER_OBJC_GENERICS`)
114Warn if a specialized generic type is converted to an incompatible type.
115
116#### Method Signatures Mismatch (`CLANG_ANALYZER_OBJC_INCOMP_METHOD_TYPES`)
117Warn about Objective-C method signatures with type incompatibilities.
118
119#### Improper Handling of CFError and NSError (`CLANG_ANALYZER_OBJC_NSCFERROR`)
120Warn if functions accepting CFErrorRef or NSError cannot indicate that an error occurred.
121
122#### Violation of Reference Counting Rules (`CLANG_ANALYZER_OBJC_RETAIN_COUNT`)
123Warn on leaks and improper reference count management.
124
125#### Violation of 'self = `super init`' Rule (`CLANG_ANALYZER_OBJC_SELF_INIT`)
126Check that super init is properly called within an Objective-C initialization method.
127
128#### Unused Ivars (`CLANG_ANALYZER_OBJC_UNUSED_IVARS`)
129Warn about private ivars that are never used.
130
131*EXPERIMENTAL* Buffer overflows (`CLANG_ANALYZER_SECURITY_BUFFER_OVERFLOW_EXPERIMENTAL`)
132Check for potential buffer overflows.
133
134#### Floating Point Value Used as Loop Counter (`CLANG_ANALYZER_SECURITY_FLOATLOOPCOUNTER`)
135Warn on using a floating point value as a loop counter (CERT: FLP30-C, FLP30-CPP).
136
137#### Use of `getpw`, `gets` (Buffer Overflow) (`CLANG_ANALYZER_SECURITY_INSECUREAPI_GETPW_GETS`)
138Warn on uses of getpw and gets. The functions are dangerous as they may trigger a buffer overflow.
139
140#### Use of `mktemp` or Predictable `mktemps` (`CLANG_ANALYZER_SECURITY_INSECUREAPI_MKSTEMP`)
141Warn on uses of mktemp, which produces predictable temporary files. It is obsoleted by mktemps. Warn when mkstemp is passed fewer than 6 X's in the format string.
142
143#### Use of `rand` Functions (`CLANG_ANALYZER_SECURITY_INSECUREAPI_RAND`)
144Warn on uses of rand, random, and related functions, which produce predictable random number sequences. Use arc4random instead.
145
146#### Use of `strcpy` and `strcat` (`CLANG_ANALYZER_SECURITY_INSECUREAPI_STRCPY`)
147Warn on uses of the strcpy and strcat functions, which can result in buffer overflows. Use strlcpy or strlcat instead.
148
149#### Unchecked Return Values (`CLANG_ANALYZER_SECURITY_INSECUREAPI_UNCHECKEDRETURN`)
150Warn on uses of sensitive functions whose return values must be always checked.
151
152#### Use of `vfork` (`CLANG_ANALYZER_SECURITY_INSECUREAPI_VFORK`)
153Warn on uses of the vfork function, which is inherently insecure. Use the safer posix_spawn function instead.
154
155#### Misuse of Keychain Services API (`CLANG_ANALYZER_SECURITY_KEYCHAIN_API`)
156Check for misuse of the Keychain Services API.
157
158#### C++ Language Dialect (`CLANG_CXX_LANGUAGE_STANDARD`)
159Choose a standard or non-standard C++ language dialect. Options include:
160
161- C++98: Accept ISO C++ 1998 with amendments, but not GNU extensions. `-std`=c++98
162- GNU++98: Accept ISO C++ 1998 with amendments and GNU extensions. `-std`=gnu++98
163- C++11: Accept the ISO C++ 2011 standard with amendments, but not GNU extensions. `-std`=c++11
164- GNU++11: Accept the ISO C++ 2011 standard with amendments and GNU extensions. `-std`=gnu++11
165- C++14: Accept the ISO C++ 2014 standard with amendments, but not GNU extensions. `-std`=c++14
166- GNU++14: Accept the ISO C++ 2014 standard with amendments and GNU extensions. `-std`=gnu++14
167- Compiler Default: Tells the compiler to use its default C++ language dialect. This is normally the best choice unless you have specific needs. (Currently equivalent to GNU++98.)
168
169#### C++ Standard Library (`CLANG_CXX_LIBRARY`)
170Choose a version of the C++ standard library to use.
171
172- libstdc++: A traditional C++ standard library that works with GCC and the LLVM Compiler (`default`).
173- libc++: A highly optimized C++ standard library that works only with the LLVM Compiler, and is designed to support new C++11 features.
174
175#### Debug Information Level (`CLANG_DEBUG_INFORMATION_LEVEL`)
176Toggles the amount of debug information emitted when debug symbols are enabled. This can impact the size of the generated debug information, which may matter in some cases for large projects, such as when using LTO.
177
178#### Enable Code Coverage Support (`CLANG_ENABLE_CODE_COVERAGE`)
179Enables building with code coverage instrumentation. This is only used when the build has code coverage enabled, which is typically done via the Xcode scheme settings.
180
181#### Enable Modules (C and Objective-C) (`CLANG_ENABLE_MODULES`)
182Enables the use of modules for system APIs. System headers are imported as semantic modules instead of raw headers. This can result in faster builds and project indexing.
183
184#### Enable Clang Module Debugging (`CLANG_ENABLE_MODULE_DEBUGGING`)
185When this setting is enabled, clang will use the shared debug info available in clang modules and precompiled headers. This results in smaller build artifacts, faster compile times, and more complete debug info. This setting should only be disabled when building static libraries with debug info for distribution.
186
187#### Objective-C Automatic Reference Counting (`CLANG_ENABLE_OBJC_ARC`)
188Compiles reference-counted Objective-C code (when garbage collection is not enabled) to use Automatic Reference Counting. Code compiled using automated reference counting is compatible with other code (such as frameworks) compiled using either manual reference counting (for example, traditional retain and release messages) or automated reference counting. Using this mode is currently incompatible with compiling code to use Objective-C Garbage Collection.
189
190#### Weak References in Manual Retain Release (`CLANG_ENABLE_OBJC_WEAK`)
191Compiles Objective-C code to enable weak references for code compiled with manual retain release (`MRR`) semantics.
192
193#### Implicitly Link Objective-C Runtime Support (`CLANG_LINK_OBJC_RUNTIME`)
194When linking a target using Objective-C code, implicitly link in Foundation (and if deploying back to an older OS) a backwards compatibility library to allow newer language features to run on an OS where the runtime support is not natively available. Most targets that use Objective-C should use this, although there are rare cases where a target should opt out of this behavior.
195
196#### Add attribute annotations (`CLANG_MIGRATOR_ANNOTATIONS`)
197Add attribute annotations to properties and methods.
198
199#### Infer instancetype for method result type (`CLANG_MIGRATOR_INSTANCE_TYPE`)
200Infer instancetype for method result type instead of id.
201
202#### Use NS_ENUM/NS_OPTIONS macros (`CLANG_MIGRATOR_NSENUM_MACROS`)
203Use NS_ENUM/NS_OPTIONS macros for enumerators.
204
205#### Infer designated initializer methods (`CLANG_MIGRATOR_OBJC_DESIGNATED_INIT`)
206Infer `NS_DESIGNATED_INITIALIZER` for designated initializer methods.
207
208#### ObjC literals (`CLANG_MIGRATOR_OBJC_LITERALS`)
209Enable migration to modern ObjC literals syntax.
210
211#### ObjC subscripting (`CLANG_MIGRATOR_OBJC_SUBSCRIPTING`)
212Enable migration to modern ObjC subscripting syntax.
213
214#### Atomicity of inferred properties (`CLANG_MIGRATOR_PROPERTY_ATOMICITY`)
215Choose the atomicity of the inferred properties.
216
217#### ObjC property-dot syntax (`CLANG_MIGRATOR_PROPERTY_DOT_SYNTAX`)
218Enable migration of setter/getter messages to property-dot syntax.
219
220#### Infer protocol conformance (`CLANG_MIGRATOR_PROTOCOL_CONFORMANCE`)
221Infer protocol conformance from the interface methods.
222
223#### Only modify public headers (`CLANG_MIGRATOR_PUBLIC_HEADERS_ONLY`)
224Only modify public headers of a target.
225
226#### Infer readonly properties (`CLANG_MIGRATOR_READONLY_PROPERTY`)
227Infer readonly properties from getter methods.
228
229#### Infer readwrite properties (`CLANG_MIGRATOR_READWRITE_PROPERTY`)
230Infer readwrite properties from a getter and setter method.
231
232#### Link Frameworks Automatically (`CLANG_MODULES_AUTOLINK`)
233Automatically link SDK frameworks that are referenced using `#import` or `#include`. This feature requires also enabling support for modules.
234
235#### Optimization Profile File (`CLANG_OPTIMIZATION_PROFILE_FILE`)
236The path to the file of the profile data to use when Use Optimization Profile (`CLANG_USE_OPTIMIZATION_PROFILE`) is enabled.
237
238#### Mode of Analysis for `Build` (`CLANG_STATIC_ANALYZER_MODE`)
239The depth the static analyzer uses during the Build action. Use Deep to exercise the full power of the analyzer. Use Shallow for faster analysis.
240
241#### Mode of Analysis for `Analyze` (`CLANG_STATIC_ANALYZER_MODE_ON_ANALYZE_ACTION`)
242The depth the static analyzer uses during the Analyze action. Use Deep to exercise the full power of the analyzer. Use Shallow for faster analysis.
243
244#### Use Optimization Profile (`CLANG_USE_OPTIMIZATION_PROFILE`)
245When this setting is enabled, clang will use the optimization profile collected for a target when building it.
246
247#### Out-of-Range Enum Assignments (`CLANG_WARN_ASSIGN_ENUM`)
248Warn about assigning integer constants to enum values that are out of the range of the enumerated type.
249
250#### Implicit Boolean Conversions (`CLANG_WARN_BOOL_CONVERSION`)
251Warn about implicit conversions to boolean values that are suspicious. For example, writing if (`foo`) where foo is the name a function will trigger a warning.
252
253#### Implicit Constant Conversions (`CLANG_WARN_CONSTANT_CONVERSION`)
254Warn about implicit conversions of constant values that cause the constant value to change, either through a loss of precision, or entirely in its meaning.
255
256#### Using C++11 extensions in earlier versions of C++ (`CLANG_WARN_CXX0X_EXTENSIONS`)
257When compiling C++ code using a language standard older than C++11, warn about the use of C++11 extensions.
258
259#### Overriding Deprecated Objective-C Methods (`CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS`)
260Warn if an Objective-C class either subclasses a deprecated class or overrides a method that has been marked deprecated.
261
262#### Direct usage of `isa` (`CLANG_WARN_DIRECT_OBJC_ISA_USAGE`)
263Warn about direct accesses to the Objective-C isa pointer instead of using a runtime API.
264
265#### Documentation Comments (`CLANG_WARN_DOCUMENTATION_COMMENTS`)
266Warns about issues in documentation comments (doxygen-style) such as missing or incorrect documentation tags.
267
268#### Empty Loop Bodies (`CLANG_WARN_EMPTY_BODY`)
269Warn about loop bodies that are suspiciously empty.
270
271#### Implicit Enum Conversions (`CLANG_WARN_ENUM_CONVERSION`)
272Warn about implicit conversions between different kinds of enum values. For example, this can catch issues when using the wrong enum flag as an argument to a function or method.
273
274#### Implicit Signedness Conversions (`CLANG_WARN_IMPLICIT_SIGN_CONVERSION`)
275Warn about implicit integer conversions that change the signedness of an integer value.
276
277#### Infinite Recursion (`CLANG_WARN_INFINITE_RECURSION`)
278Warn if all paths through a function call itself.
279
280#### Implicit Integer to Pointer Conversions (`CLANG_WARN_INT_CONVERSION`)
281Warn about implicit conversions between pointers and integers. For example, this can catch issues when one incorrectly intermixes using NSNumber*'s and raw integers.
282
283#### Incorrect Uses of Nullable Values (`CLANG_WARN_NULLABLE_TO_NONNULL_CONVERSION`)
284Warns when a nullable expression is used somewhere it’s not allowed, such as when passed as a `_NONNULL` parameter.
285
286#### Implicit ownership types on out parameters (`CLANG_WARN_OBJC_EXPLICIT_OWNERSHIP_TYPE`)
287Warn about implicit ownership types on Objective-C object references as out parameters. For example, declaring a parameter with type NSObject** will produce a warning because the compiler will assume that the out parameter's ownership type is `__autoreleasing`.
288
289#### Implicit Atomic Objective-C Properties (`CLANG_WARN_OBJC_IMPLICIT_ATOMIC_PROPERTIES`)
290Warn about `@property` declarations that are implicitly atomic.
291
292#### Implicit retain of `self` within blocks (`CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF`)
293Warn about implicit retains of self within blocks, which can create a retain-cycle.
294
295#### Implicit Synthesized Properties (`CLANG_WARN_OBJC_MISSING_PROPERTY_SYNTHESIS`)
296Starting in Xcode 4.4, the Apple LLVM Compiler will implicitly synthesize properties that are not explicitly synthesized using `@synthesize`. This setting warns about such implicit behavior, even though the property is still synthesized. This is essentially a backwards compatibility warning, or for those who wish to continue to explicitly use `@synthesize`.
297
298#### Repeatedly using a `__weak` reference (`CLANG_WARN_OBJC_REPEATED_USE_OF_WEAK`)
299Warn about repeatedly using a weak reference without assigning the weak reference to a strong reference. This is often symptomatic of a race condition where the weak reference can become `nil` between accesses, resulting in unexpected behavior. Assigning to temporary strong reference ensures the object stays alive during the related accesses.
300
301#### Unintentional Root Class (`CLANG_WARN_OBJC_ROOT_CLASS`)
302Warn about classes that unintentionally do not subclass a root class, such as NSObject.
303
304#### Suspicious Implicit Conversions (`CLANG_WARN_SUSPICIOUS_IMPLICIT_CONVERSION`)
305Warn about various implicit conversions that can lose information or are otherwise suspicious.
306
307#### Suspicious Moves (`CLANG_WARN_SUSPICIOUS_MOVE`)
308Warn about suspicious uses of std::move.
309
310#### Unreachable Code (`CLANG_WARN_UNREACHABLE_CODE`)
311Warns about potentially unreachable code.
312
313#### Using `__bridge` Casts Outside of ARC (`CLANG_WARN__ARC_BRIDGE_CAST_NONARC`)
314Warn about using `__bridge` casts when not using ARC, where they have no effect.
315
316#### Duplicate Method Definitions (`CLANG_WARN__DUPLICATE_METHOD_MATCH`)
317Warn about declaring the same method more than once within the same `@interface`.
318
319#### Exit-Time C++ Destructors (`CLANG_WARN__EXIT_TIME_DESTRUCTORS`)
320Warn about destructors for C++ objects that are called when an application is terminating.
321
322#### Enable Additional Vector Extensions (`CLANG_X86_VECTOR_INSTRUCTIONS`)
323Enables the use of extended vector instructions. Only used when targeting Intel architectures.
324
325#### Code Signing Entitlements (`CODE_SIGN_ENTITLEMENTS`)
326The path to a file specifying code-signing entitlements.
327
328#### Code Signing Identity (`CODE_SIGN_IDENTITY`)
329The name, also known as the common name, of a valid code-signing certificate in a keychain within your keychain path. A missing or invalid certificate will cause a build error.
330
331#### Combine High Resolution Artwork (`COMBINE_HIDPI_IMAGES`)
332Combines image files at different resolutions into one multi-page TIFF file that is HiDPI compliant for macOS 10.7 and later. Only image files in the same directory and with the same base name and extension are combined. The file names must conform to the naming convention used in HiDPI.
333
334#### Compress PNG Files (`COMPRESS_PNG_FILES`)
335If enabled, PNG resource files are compressed as they are copied.
336
337#### CONFIGURATION
338Identifies the build configuration, such as Debug or Release, that the target uses to generate the product.
339
340#### Per-configuration Build Products Path (`CONFIGURATION_BUILD_DIR`)
341The base path where build products will be placed during a build for a given configuration. By default, this is set to `$(BUILD_DIR)/$(CONFIGURATION)`.
342
343#### Per-configuration Intermediate Build Files Path (`CONFIGURATION_TEMP_DIR`)
344The base path where intermediates will be placed during a build for a given configuration. By default, this is set to `$(PROJECT_TEMP_DIR)/$(CONFIGURATION)`.
345
346#### CONTENTS_FOLDER_PATH
347Specifies the directory inside the generated bundle that contains the product’s files.
348
349#### Preserve HFS Data (`COPYING_PRESERVES_HFS_DATA`)
350Causes the copying of resources to preserve resource forks and Finder info.
351
352#### Run unifdef on Product Headers (`COPY_HEADERS_RUN_UNIFDEF`)
353If enabled, headers are run through the `unifdef(1)` tool when copied to the product.
354
355#### Unifdef Flags for Product Headers (`COPY_HEADERS_UNIFDEF_FLAGS`)
356Specifies the flags to pass to `unifdef(1)` when invoking that tool to copy headers. This setting has no effect unless Run unifdef on Product Headers (`COPY_HEADERS_RUN_UNIFDEF`) is enabled.
357
358#### Strip Debug Symbols During Copy (`COPY_PHASE_STRIP`)
359Specifies whether binary files that are copied during the build, such as in a Copy Bundle Resources or Copy Files build phase, should be stripped of debugging symbols. It does not cause the linked product of a target to be stripped—use Strip Linked Product (`STRIP_INSTALLED_PRODUCT`) for that.
360
361#### Cpp Other Preprocessor Flags (`CPP_OTHER_PREPROCESSOR_FLAGS`)
362Other flags to pass to the C preprocessor when using the standalone C Preprocessor rule.
363
364#### Cpp Prefix File (`CPP_PREFIX_HEADER`)
365Implicitly include the given file when preprocessing using the standalone C Preprocessor rule. The path given should either be a project relative path or an absolute path.
366
367#### Cpp Preprocessor Definitions (`CPP_PREPROCESSOR_DEFINITIONS`)
368Space-separated list of preprocessor macros of the form foo or foo=bar. These macros are used when preprocessing using the standalone C Preprocessor rule.
369
370#### Create `Info.plist` Section in Binary (`CREATE_INFOPLIST_SECTION_IN_BINARY`)
371Enabling this setting will create a section in the product's linked binary containing the processed `Info.plist` file for the target. This setting only applies to command-line tool targets.
372
373#### CURRENT_ARCH
374The name of the active architecture being processed.
375
376#### Current Project Version (`CURRENT_PROJECT_VERSION`)
377This setting defines the current version of the project. The value must be a integer or floating point number, such as 57 or 365.8.
378
379#### CURRENT_VARIANT
380The name of the active variant being processed.
381
382#### Dead Code Stripping (`DEAD_CODE_STRIPPING`)
383Activating this setting causes the `-dead_strip` flag to be passed to `ld(1)` via `cc(1)` to turn on dead code stripping. If this option is selected, `-gfull` (not `-gused`) must be used to generate debugging symbols in order to have them correctly stripped.
384
385#### Debug Information Format (`DEBUG_INFORMATION_FORMAT`)
386The type of debug information to produce.
387
388- DWARF: Object files and linked products will use DWARF as the debug information format. dwarf
389- DWARF with dSYM File: Object files and linked products will use DWARF as the debug information format, and Xcode will also produce a dSYM file containing the debug information from the individual object files (except that a dSYM file is not needed and will not be created for static library or object file products). dwarf-with-dsym
390
391#### Defines Module (`DEFINES_MODULE`)
392If enabled, the product will be treated as defining its own module. This enables automatic production of LLVM module map files when appropriate, and allows the product to be imported as a module.
393
394#### Deployment Location (`DEPLOYMENT_LOCATION`)
395If enabled, built products are placed in their installed locations in addition to the built products folder.
396
397#### Deployment Postprocessing (`DEPLOYMENT_POSTPROCESSING`)
398If enabled, indicates that binaries should be stripped and file mode, owner, and group information should be set to standard values.
399
400#### DERIVED_FILE_DIR
401Identifies the directory into which derived source files, such as those generated by lex and yacc, are placed.
402
403#### Development Team (`DEVELOPMENT_TEAM`)
404The team ID of a development team to use for signing certificates and provisioning profiles.
405
406#### Output Log Level (`DISTILL_LOGLEVEL`)
407This option controls the output of the distill tool.
408
409#### Distillation Mode (`DISTILL_MODE`)
410This option controls the mode under which the distill tool is run—either it can regenerate its output entirely or it can incrementally edit the existing output.
411
412#### DOCUMENTATION_FOLDER_PATH
413Identifies the directory that contains the bundle’s documentation files.
414
415#### Installation Build Products Location (`DSTROOT`)
416The path at which all products will be rooted when performing an install build. For instance, to install your products on the system proper, set this path to /. Defaults to /tmp/`$(PROJECT_NAME)`.dst to prevent a test install build from accidentally overwriting valid and needed data in the ultimate install path.
417
418Typically this path is not set per target, but is provided as an option on the command line when performing an xcodebuild install. It may also be set in a build configuration in special circumstances.
419
420#### Other DTrace Flags (`DTRACE_OTHER_FLAGS`)
421Space-separated list of additional flags to pass to the dtrace compiler. Be sure to backslash-escape any arguments that contain spaces or special characters, such as path names that may contain spaces. Use this setting if Xcode does not already provide UI for a particular dtrace flag.
422
423#### Compatibility Version (`DYLIB_COMPATIBILITY_VERSION`)
424Determines the compatibility version of the resulting library, bundle, or framework binary. See Dynamic Library Design Guidelines in Dynamic Library Programming Topics for details on assigning version numbers of dynamic libraries.
425
426#### Current Library Version (`DYLIB_CURRENT_VERSION`)
427This setting defines the current version of any framework built by the project. As with Current Project Version (`CURRENT_PROJECT_VERSION`), the value must be an integer or floating point number, such as 57 or 365.8. By default, it is set to `$(CURRENT_PROJECT_VERSION)`. See Dynamic Library Design Guidelines in Dynamic Library Programming Topics for details on assigning version numbers of dynamic libraries.
428
429#### Dynamic Library Install Name Base (`DYLIB_INSTALL_NAME_BASE`)
430Sets the base value for the internal "install path" (`LC_ID_DYLIB`) in a dynamic library. This will be combined with the `EXECUTABLE_PATH` to form the full install path. Setting Dynamic Library Install Name (`LD_DYLIB_INSTALL_NAME`) directly will override this setting. This setting defaults to the target's Installation Directory (`INSTALL_PATH`). It is ignored when building any product other than a dynamic library.
431
432#### Embed Asset Packs In Product Bundle (`EMBED_ASSET_PACKS_IN_PRODUCT_BUNDLE`)
433Embed all the built asset packs inside the product bundle. Since this negates the performance benefits of the On Demand Resources feature, it is only useful for testing purposes when it isn't practical to use an asset pack server.
434
435#### Enable Bitcode (`ENABLE_BITCODE`)
436Activating this setting indicates that the target or project should generate bitcode during compilation for platforms and architectures that support it. For Archive builds, bitcode will be generated in the linked binary for submission to the App Store. For other builds, the compiler and linker will check whether the code complies with the requirements for bitcode generation, but will not generate actual bitcode.
437
438#### ENABLE_HEADER_DEPENDENCIES
439Specifies whether to automatically track dependencies on included header files.
440
441#### Enable Incremental Distill (`ENABLE_INCREMENTAL_DISTILL`)
442Enabled the incremental distill option in the asset catalog compiler. This feature is experimental and should only be enabled with caution.
443
444#### Enable Foundation Assertions (`ENABLE_NS_ASSERTIONS`)
445Controls whether assertion logic provided by NSAssert is included in the preprocessed source code or is elided during preprocessing. Disabling assertions can improve code performance.
446
447#### Build Active Resources Only (`ENABLE_ONLY_ACTIVE_RESOURCES`)
448Omit inapplicable resources when building for a single device. For example, when building for a device with a Retina display, exclude 1x resources.
449
450#### Enable On Demand Resources (`ENABLE_ON_DEMAND_RESOURCES`)
451If enabled, tagged assets—files and asset catalog entries—are built into asset packs based on their combination of tags. Untagged resources are treated normally.
452
453#### Enable Strict Checking of objc_msgSend Calls (`ENABLE_STRICT_OBJC_MSGSEND`)
454Controls whether objc_msgSend calls must be cast to the appropriate function pointer type before being called.
455
456#### Enable Testability (`ENABLE_TESTABILITY`)
457When this setting is activated, the product will be built with options appropriate for running automated tests, such as making private interfaces accessible to the tests. This may result in tests running slower than they would without testability enabled.
458
459#### Sub-Directories to Exclude in Recursive Searches (`EXCLUDED_RECURSIVE_SEARCH_PATH_SUBDIRECTORIES`)
460This is a list of `fnmatch()`-style patterns of file or directory names to exclude when performing a recursive search. By default, this is set to `.nib` `.lproj` `.framework` `.gch` `.xcode` () `.DS_Store` CVS `.svn` `.git` `.hg`. Normally, if you override this value you should include the default values via the `$(inherited)` macro.
461
462#### EXECUTABLES_FOLDER_PATH
463Identifies the directory that contains additional binary files.
464
465#### Executable Extension (`EXECUTABLE_EXTENSION`)
466This is the extension used for the executable product generated by the target, which has a default value based on the product type.
467
468#### EXECUTABLE_FOLDER_PATH
469Identifies the directory that contains the binary the target builds.
470
471#### EXECUTABLE_NAME
472Specifies the name of the binary the target produces.
473
474#### EXECUTABLE_PATH
475Specifies the path to the binary the target produces within its bundle.
476
477#### Executable Prefix (`EXECUTABLE_PREFIX`)
478The prefix used for the executable product generated by the target, which has a default value based on the product type.
479
480#### EXECUTABLE_SUFFIX
481Specifies the suffix of the binary filename, including the character that separates the extension from the rest of the bundle name.
482
483#### Exported Symbols File (`EXPORTED_SYMBOLS_FILE`)
484This is a project-relative path to a file that lists the symbols to export. See `ld -exported_symbols_list` for details on exporting symbols.
485
486#### FRAMEWORKS_FOLDER_PATH
487Specifies the directory that contains the product’s embedded frameworks.
488
489#### Framework Search Paths (`FRAMEWORK_SEARCH_PATHS`)
490This is a list of paths to folders containing frameworks to be searched by the compiler for both included or imported header files when compiling C, Objective-C, C++, or Objective-C++, and by the linker for frameworks used by the product. Paths are delimited by whitespace, so any paths with spaces in them must be properly quoted.
491
492#### Framework Version (`FRAMEWORK_VERSION`)
493Framework bundles are versioned by having contents in subfolders of a version folder that has links to the current version and its contents.
494
495#### `char` Type Is Unsigned (`GCC_CHAR_IS_UNSIGNED_CHAR`)
496Enabling this setting causes char to be unsigned by default, disabling it causes char to be signed by default.
497
498#### CodeWarrior/MS-Style Inline Assembly (`GCC_CW_ASM_SYNTAX`)
499Enable the CodeWarrior/Microsoft syntax for inline assembly code in addition to the standard GCC syntax.
500
501#### C Language Dialect (`GCC_C_LANGUAGE_STANDARD`)
502Choose a standard or non-standard C language dialect.
503
504- ANSI C: Accept ISO C90 and ISO C++, turning off GNU extensions that are incompatible. `-ansi`
505
506    Incompatible GNU extensions include the asm, inline, and typeof keywords (but not the equivalent asm, inline, and typeof forms), and the // syntax for comments.
507
508    This setting also enables trigraphs.
509
510- C89: Accept ISO C90 (`1990`), but not GNU extensions. `-std`=c89
511- GNU89: Accept ISO C90 and GNU extensions. `-std`=gnu89
512- C99: Accept ISO C99 (`1999`), but not GNU extensions. `-std`=c99
513- GNU99: Accept ISO C99 and GNU extensions. `-std`=gnu99
514- C11: Accept ISO C11 (`2011`), but not GNU extensions. `-std`=c11
515- GNU11: Accept ISO C11 and GNU extensions. `-std`=gnu11
516- Compiler Default: Tells the compiler to use its default C language dialect. This is normally the best choice unless you have specific needs. (Currently equivalent to GNU99.)
517
518Please see the full GCC manual for the full definition of all these settings on the C dialect.
519
520#### Generate Position-Dependent Code (`GCC_DYNAMIC_NO_PIC`)
521Faster function calls for applications. Not appropriate for shared libraries, which need to be position-independent.
522
523#### Allow `asm`, `inline`, `typeof` (`GCC_ENABLE_ASM_KEYWORD`)
524Controls whether `asm`, `inline`, and `typeof` are treated as keywords or whether they can be used as identifiers.
525
526#### Recognize Built-in Functions (`GCC_ENABLE_BUILTIN_FUNCTIONS`)
527Controls whether built-in functions that do not begin with `__builtin_` as prefix are recognized.
528
529GCC normally generates special code to handle certain built-in functions more efficiently; for instance, calls to alloca may become single instructions that adjust the stack directly, and calls to memcpy may become inline copy loops. The resulting code is often both smaller and faster, but since the function calls no longer appear as such, you cannot set a breakpoint on those calls, nor can you change the behavior of the functions by linking with a different library. In addition, when a function is recognized as a built-in function, GCC may use information about that function to warn about problems with calls to that function, or to generate more efficient code, even if the resulting code still contains calls to that function. For example, warnings are given with `-Wformat` for bad calls to printf, when printf is built in, and strlen is known not to modify global memory.
530
531#### Enable C++ Exceptions (`GCC_ENABLE_CPP_EXCEPTIONS`)
532Enable C++ exception handling. Generates extra code needed to propagate exceptions. For some targets, this implies GCC will generate frame unwind information for all functions, which can produce significant data size overhead, although it does not affect execution. If you do not specify this option, GCC will enable it by default for languages like C++ that normally require exception handling, and disable it for languages like C that do not normally require it. However, you may need to enable this option when compiling C code that needs to interoperate properly with exception handlers written in C++.
533
534#### Enable C++ Runtime Types (`GCC_ENABLE_CPP_RTTI`)
535Enable generation of information about every class with virtual functions for use by the C++ runtime type identification features (dynamic_cast and typeid). If you don't use those parts of the language, you can save some space by using this flag. Note that exception handling uses the same information, but it will generate it as needed.
536
537#### Enable Exceptions (`GCC_ENABLE_EXCEPTIONS`)
538Enable exception handling. Generates extra code needed to propagate exceptions. For some targets, this implies GCC will generate frame unwind information for all functions, which can produce significant data size overhead, although it does not affect execution. If you do not specify this option, GCC will enable it by default for languages like C++ and Objective-C that normally require exception handling, and disable it for languages like C that do not normally require it. However, you may need to enable this option when compiling C code that needs to interoperate properly with exception handlers written in other languages. You may also wish to disable this option if you are compiling older programs that don't use exception handling.
539
540#### Generate Floating Point Library Calls (`GCC_ENABLE_FLOATING_POINT_LIBRARY_CALLS`)
541Generate output containing library calls for floating point.
542
543#### Kernel Development Mode (`GCC_ENABLE_KERNEL_DEVELOPMENT`)
544Activating this setting enables kernel development mode. This mode sets `-static`, `-fno-common`, `-fno-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.
545
546#### Enable Objective-C Exceptions (`GCC_ENABLE_OBJC_EXCEPTIONS`)
547This setting enables `@try`/`@catch`/`@throw` syntax for handling exceptions in Objective-C code. Only applies to Objective-C.
548
549#### Recognize Pascal Strings (`GCC_ENABLE_PASCAL_STRINGS`)
550Recognize and construct Pascal-style string literals. Its use in new code is discouraged.
551
552Pascal string literals take the form `\pstring` . The special escape sequence \p denotes the Pascal length byte for the string, and will be replaced at compile time with the number of characters that follow. The p may only appear at the beginning of a string literal, and may not appear in wide string literals or as an integral constant.
553
554#### Enable SSE3 Extensions (`GCC_ENABLE_SSE3_EXTENSIONS`)
555Specifies whether the binary uses the built-in functions that provide access to the SSE3 extensions to the IA-32 architecture.
556
557#### Enable SSE4.1 Extensions (`GCC_ENABLE_SSE41_EXTENSIONS`)
558Specifies whether the binary uses the built-in functions that provide access to the SSE4.1 extensions to the IA-32 architecture.
559
560#### Enable SSE4.2 Extensions (`GCC_ENABLE_SSE42_EXTENSIONS`)
561Specifies whether the binary uses the built-in functions that provide access to the SSE4.2 extensions to the IA-32 architecture.
562
563#### Enable Trigraphs (`GCC_ENABLE_TRIGRAPHS`)
564Controls whether or not trigraphs are permitted in the source code.
565
566#### Relax IEEE Compliance (`GCC_FAST_MATH`)
567Enables some floating point optimizations that are not IEEE754-compliant, but which usually work. Programs that require strict IEEE compliance may not work with this option.
568
569#### Generate Debug Symbols (`GCC_GENERATE_DEBUGGING_SYMBOLS`)
570Enables or disables generation of debug symbols. When debug symbols are enabled, the level of detail can be controlled by the Level of Debug Symbols build setting.
571
572#### Generate Legacy Test Coverage Files (`GCC_GENERATE_TEST_COVERAGE_FILES`)
573Activating this setting causes a `notes` file to be produced that the gcov code-coverage utility can use to show program coverage.
574
575#### Increase Sharing of Precompiled Headers (`GCC_INCREASE_PRECOMPILED_HEADER_SHARING`)
576Enabling this option will enable increased sharing of precompiled headers among targets that share the same prefix header and precompiled header directory.
577
578Xcode distinguishes between precompiled header (PCH) files by generating a hash value based on the command-line options to the compiler used to create the PCH. Enabling this option will exclude certain compiler options from that hash. Presently this option will exclude search path options (-I, `-iquote`, `-isystem`, `-F`, `-L`) from the hash.
579
580Enabling increased sharing of PCH files carries some risk—if two targets use the same prefix header but have different include paths that cause the prefix header to include different files when they are precompiled, then subtle problems may result because one target will use a PCH that was built using files included by the other target. In this case, this option must be turned off in order to enforce correctness.
581
582#### Inline Methods Hidden (`GCC_INLINES_ARE_PRIVATE_EXTERN`)
583When enabled, out-of-line copies of inline methods are declared `private extern`.
584
585#### Compile Sources As (`GCC_INPUT_FILETYPE`)
586Specifies whether to compile each source file according to its file type, or whether to treat all source files in the target as if they are of a specific language.
587
588#### Instrument Program Flow (`GCC_INSTRUMENT_PROGRAM_FLOW_ARCS`)
589Activating this setting indicates that code should be added so program flow arcs are instrumented.
590
591#### Enable Linking With Shared Libraries (`GCC_LINK_WITH_DYNAMIC_LIBRARIES`)
592Enabling this option allows linking with the shared libraries. This is the default for most product types.
593
594#### No Common Blocks (`GCC_NO_COMMON_BLOCKS`)
595In C, allocate even uninitialized global variables in the data section of the object file, rather than generating them as common blocks. This has the effect that if the same variable is declared (without `extern`) in two different compilations, you will get an error when you link them.
596
597#### Optimization Level (`GCC_OPTIMIZATION_LEVEL`)
598Specifies the degree to which the generated code is optimized for speed and binary size.
599
600- None: Do not optimize. `-O0`
601
602    With this setting, the compiler's goal is to reduce the cost of compilation and to make debugging produce the expected results. Statements are independent—if you stop the program with a breakpoint between statements, you can then assign a new value to any variable or change the program counter to any other statement in the function and get exactly the results you would expect from the source code.
603
604- Fast: Optimizing compilation takes somewhat more time, and a lot more memory for a large function. `-O1`
605
606    With this setting, the compiler tries to reduce code size and execution time, without performing any optimizations that take a great deal of compilation time. In Apple's compiler, strict aliasing, block reordering, and inter-block scheduling are disabled by default when optimizing.
607
608- Faster: The compiler performs nearly all supported optimizations that do not involve a space-speed tradeoff. `-O2`
609
610    With this setting, the compiler does not perform loop unrolling or function inlining, or register renaming. As compared to the `Fast` setting, this setting increases both compilation time and the performance of the generated code.
611
612- Fastest: Turns on all optimizations specified by the Faster setting and also turns on function inlining and register renaming options. This setting may result in a larger binary. `-O3`\
613- Fastest, Smallest: Optimize for size: This setting enables all Faster optimizations that do not typically increase code size. It also performs further optimizations designed to reduce code size. `-Os`
614- Fastest, Aggressive Optimizations: This setting enables Fastest but also enables aggressive optimizations that may break strict standards compliance but should work well on well-behaved code. `-Ofast`
615
616#### Precompile Prefix Header (`GCC_PRECOMPILE_PREFIX_HEADER`)
617Generates a precompiled header for the prefix header, which should reduce overall build times.
618
619Note: Precompiling the prefix header will be most effective if the contents of the prefix header or any file it includes change rarely. If the contents of the prefix header or any file it includes change frequently, there may be a negative impact to overall build time.
620
621#### Prefix Header (`GCC_PREFIX_HEADER`)
622Implicitly include the named header. The path given should either be a project relative path or an absolute path.
623
624#### Preprocessor Macros (`GCC_PREPROCESSOR_DEFINITIONS`)
625Space-separated list of preprocessor macros of the form foo or foo=bar.
626
627#### Preprocessor Macros Not Used In Precompiled Headers (`GCC_PREPROCESSOR_DEFINITIONS_NOT_USED_IN_PRECOMPS`)
628Space-separated list of preprocessor macros of the form foo or foo=bar. These macros are not used when precompiling a prefix header file.
629
630#### Make Strings Read-Only (`GCC_REUSE_STRINGS`)
631Reuse string literals.
632
633#### Short Enumeration Constants (`GCC_SHORT_ENUMS`)
634Make enums only as large as needed for the range of possible values.
635
636WARNING: This setting generates code that may not binary compatible with code generated without this setting or with macOS frameworks.
637
638#### Enforce Strict Aliasing (`GCC_STRICT_ALIASING`)
639Optimize code by making more aggressive assumptions about whether pointers can point to the same objects as other pointers. Programs that use pointers a lot may benefit from this, but programs that don't strictly follow the ISO C rules about the type with which an object may be accessed may behave unexpectedly.
640
641#### Symbols Hidden by Default (`GCC_SYMBOLS_PRIVATE_EXTERN`)
642When enabled, all symbols are declared `private extern` unless explicitly marked to be exported using `attribute((visibility("default")))` in code. If not enabled, all symbols are exported unless explicitly marked as `private extern`. See Controlling Symbol Visibility in C++ Runtime Environment Programming Guide.
643
644#### Statics are Thread-Safe (`GCC_THREADSAFE_STATICS`)
645Emits extra code to use the routines specified in the C++ ABI for thread-safe initialization of local statics. You can disable this option to reduce code size slightly in code that doesn't need to be thread-safe.
646
647#### Treat Missing Function Prototypes as Errors (`GCC_TREAT_IMPLICIT_FUNCTION_DECLARATIONS_AS_ERRORS`)
648Causes warnings about missing function prototypes to be treated as errors. Only applies to C and Objective-C.
649
650#### Treat Incompatible Pointer Type Warnings as Errors (`GCC_TREAT_INCOMPATIBLE_POINTER_TYPE_WARNINGS_AS_ERRORS`)
651Enabling this option causes warnings about incompatible pointer types to be treated as errors.
652
653#### Treat Warnings as Errors (`GCC_TREAT_WARNINGS_AS_ERRORS`)
654Enabling this option causes all warnings to be treated as errors.
655
656#### Unroll Loops (`GCC_UNROLL_LOOPS`)
657Unrolls loops. Unrolling makes the code larger, but may make it faster by reducing the number of branches executed.
658
659#### Use Standard System Header Directory Searching (`GCC_USE_STANDARD_INCLUDE_SEARCHING`)
660Controls whether the standard system directories are searched for header files. When disabled, only the directories you have specified with `-I` options (and the directory of the current file, if appropriate) are searched.
661
662#### Compiler for C/C++/Objective-C (`GCC_VERSION`)
663The compiler to use for C, C++, and Objective-C.
664
665#### Implicit Conversion to 32 Bit Type (`GCC_WARN_64_TO_32_BIT_CONVERSION`)
666Warn if a value is implicitly converted from a 64-bit type to a 32-bit type.
667
668#### Deprecated Functions (`GCC_WARN_ABOUT_DEPRECATED_FUNCTIONS`)
669Warn about the use of deprecated functions, variables, and types (as indicated by the deprecated attribute).
670
671#### Undefined Use of offsetof Macro (`GCC_WARN_ABOUT_INVALID_OFFSETOF_MACRO`)
672Unchecking this setting will suppress warnings from applying the offsetof macro to a non-POD type. According to the 1998 ISO C++ standard, applying offsetof to a non-POD type is undefined. In existing C++ implementations, however, offsetof typically gives meaningful results even when applied to certain kinds of non-POD types, such as a simple struct that fails to be a POD type only by virtue of having a constructor. This flag is for users who are aware that they are writing nonportable code and who have deliberately chosen to ignore the warning about it.
673
674The restrictions on offsetof may be relaxed in a future version of the C++ standard.
675
676#### Missing Fields in Structure Initializers (`GCC_WARN_ABOUT_MISSING_FIELD_INITIALIZERS`)
677Warn if a structure's initializer has some fields missing. For example, the following code would cause such a warning because x.h is implicitly zero:
678
679    ```c
680    struct s { int f, g, h; };
681
682    struct s x = { 3, 4 };
683    ```
684
685This option does not warn about designated initializers, so the following modification would not trigger a warning:
686
687    ```c
688    struct s { int f, g, h; };
689    struct s x = { `.f` = 3, `.g` = 4 };
690    ```
691
692#### Missing Newline At End Of File (`GCC_WARN_ABOUT_MISSING_NEWLINE`)
693Warn when a source file does not end with a newline.
694
695#### Missing Function Prototypes (`GCC_WARN_ABOUT_MISSING_PROTOTYPES`)
696Causes warnings to be emitted about missing prototypes.
697
698#### Pointer Sign Comparison (`GCC_WARN_ABOUT_POINTER_SIGNEDNESS`)
699Warn when pointers passed via arguments or assigned to a variable differ in sign.
700
701#### Mismatched Return Type (`GCC_WARN_ABOUT_RETURN_TYPE`)
702Causes warnings to be emitted when a function with a defined return type (not void) contains a return statement without a return-value. Also emits a warning when a function is defined without specifying a return type.
703
704#### Incomplete Objective-C Protocols (`GCC_WARN_ALLOW_INCOMPLETE_PROTOCOL`)
705Warn if methods required by a protocol are not implemented in the class adopting it. Only applies to Objective-C.
706
707#### Check Switch Statements (`GCC_WARN_CHECK_SWITCH_STATEMENTS`)
708Warn whenever a switch statement has an index of enumeral type and lacks a case for one or more of the named codes of that enumeration. The presence of a default label prevents this warning. Case labels outside the enumeration range also provoke warnings when this option is used.
709
710#### Four Character Literals (`GCC_WARN_FOUR_CHARACTER_CONSTANTS`)
711Warn about four-char literals (for example, macOS-style OSTypes: APPL).
712
713#### Overloaded Virtual Functions (`GCC_WARN_HIDDEN_VIRTUAL_FUNCTIONS`)
714Warn when a function declaration hides virtual functions from a base class.
715
716For example, in the following example, the A class version of `f()` is hidden in B.
717
718    ```c
719    struct A {
720      virtual void `f()`;
721    };
722    struct B: public A {
723      void `f(int)`;
724    };
725    ```
726
727As a result, the following code will fail to compile.
728
729    ```c
730    B* b;
731    b->f();
732    ```
733
734This setting only applies to C++ and Objective-C++ sources.
735
736#### Inhibit All Warnings (`GCC_WARN_INHIBIT_ALL_WARNINGS`)
737Inhibit all warning messages.
738
739#### Initializer Not Fully Bracketed (`GCC_WARN_INITIALIZER_NOT_FULLY_BRACKETED`)
740Warn if an aggregate or union initializer is not fully bracketed. In the following example, the initializer for a is not fully bracketed, but the initializer for b is fully bracketed.
741
742    ```c
743    int a`2``2` = { 0, 1, 2, 3 };
744    int b`2``2` = { { 0, 1 }, { 2, 3 } };
745    ```
746
747#### Missing Braces and Parentheses (`GCC_WARN_MISSING_PARENTHESES`)
748Warn if parentheses are omitted in certain contexts, such as when there is an assignment in a context where a truth value is expected, or when operators are nested whose precedence causes confusion. Also, warn about constructions where there may be confusion as to which if statement an else branch belongs. For example:
749
750    ```c
751    {
752      if (`a`)
753        if (`b`)
754          foo ();
755      else
756        bar ();
757    }
758    ```
759
760In C, every else branch belongs to the innermost possible if statement, which in the example above is if (`b`). This is often not what the programmer expects, as illustrated by indentation used in the example above. This build setting causes GCC to issue a warning when there is the potential for this confusion. To eliminate the warning, add explicit braces around the innermost if statement so there is no way the else could belong to the enclosing if. For example:
761
762    ```c
763    {
764      if (`a`)
765        {
766          if (`b`)
767            foo ();
768          else
769            bar ();
770        }
771    }
772    ```
773
774#### Nonvirtual Destructor (`GCC_WARN_NON_VIRTUAL_DESTRUCTOR`)
775Warn when a class declares an nonvirtual destructor that should probably be virtual, because it looks like the class will be used polymorphically. This is only active for C++ or Objective-C++ sources.
776
777#### Pedantic Warnings (`GCC_WARN_PEDANTIC`)
778Issue all the warnings demanded by strict ISO C and ISO C++; reject all programs that use forbidden extensions, and some other programs that do not follow ISO C and ISO C++. For ISO C, follows the version of the ISO C standard specified by any `-std` option used.
779
780#### Hidden Local Variables (`GCC_WARN_SHADOW`)
781Warn whenever a local variable shadows another local variable, parameter or global variable or whenever a builtin function is shadowed.
782
783#### Sign Comparison (`GCC_WARN_SIGN_COMPARE`)
784Warn when a comparison between signed and unsigned values could produce an incorrect result when the signed value is converted to unsigned.
785
786#### Strict Selector Matching (`GCC_WARN_STRICT_SELECTOR_MATCH`)
787Warn if multiple methods with differing argument and/or return types are found for a given selector when attempting to send a message using this selector to a receiver of type id or Class. When this setting is disabled, the compiler will omit such warnings if any differences found are confined to types that share the same size and alignment.
788
789#### Typecheck Calls to printf/scanf (`GCC_WARN_TYPECHECK_CALLS_TO_PRINTF`)
790Check calls to printf and scanf to make sure that the arguments supplied have types appropriate to the format string specified, and that the conversions specified in the format string make sense.
791
792#### Undeclared Selector (`GCC_WARN_UNDECLARED_SELECTOR`)
793Warn if a `@selector(...)` expression referring to an undeclared selector is found. A selector is considered undeclared if no method with that name has been declared before the `@selector(...)` expression, either explicitly in an `@interface` or `@protocol` declaration, or implicitly in an `@implementation` section. This option always performs its checks as soon as a `@selector(...)` expression is found, while `-Wselector` only performs its checks in the final stage of compilation. This also enforces the coding style convention that methods and selectors must be declared before being used.
794
795#### Uninitialized Variables (`GCC_WARN_UNINITIALIZED_AUTOS`)
796Warn if a variable might be clobbered by a `setjmp` call or if an automatic variable is used without prior initialization.
797
798Note: The compiler may not detect all cases where an automatic variable is initialized or all usage patterns that may lead to use prior to initialization. You can toggle between the normal uninitialized value checking or the more aggressive (`conservative`) checking, which finds more issues but the checking is much stricter.
799
800#### Unknown Pragma (`GCC_WARN_UNKNOWN_PRAGMAS`)
801Warn when a `#pragma` directive is encountered that is not understood by GCC. If this command line option is used, warnings will even be issued for unknown pragmas in system header files. This is not the case if the warnings were only enabled by the `-Wall` command-line option.
802
803#### Unused Functions (`GCC_WARN_UNUSED_FUNCTION`)
804Warn whenever a static function is declared but not defined or a noninline static function is unused.
805
806#### Unused Labels (`GCC_WARN_UNUSED_LABEL`)
807Warn whenever a label is declared but not used.
808
809#### Unused Parameters (`GCC_WARN_UNUSED_PARAMETER`)
810Warn whenever a function parameter is unused aside from its declaration.
811
812#### Unused Values (`GCC_WARN_UNUSED_VALUE`)
813Warn whenever a statement computes a result that is explicitly not used.
814
815#### Unused Variables (`GCC_WARN_UNUSED_VARIABLE`)
816Warn whenever a local variable or nonconstant static variable is unused aside from its declaration.
817
818#### Perform Single-Object Prelink (`GENERATE_MASTER_OBJECT_FILE`)
819Activating this setting will cause the object files built by a target to be prelinked using `ld -r` into a single object file, and that object file will then be linked into the final product. This is useful to force the linker to resolve symbols and link the object files into a single module before building a static library. Also, a separate set of link flags can be applied to the prelink allowing additional control over, for instance, exported symbols.
820
821#### Force Package Info Generation (`GENERATE_PKGINFO_FILE`)
822Forces the PkgInfo file to be written to wrapped products even if this file is not expected.
823
824#### Generate Profiling Code (`GENERATE_PROFILING_CODE`)
825Activating this setting will cause the compiler and linker to generate profiling code. For example, GCC will generate code suitable for use with `gprof(1)`.
826
827#### Enable Text-Based Stubs Generation (`GENERATE_TEXT_BASED_STUBS`)
828Enables the generation of Text-Based stubs for dynamic libraries and frameworks.
829
830#### HEADERMAP_INCLUDES_FLAT_ENTRIES_FOR_TARGET_BEING_BUILT
831Specifies whether the header map contains a name/path entry for every header in the target being built.
832
833#### HEADERMAP_INCLUDES_FRAMEWORK_ENTRIES_FOR_ALL_PRODUCT_TYPES
834Specifies whether the header map contains a framework-name/path entry for every header in the target being built, including targets that do not build frameworks.
835
836#### HEADERMAP_INCLUDES_PROJECT_HEADERS
837Specifies whether the header map contains a name/path entry for every header in the project, regardless of the headers’ target membership.
838
839#### Header Search Paths (`HEADER_SEARCH_PATHS`)
840This is a list of paths to folders to be searched by the compiler for included or imported header files when compiling C, Objective-C, C++, or Objective-C++. Paths are delimited by whitespace, so any paths with spaces in them need to be properly quoted.
841
842#### Auto-Activate Custom Fonts (`IBC_COMPILER_AUTO_ACTIVATE_CUSTOM_FONTS`)
843Instructs the XIB compiler to add custom fonts to the application's `Info.plist`, which will cause the fonts to activate upon application launch.
844
845#### Show Errors (`IBC_ERRORS`)
846Show errors encountered during the compilation of XIB files.
847
848#### Flatten Compiled XIB Files (`IBC_FLATTEN_NIBS`)
849If enabled, compile XIB files into flattened (non-wrapper) NIB files. After flattening, the resulting NIB is more compact but no longer editable by Interface Builder. When this option is disabled, the resulting NIB file remains editable in Interface Builder.
850
851#### Default Module (`IBC_MODULE`)
852Defines the module name for Swift classes referenced without a specific module name.
853
854#### Show Notices (`IBC_NOTICES`)
855Show notices encountered during the compilation of XIB files.
856
857#### Other Interface Builder Compiler Flags (`IBC_OTHER_FLAGS`)
858A list of additional flags to pass to the Interface Builder Compiler. Use this setting if Xcode does not already provide UI for a particular Interface Builder Compiler flag.
859
860#### Overriding Plug-In and Framework Directory (`IBC_OVERRIDING_PLUGINS_AND_FRAMEWORKS_DIR`)
861Instructs Interface Builder to load frameworks and Interface Builder plugins from the specified directory. Setting this value to `$(BUILD_DIR)/$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)` will ensure that Interface Builder will load frameworks and plug-ins from the built products directory of the current build configuration.
862
863#### Plug-Ins (`IBC_PLUGINS`)
864A list of paths to Interface Builder plugins to load when compiling XIB files.
865
866#### Plug-In Search Paths (`IBC_PLUGIN_SEARCH_PATHS`)
867A list of paths to be searched for Interface Builder plug-ins to load when compiling XIB files.
868
869#### Strip NIB Files (`IBC_STRIP_NIBS`)
870`IBC_STRIP_NIBS`
871
872#### Show Warnings (`IBC_WARNINGS`)
873Show warnings encountered during the compilation of XIB files.
874
875#### Auto-Activate Custom Fonts (`IBSC_COMPILER_AUTO_ACTIVATE_CUSTOM_FONTS`)
876Instructs the Storyboard compiler to add custom fonts to the application's `Info.plist` that will cause the fonts to activate upon application launch.
877
878#### Show Errors (`IBSC_ERRORS`)
879Show errors encountered during the compilation of Storyboard files.
880
881#### Flatten Compiled Storyboard Files (`IBSC_FLATTEN_NIBS`)
882Compiles a Storyboard file into flattened (non-wrapper) Storyboard file. After flattening, the resulting Storyboard is more compact but no longer editable by Interface Builder. When this option is disabled, the resulting Storyboard file remains editable in Interface Builder.
883
884#### Default Module (`IBSC_MODULE`)
885Defines the module name for Swift classes referenced without a specific module name.
886
887#### Show Notices (`IBSC_NOTICES`)
888Show notices encountered during the compilation of Storyboard files.
889
890#### Other Storyboard Compiler Flags (`IBSC_OTHER_FLAGS`)
891A list of additional flags to pass to the Interface Builder Compiler. Use this setting if Xcode does not already provide UI for a particular Interface Builder Compiler flag.
892
893#### Strip Storyboardc Files (`IBSC_STRIP_NIBS`)
894`IBSC_STRIP_NIBS`
895
896#### Show Warnings (`IBSC_WARNINGS`)
897Show warnings encountered during the compilation of Storyboard files.
898
899#### Sub-Directories to Include in Recursive Searches (`INCLUDED_RECURSIVE_SEARCH_PATH_SUBDIRECTORIES`)
900This is a list of `fnmatch()`-style patterns of file or directory names to include when performing a recursive search. By default, this list is empty and is only customized when you want to provide exceptions to the list of filename patterns provided in Sub-Directories to Exclude in Recursive Searches (`EXCLUDED_RECURSIVE_SEARCH_PATH_SUBDIRECTORIES`).
901
902#### Expand Build Settings in `Info.plist` File (`INFOPLIST_EXPAND_BUILD_SETTINGS`)
903Expand build settings in the `Info.plist` file.
904
905#### `Info.plist` File (`INFOPLIST_FILE`)
906The project-relative path to the property list file that contains the `Info.plist` information used by bundles. For details on information property list files, see Information Property List Files in Runtime Configuration Guidelines.
907
908#### `Info.plist` Other Preprocessor Flags (`INFOPLIST_OTHER_PREPROCESSOR_FLAGS`)
909Other flags to pass to the C preprocessor when preprocessing the `Info.plist` file.
910
911#### `Info.plist` Output Encoding (`INFOPLIST_OUTPUT_FORMAT`)
912Specifies the output encoding for the output `Info.plist`. The output encodings can be `binary` or `XML`. By default, the output encoding will be unchanged from the input.
913
914#### INFOPLIST_PATH
915Specifies the path to the bundle’s information property list file.
916
917#### `Info.plist` Preprocessor Prefix File (`INFOPLIST_PREFIX_HEADER`)
918Implicitly include the given file when preprocessing the `Info.plist` file. The path given should either be a project relative path or an absolute path.
919
920#### Preprocess `Info.plist` File (`INFOPLIST_PREPROCESS`)
921Preprocess the `Info.plist` file using the C Preprocessor.
922
923#### `Info.plist` Preprocessor Definitions (`INFOPLIST_PREPROCESSOR_DEFINITIONS`)
924Space-separated list of preprocessor macros of the form foo or foo=bar. These macros are used when preprocessing the `Info.plist` file.
925
926#### INFOSTRINGS_PATH
927Specifies the file that contains the bundle’s localized strings file.
928
929#### Initialization Routine (`INIT_ROUTINE`)
930This is the name of the routine to use for initialization.
931
932#### Enable Text-Based Stubs Inlining (`INLINE_PRIVATE_FRAMEWORKS`)
933Enables private framework inlining for Text-Based Stubs.
934
935#### Perform Copy Files Phases During `installhdrs` (`INSTALLHDRS_COPY_PHASE`)
936Specifies whether the target’s Copy Files build phases are executed in `install-header` builds.
937
938#### Perform Shell Script Phases During `installhdrs` (`INSTALLHDRS_SCRIPT_PHASE`)
939Specifies whether the target’s Run Script build phases are executed in `install-header` builds. See Active Build Action (`ACTION`) for details on `install-header` builds.
940
941#### INSTALL_DIR
942Identifies the directory in the developer’s filesystem into which the installed product is placed.
943
944#### Install Group (`INSTALL_GROUP`)
945The group name or `gid` for installed products.
946
947#### Install Permissions (`INSTALL_MODE_FLAG`)
948Permissions used for installed product files.
949
950#### Install Owner (`INSTALL_OWNER`)
951The owner name or `uid` for installed products.
952
953#### Installation Directory (`INSTALL_PATH`)
954The directory in which to install the build products. This path is prepended by the Installation Build Products Location (`DSTROOT`).
955
956#### Preserve Private External Symbols (`KEEP_PRIVATE_EXTERNS`)
957Activating this setting will preserve private external symbols, rather than turning them into static symbols. This setting is also respected when performing a single-object prelink.
958
959#### Path to Linker Dependency Info File (`LD_DEPENDENCY_INFO_FILE`)
960This setting defines the path to which the linker should emit information about what files it used as inputs and generated. Xcode uses this information for its dependency tracking. Setting the value of this setting to empty will disable passing this option to the linker.
961
962#### Dynamic Library Install Name (`LD_DYLIB_INSTALL_NAME`)
963Sets an internal install path (`LC_ID_DYLIB`) in a dynamic library. Any clients linked against the library will record that path as the way dyld should locate this library. If this option is not specified, then the `-o` path will be used. This setting is ignored when building any product other than a dynamic library. See Dynamic Library Programming Topics.
964
965#### Write Link Map File (`LD_GENERATE_MAP_FILE`)
966Activating this setting will cause the linker to write a map file to disk, which details all symbols and their addresses in the output image. The path to the map file is defined by the Path to Link Map File (`LD_MAP_FILE_PATH`) setting.
967
968#### Path to Link Map File (`LD_MAP_FILE_PATH`)
969This setting defines the path to the map file written by the linker when the Write Link Map File (`LD_GENERATE_MAP_FILE`) setting is activated. By default, a separate file will be written for each architecture and build variant, and these will be generated in the Intermediates directory for the target whose product is being linked.
970
971#### Generate Position-Dependent Executable (`LD_NO_PIE`)
972Activating this setting will prevent Xcode from building a main executable that is position independent (PIE). When targeting macOS 10.7 or later, PIE is the default for main executables, so activating this setting will change that behavior. When targeting OS X10.6 or earlier, or when building for i386, PIE is not the default, so activating this setting does nothing.
973
974You cannot create a PIE from `.o` files compiled with `-mdynamic-no-pic`. Using PIE means the codegen is less optimal, but the address randomization adds some security.
975
976#### Quote Linker Arguments (`LD_QUOTE_LINKER_ARGUMENTS_FOR_COMPILER_DRIVER`)
977This setting controls whether arguments to the linker should be quoted using `-Xlinker`. By default, Xcode invokes the linker by invoking the driver of the compiler used to build the source files in the target, and passing `-Xlinker` to quote arguments will cause the compiler driver to pass them through to the linker (rather than trying to evaluate them within the driver). By default, this setting is enabled. Disabling it will cause Xcode to not use `-Xlinker` to pass arguments to the linker. Disabling this setting is useful if the target has instructed Xcode to use an alternate linker (for example, by setting the LD setting to the path to another linker) and that alternate linker does not recognize `-Xlinker`.
978
979#### Runpath Search Paths (`LD_RUNPATH_SEARCH_PATHS`)
980This is a list of paths to be added to the runpath search path list for the image being created. At runtime, dyld uses the runpath when searching for dylibs whose load path begins with `@rpath/`. See Dynamic Library Programming Topics.
981
982#### Other Lex Flags (`LEXFLAGS`)
983Space-separated list of additional flags to pass to lex. Be sure to backslash-escape any arguments that contain spaces or special characters, such as path names that may contain spaces. Use this setting if Xcode does not already provide UI for a lex flag.
984
985#### Generate Case-Insensitive Scanner (`LEX_CASE_INSENSITIVE_SCANNER`)
986Enabling this option causes lex to generate a case-insensitive scanner. The case of letters given in the lex input patterns will be ignored, and tokens in the input will be matched regardless of case. The matched text given in yytext will have the preserved case (for example, it will not be folded).
987
988#### Insert `#line` Directives (`LEX_INSERT_LINE_DIRECTIVES`)
989Enabling this option instructs lex to insert `#line` directives so error messages in the actions will be correctly located with respect to either the original lex input file (if the errors are due to code in the input file), or `lex.yy.c` (if the errors are lex's fault). This option is enabled by default; disabling it passes a flag to lex to not insert `#line` directives.
990
991#### Suppress Default Rule (`LEX_SUPPRESS_DEFAULT_RULE`)
992Enabling this option causes the default rule (that unmatched scanner input is echoed to stdout) to be suppressed. If the scanner encounters input that does not match any of its rules, it aborts with an error. This option is useful for finding holes in a scanner's rule set.
993
994#### Suppress Warning Messages (`LEX_SUPPRESS_WARNINGS`)
995Enabling this option causes lex to suppress its warning messages.
996
997#### Library Search Paths (`LIBRARY_SEARCH_PATHS`)
998This is a list of paths to folders to be searched by the linker for libraries used by the product. Paths are delimited by whitespace, so any paths with spaces in them need to be properly quoted.
999
1000#### Display Mangled Names (`LINKER_DISPLAYS_MANGLED_NAMES`)
1001Activating this setting causes the linker to display mangled names for C++ symbols. Normally, this is not recommended, but turning it on can help to diagnose and solve C++ link errors.
1002
1003#### Link With Standard Libraries (`LINK_WITH_STANDARD_LIBRARIES`)
1004When this setting is enabled, the compiler driver will automatically pass its standard libraries to the linker to use during linking. If desired, this flag can be used to disable linking with the standard libraries, and then individual libraries can be passed as Other Linker Flags (`OTHER_LDFLAGS`).
1005
1006#### Link-Time Optimization (`LLVM_LTO`)
1007Enabling this setting allows optimization across file boundaries during linking.
1008
1009- No: Disabled. Do not use link-time optimization.
1010- Monolithic Link-Time Optimization: This mode performs monolithic link-time optimization of binaries, combining all executable code into a single unit and running aggressive compiler optimizations.
1011- Incremental Link-Time Optimization: This mode performs partitioned link-time optimization of binaries, inlining between compilation units and running aggressive compiler optimizations on each unit in parallel. This enables fast incremental builds and uses less memory than Monolithic LTO.
1012
1013#### Mach-O Type (`MACH_O_TYPE`)
1014This setting determines the format of the produced binary and how it can be linked when building other binaries. For information on binary types, see Building Mach-O Files in Mach-O Programming Topics.
1015
1016- Executable: Executables and standalone binaries and cannot be linked. mh_execute
1017- Dynamic Library: Dynamic libraries are linked at build time and loaded automatically when needed. mh_dylib
1018- Bundle: Bundle libraries are loaded explicitly at run time. mh_bundle
1019- Static Library: Static libraries are linked at build time and loaded at execution time. staticlib
1020- Relocatable Object File: Object files are single-module files that are linked at build time. mh_object
1021
1022#### macOS Deployment Target (`MACOSX_DEPLOYMENT_TARGET`)
1023Code will load on this and later versions of macOS. Framework APIs that are unavailable in earlier versions will be weak-linked; your code should check for null function pointers or specific system versions before calling newer APIs.
1024
1025#### Suppress all mapc warnings (`MAPC_NO_WARNINGS`)
1026Compile `.xcmappingmodel` files into `.cdm` without reporting warnings.
1027
1028#### Module Map File (`MODULEMAP_FILE`)
1029This is the project-relative path to the LLVM module map file that defines the module structure for the compiler. If empty, it will be automatically generated for appropriate products when Defines Module (`DEFINES_MODULE`) is enabled.
1030
1031#### Private Module Map File (`MODULEMAP_PRIVATE_FILE`)
1032This is the project-relative path to the LLVM module map file that defines the module structure for private headers.
1033
1034#### MODULE_CACHE_DIR
1035Absolute path of folder in which compiler stores its cached modules—this cache is a performance improvement.
1036
1037#### Module Identifier (`MODULE_NAME`)
1038This is the identifier of the kernel module listed in the generated stub. This is only used when building kernel extensions.
1039
1040#### Module Start Routine (`MODULE_START`)
1041This defines the name of the kernel module start routine. This is only used when building kernel extensions.
1042
1043#### Module Stop Routine (`MODULE_STOP`)
1044This defines the name of the kernel module stop routine. This is only used when building kernel extensions.
1045
1046#### Module Version (`MODULE_VERSION`)
1047This is the version of the kernel module listed in the generated stub. This is only used when building kernel extensions.
1048
1049#### Suppress momc warnings for delete rules (`MOMC_NO_DELETE_RULE_WARNINGS`)
1050Suppress managed object model compiler (`momc`) warnings for delete rules during the compilation of `.xcdatamodel(d)` files.
1051
1052#### Suppress momc warnings on missing inverse relationships (`MOMC_NO_INVERSE_RELATIONSHIP_WARNINGS`)
1053Suppress managed object model compiler (`momc`) warnings from output on missing inverse relationships during the compilation of `.xcdatamodel(d)` files
1054
1055#### Suppress momc warnings for entities with more than 100 properties (`MOMC_NO_MAX_PROPERTY_COUNT_WARNINGS`)
1056Suppress managed object model compiler (`momc`) warnings from output on entities with more than 100 properties during the compilation of `.xcdatamodel(d)` files.
1057
1058#### Suppress all momc warnings (`MOMC_NO_WARNINGS`)
1059Suppress managed object model compiler (`momc`) warnings from output during the compilation of `.xcdatamodel(d)` files
1060
1061#### Suppress momc error on transient inverse relationships (`MOMC_SUPPRESS_INVERSE_TRANSIENT_ERROR`)
1062Suppress managed object model compiler (`momc`) warnings from output on transient inverse relationships during the compilation of `.xcdatamodel(d)` files. This is only intended to be used on 10.4.x created models that compiled properly in 10.4.x before the error was introduced in 10.5
1063
1064#### Other Nasm Flags (`NASM_OTHER_FLAGS`)
1065Space-separated list of additional flags to pass to the nasm assembler. Be sure to backslash-escape any arguments that contain spaces or special characters, such as path names that may contain spaces. Use this setting if Xcode does not already provide UI for a particular nasm flag.
1066
1067#### Nasm Preinclude File (`NASM_PREINCLUDE_FILE`)
1068Specifies a file to be preincluded, before the main source file starts to be processed.
1069
1070#### NATIVE_ARCH
1071Identifies the architecture on which the build is being performed.
1072
1073#### OBJECT_FILE_DIR
1074Partially identifies the directory into which variant object files are placed. The complete specification is computed using the variants of this build setting.
1075
1076#### Intermediate Build Files Path (`OBJROOT`)
1077The path where intermediate files will be placed during a build. Intermediate files include generated sources, object files, etc. Shell script build phases can place and access files here, as well. Typically this path is not set per target, but is set per project or per user. By default, this is set to `$(PROJECT_DIR)`/build.
1078
1079#### Build Active Architecture Only (`ONLY_ACTIVE_ARCH`)
1080If enabled, only the active architecture is built.
1081
1082#### On Demand Resources Initial Install Tags (`ON_DEMAND_RESOURCES_INITIAL_INSTALL_TAGS`)
1083Defined a set of initial On Demand Resources tags to be downloaded and installed with your application.
1084
1085#### On Demand Resources Prefetch Order (`ON_DEMAND_RESOURCES_PREFETCH_ORDER`)
1086Once your app is installed, this defined a set of On Demand Resources tags that should be downloaded. These tags are downloaded after the initial installation of your application, and will be downloaded in the order the tags provided in the list from first to last.
1087
1088#### OpenCL Architectures (`OPENCL_ARCHS`)
1089A list of the architectures for which the product will be built. This is usually set to a predefined build setting provided by the platform.
1090
1091#### Auto-vectorizer (`OPENCL_AUTO_VECTORIZE_ENABLE`)
1092Auto-vectorizes the OpenCL kernels for the CPU. This setting takes effect only for the CPU. This makes it possible to write a single kernel that is portable and performant across CPUs and GPUs.
1093
1094#### OpenCL Compiler Version (`OPENCL_COMPILER_VERSION`)
1095The OpenCL C compiler version supported by the platform.
1096
1097#### Flush denorms to zero (`OPENCL_DENORMS_ARE_ZERO`)
1098This option controls how single precision and double precision denormalized numbers are handled. If specified as a build option, the single precision denormalized numbers may be flushed to zero; double precision denormalized numbers may also be flushed to zero if the optional extension for double precision is supported. This is intended to be a performance hint and the OpenCL compiler can choose not to flush denorms to zero if the device supports single precision (or double precision) denormalized numbers.
1099
1100This option is ignored for single precision numbers if the device does not support single precision denormalized numbers, for example, `CL_FP_DENORM` bit is not set in `CL_DEVICE_SINGLE_FP_CONFIG`.
1101
1102This option is ignored for double precision numbers if the device does not support double precision or if it does support double precision but not double precision denormalized numbers, for example, `CL_FP_DENORM` bit is not set in `CL_DEVICE_DOUBLE_FP_CONFIG`.
1103
1104This flag only applies for scalar and vector single precision floating-point variables and computations on these floating-point variables inside a program. It does not apply to reading from or writing to image objects.
1105
1106#### Double as single (`OPENCL_DOUBLE_AS_SINGLE`)
1107Treat double precision floating-point expression as a single precision floating-point expression. This option is available for GPUs only.
1108
1109#### Relax IEEE Compliance (`OPENCL_FAST_RELAXED_MATH`)
1110This allows optimizations for floating-point arithmetic that may violate the IEEE 754 standard and the OpenCL numerical compliance requirements defined in in section 7.4 for single-precision floating-point, section 9.3.9 for double-precision floating-point, and edge case behavior in section 7.5 of the OpenCL 1.1 specification.
1111
1112This is intended to be a performance optimization.
1113
1114This option causes the preprocessor macro `FAST_RELAXED_MATH` to be defined in the OpenCL program.
1115
1116#### Use MAD (`OPENCL_MAD_ENABLE`)
1117Allow `a * b + c` to be replaced by a mad instruction. The mad computes `a * b + c` with reduced accuracy. For example, some OpenCL devices implement mad as truncate the result of `a * b` before adding it to `c`.
1118
1119This is intended to be a performance optimization.
1120
1121#### Optimization Level (`OPENCL_OPTIMIZATION_LEVEL`)
1122- None: Do not optimize. `-O0`
1123
1124    With this setting, the compiler's goal is to reduce the cost of compilation and to make debugging produce the expected results. Statements are independent—if you stop the program with a breakpoint between statements, you can then assign a new value to any variable or change the program counter to any other statement in the function and get exactly the results you would expect from the source code.
1125
1126- Fast: Optimizing compilation takes somewhat more time, and a lot more memory for a large function. `-O`, `-O1`
1127
1128    With this setting, the compiler tries to reduce code size and execution time, without performing any optimizations that take a great deal of compilation time. In Apple's compiler, strict aliasing, block reordering, and inter-block scheduling are disabled by default when optimizing.
1129
1130- Faster: The compiler performs nearly all supported optimizations that do not involve a space-speed tradeoff. `-O2`
1131
1132    With this setting, the compiler does not perform loop unrolling or function inlining, or register renaming. As compared to the Fast setting, this setting increases both compilation time and the performance of the generated code.
1133
1134- Fastest: Turns on all optimizations specified by the Faster setting and also turns on function inlining and register renaming options. This setting may result in a larger binary. `-O3`
1135- Fastest, smallest: Optimize for size. This setting enables all Faster optimizations that do not typically increase code size. It also performs further optimizations designed to reduce code size. `-Os`
1136
1137#### OpenCL Other Flags (`OPENCL_OTHER_BC_FLAGS`)
1138Space-separated list of additional flags to pass to the compiler. Be sure to backslash-escape any arguments that contain spaces or special characters, such as path names that may contain spaces. Use this setting if Xcode does not already provide UI for a particular compiler flag.
1139
1140#### OpenCL Preprocessor Macros (`OPENCL_PREPROCESSOR_DEFINITIONS`)
1141Space-separated list of preprocessor macros of the form foo or foo=bar.
1142
1143#### Order File (`ORDER_FILE`)
1144The path to a file that alters the order in which functions and data are laid out.
1145
1146For each section in the output file, any symbol in that section that are specified in the order file is moved to the start of its section and laid out in the same order as in the order file. Order files are text files with one symbol name per line. Lines starting with a # are comments. A symbol name may be optionally preceded with its object file leafname and a colon (for example, foo.o:_foo). This is useful for static functions/data that occur in multiple files. A symbol name may also be optionally preceded with the architecture (for example, ppc:_foo or ppc:foo.o:_foo). This enables you to have one order file that works for multiple architectures. Literal c-strings may be ordered by quoting the string in the order file (for example, "Hello, world\n").
1147
1148Generally you should not specify an order file in Debug or Development configurations, as this will make the linked binary less readable to the debugger. Use them only in Release or Deployment configurations.
1149
1150#### Save as Execute-Only (`OSACOMPILE_EXECUTE_ONLY`)
1151Saves the output script in execute-only form; the script can be run, but cannot be opened in Script Editor or Xcode. With this option turned off, a user may see the original script source by opening the script.
1152
1153#### Other C Flags (`OTHER_CFLAGS`)
1154Space-separated list of additional flags to pass to the compiler for C and Objective-C files. Be sure to backslash-escape any arguments that contain spaces or special characters, such as path names that may contain spaces. Use this setting if Xcode does not already provide UI for a particular C or Objective-C compiler flag.
1155
1156#### Other Code Signing Flags (`OTHER_CODE_SIGN_FLAGS`)
1157A list of additional options to pass to `codesign(1)`.
1158
1159#### Other C++ Flags (`OTHER_CPLUSPLUSFLAGS`)
1160Space-separated list of additional flags to pass to the compiler for C++ and Objective-C++ files. Be sure to backslash-escape any arguments that contain spaces or special characters, such as path names that may contain spaces. Use this setting if Xcode does not already provide UI for a C++ or Objective-C++ compiler flag.
1161
1162#### Other Linker Flags (`OTHER_LDFLAGS`)
1163Options defined in this setting are passed to invocations of the linker.
1164
1165#### Other Librarian Flags (`OTHER_LIBTOOLFLAGS`)
1166Options defined in this setting are passed to all invocations of the archive librarian, which is used to generate static libraries.
1167
1168#### Other MiG Flags (`OTHER_MIGFLAGS`)
1169Space-separated list of additional flags to pass to mig. Be sure to backslash-escape any arguments that contain spaces or special characters, such as path names that may contain spaces. Use this setting if Xcode does not already provide UI for a mig flag.
1170
1171#### Other OSACompile Flags (`OTHER_OSACOMPILEFLAGS`)
1172Space-separated list of additional flags to pass to osacompile. Be sure to backslash-escape any arguments that contain spaces or special characters, such as path names that may contain spaces. Use this setting if Xcode does not already provide UI for a particular osacompile flag.
1173
1174#### Other Rez Flags (`OTHER_REZFLAGS`)
1175Space-separated list of additional flags to pass to the Rez compiler. Be sure to backslash-escape any arguments that contain spaces or special characters, such as path names that may contain spaces. Use this setting if Xcode does not already provide UI for a particular Rez flag.
1176
1177#### Other Swift Flags (`OTHER_SWIFT_FLAGS`)
1178A list of additional flags to pass to the Swift compiler.
1179
1180#### Other Text-Based InstallAPI Flags (`OTHER_TAPI_FLAGS`)
1181Options defined in this setting are passed to invocations of the text-base InstallAPI tool.
1182
1183#### PACKAGE_TYPE
1184Uniform type identifier. Identifies the type of the product the target builds. Some products may be made up of a single binary or archive. Others may comprise several files, which are grouped under a single directory. These container directories are known as bundles.
1185
1186#### Property List Output Encoding (`PLIST_FILE_OUTPUT_FORMAT`)
1187Specifies the output encoding for property list files (.plist). The output endcodings can be `binary` or `XML`. By default, the output encoding will be unchanged from the input.
1188
1189#### PLUGINS_FOLDER_PATH
1190Specifies the directory that contains the product’s plugins.
1191
1192#### Precompiled Header Uses Files From Build Directory (`PRECOMPS_INCLUDE_HEADERS_FROM_BUILT_PRODUCTS_DIR`)
1193This setting allows for better control of sharing precompiled prefix header files between projects. By default, Xcode assumes that the prefix header file may include header files from the build directory if the build directory is outside of the project directory. Xcode cannot determine this ahead of time since other projects may not have been built into the shared build directory at the time the information is needed.
1194
1195If your prefix file never includes files from the build directory you may set this to `NO` to improve sharing of precompiled headers. If the prefix does use files from a build directory that is inside your project directory, you may set this to `YES` to avoid unintended sharing that may result in build failures.
1196
1197#### Single-Object Prelink Flags (`PRELINK_FLAGS`)
1198Additional flags to pass when performing a single-object prelink.
1199
1200#### Prelink libraries (`PRELINK_LIBS`)
1201Additional libraries to pass when performing a single-object prelink.
1202
1203#### Don't Dead-Strip Inits and Terms (`PRESERVE_DEAD_CODE_INITS_AND_TERMS`)
1204Activating this setting, in combination with the Dead Code Stripping (`DEAD_CODE_STRIPPING`) (`-dead_strip`) option, causes the `-no_dead_strip_inits_and_terms` flag to be passed to `ld(1)` via `cc(1)` to disable dead code stripping for initialization and termination routines. This option should not be used without the aforementioned Dead Code Stripping (`DEAD_CODE_STRIPPING`) option.
1205
1206#### Private Headers Folder Path (`PRIVATE_HEADERS_FOLDER_PATH`)
1207The location to copy the private headers to during building, relative to the built products folder.
1208
1209#### Product Bundle Identifier (`PRODUCT_BUNDLE_IDENTIFIER`)
1210A string that uniquely identifies the bundle. The string should be in reverse DNS format using only alphanumeric characters (A-Z, a-z, 0-9), the dot (.), and the hyphen (-). This value is used as the CFBundleIdentifier in the `Info.plist` of the built bundle.
1211
1212#### Pre-install Requirements Property List (`PRODUCT_DEFINITION_PLIST`)
1213Path to a file specifying additional requirements for a product archive.
1214
1215#### Product Module Name (`PRODUCT_MODULE_NAME`)
1216The name to use for the source code module constructed for this target, and which will be used to import the module in implementation source files. Must be a valid identifier.
1217
1218#### Product Name (`PRODUCT_NAME`)
1219This is the basename of the product generated by the target.
1220
1221#### Project Name (`PROJECT_NAME`)
1222The name of the current project.
1223
1224#### PROJECT_TEMP_DIR
1225Identifies the directory in which the project’s intermediate build files are placed. This directory is shared between all the targets defined by the project. Run Script build phases should generate intermediate build files in the directory identified by DERIVED_FILE_DIR, not the location this build setting specifies.
1226
1227#### Provisioning Profile (`Deprecated`) (`PROVISIONING_PROFILE`)
1228The UUID of a valid provisioning profile. A missing or invalid profile will cause a build error.
1229
1230This build setting is deprecated. Use Provisioning Profile (`PROVISIONING_PROFILE_SPECIFIER`) instead.
1231
1232#### Provisioning Profile (`PROVISIONING_PROFILE_SPECIFIER`)
1233Must contain a profile name or UUID. A missing or invalid profile will cause a build error. Use in conjunction with `DEVELOPMENT_TEAM` to fully specify provisioning profile.
1234
1235#### Public Headers Folder Path (`PUBLIC_HEADERS_FOLDER_PATH`)
1236The location to copy the public headers to during building, relative to the built products folder.
1237
1238#### Re-Exported Framework Names (`REEXPORTED_FRAMEWORK_NAMES`)
1239List of framework names that should have their symbols be reexported from the built library.
1240
1241#### Re-Exported Library Names (`REEXPORTED_LIBRARY_NAMES`)
1242List of library names that should have their symbols be reexported from the built library.
1243
1244#### Re-Exported Library Paths (`REEXPORTED_LIBRARY_PATHS`)
1245List of library paths that should have their symbols be reexported from the built library.
1246
1247#### REMOVE_CVS_FROM_RESOURCES
1248Specifies whether to remove CVS directories from bundle resources when they are copied.
1249
1250#### REMOVE_GIT_FROM_RESOURCES
1251Specifies whether to remove `.git` directories from bundle resources when they are copied.
1252
1253#### REMOVE_HG_FROM_RESOURCES
1254Specifies whether to remove `.hg` directories from bundle resources when they are copied.
1255
1256#### REMOVE_SVN_FROM_RESOURCES
1257Specifies whether to remove SVN directories from bundle resources when they are copied.
1258
1259#### File Fork of Binary Sources (`RESMERGER_SOURCES_FORK`)
1260Determines whether ResMerger treats binary input files as data-fork hosted or resource-fork hosted, or whether it automatically examines each input file.
1261
1262#### Resources Targeted Device Family (`RESOURCES_TARGETED_DEVICE_FAMILY`)
1263Overrides Targeted Device Family (`TARGETED_DEVICE_FAMILY`) when the resource copying needs to differ from the default targeted device.
1264
1265#### RETAIN_RAW_BINARIES
1266Specifies whether to keep copies of unstripped binaries available.
1267
1268#### REZ_COLLECTOR_DIR
1269Specifies the directory in which the collected Resource Manager resources generated by ResMerger are stored before they are added to the product.
1270
1271#### REZ_OBJECTS_DIR
1272Specifies the directory in which compiled Resource Manager resources generated by Rez are stored before they are collected using ResMerger.
1273
1274#### Rez Prefix File (`REZ_PREFIX_FILE`)
1275Implicitly include the named file on the command line for each Rez file compiled. The path given should either be a project relative path or an absolute path.
1276
1277#### Preprocessor Defines (`REZ_PREPROCESSOR_DEFINITIONS`)
1278These strings will be defined when compiling resource manager resources.
1279
1280#### Preprocessor Undefines (`REZ_PREPROCESSOR_UNDEFINITIONS`)
1281These strings will be undefined when compiling resource manager resources.
1282
1283#### Resolve Aliases (`REZ_RESOLVE_ALIASES`)
1284Enables aliases to be unresolved or conditionally resolved. The default is to resolve aliases always.
1285
1286#### Read-only Resource Map (`REZ_RESOURCE_MAP_READ_ONLY`)
1287Enabling this option causes the resource map output to be read-only.
1288
1289#### Rez Script Type (`REZ_SCRIPT_TYPE`)
1290Enables the recognition of a specific 2-byte character script identifier to use when compiling resource manager resources. This allows for 2-byte characters in strings to be handled as indivisible entities. The default language is Roman, which specifies 1-byte character sets.
1291
1292#### Rez Search Paths (`REZ_SEARCH_PATHS`)
1293This is a list of paths to search for files with resource manager resources. Paths are delimited by whitespace, so any paths with spaces in them need to be properly quoted.
1294
1295#### Show Diagnostic Output (`REZ_SHOW_DEBUG_OUTPUT`)
1296Enabling this option causes version and progress information to be written when compiling resource manager resources.
1297
1298#### Suppress Type Redeclaration Warnings (`REZ_SUPPRESS_REDECLARED_RESOURCE_TYPE_WARNINGS`)
1299Enabling this option causes warnings about redeclared resource types to be suppressed.
1300
1301#### Analyze During `Build` (`RUN_CLANG_STATIC_ANALYZER`)
1302Activating this setting will cause Xcode to run the Clang static analysis tool on qualifying source files during every build.
1303
1304#### Scan All Source Files for Includes (`SCAN_ALL_SOURCE_FILES_FOR_INCLUDES`)
1305Activating this setting will cause all source files to be scanned for includes (for example, of header files) when computing the dependency graph, in which case if an included file is changed then the including file will be rebuilt next time a target containing it is built. Normally only certain types of files, such as C-language source files, are scanned.
1306
1307This setting is useful if your project contains files of unusual types, which are compiled using a custom build rule.
1308
1309#### SCRIPTS_FOLDER_PATH
1310Specifies the directory that contains the product’s scripts.
1311
1312#### Base SDK (`SDKROOT`)
1313The name or path of the base SDK being used during the build. The product will be built against the headers and libraries located inside the indicated SDK. This path will be prepended to all search paths, and will be passed through the environment to the compiler and linker. Additional SDKs can be specified in the Additional SDKs (`ADDITIONAL_SDKS`) setting.
1314
1315#### Symbol Ordering Flags (`SECTORDER_FLAGS`)
1316These flags are typically used to specify options for ordering symbols within segments, for example the `-sectorder` option to ld.
1317
1318Generally you should not specify symbol ordering options in Debug or Development configurations, as this will make the linked binary less readable to the debugger. Use them only in Release or Deployment configurations.
1319
1320#### Use Separate Strip (`SEPARATE_STRIP`)
1321Activating this setting when the linked product is to be stripped will cause stripping to occur via a separate invocation of `strip(1)`. Otherwise stripping will occur during linking, if possible.
1322
1323#### Separately Edit Symbols (`SEPARATE_SYMBOL_EDIT`)
1324Activating this setting when the linked product's symbols are to be edited will cause editing to occur via a separate invocation of `nmedit(1)`. Otherwise editing will occur during linking, if possible.
1325
1326#### SHARED_FRAMEWORKS_FOLDER_PATH
1327Specifies the directory that contains the product’s shared frameworks.
1328
1329#### Precompiled Headers Cache Path (`SHARED_PRECOMPS_DIR`)
1330The path where precompiled prefix header files are placed during a build. Defaults to `$(OBJROOT)`/SharedPrecompiledHeaders. Using a common location allows precompiled headers to be shared between multiple projects.
1331
1332#### Skip Install (`SKIP_INSTALL`)
1333If enabled, don't install built products even if deployment locations are active.
1334
1335#### SRCROOT
1336Identifies the directory containing the target’s source files.
1337
1338#### Strings File Output Encoding (`STRINGS_FILE_OUTPUT_ENCODING`)
1339Specify the encoding to be used for Strings files (by default, the output encoding will be 16-bit Unicode). The value can be either an NSStringEncoding, such as one of the numeric values recognized by NSString, or it can be an IANA character set name as understood by CFString. The operation will fail if the file cannot be converted to the specified encoding.
1340
1341#### Additional Strip Flags (`STRIPFLAGS`)
1342Additional flags to be passed when stripping the linked product of the build.
1343
1344#### Strip Linked Product (`STRIP_INSTALLED_PRODUCT`)
1345If enabled, the linked product of the build will be stripped of symbols when performing deployment postprocessing.
1346
1347#### Remove Text Metadata From PNG Files (`STRIP_PNG_TEXT`)
1348Metadata in the form of text chunks in PNG files will be removed to reduce their footprint on disk.
1349
1350#### Strip Style (`STRIP_STYLE`)
1351The level of symbol stripping to be performed on the linked product of the build. The default value is defined by the target's product type.
1352
1353- All Symbols: Completely strips the binary, removing the symbol table and relocation information. all, `-s`
1354- Non-Global Symbols: Strips non-global symbols, but saves external symbols. non-global, `-x`
1355- Debugging Symbols: Strips debugging symbols, but saves local and global symbols. debugging, `-S`
1356
1357#### Supported Platforms (`SUPPORTED_PLATFORMS`)
1358The list of supported platforms from which a base SDK can be used. This setting is used if the product can be built for multiple platforms using different SDKs.
1359
1360#### Supports Text-Based InstallAPI (`SUPPORTS_TEXT_BASED_API`)
1361Enable to indicate that the target supports Text-Based InstallAPI, which will enable its generation during install builds.
1362
1363#### Active Compilation Conditions (`SWIFT_ACTIVE_COMPILATION_CONDITIONS`)
1364A list of compilation conditions to enable for conditional compilation expressions.
1365
1366#### Disable Safety Checks (`SWIFT_DISABLE_SAFETY_CHECKS`)
1367Disable runtime safety checks when optimizing.
1368
1369#### Import Paths (`SWIFT_INCLUDE_PATHS`)
1370A list of paths to be searched by the Swift compiler for additional Swift modules.
1371
1372#### Install Objective-C Compatibility Header (`SWIFT_INSTALL_OBJC_HEADER`)
1373For frameworks, install the Objective-C compatibility header describing bridged Swift classes into the Public Headers Folder Path (`PUBLIC_HEADERS_FOLDER_PATH`) so they may be accessed from Objective-C code using the framework. Defaults to `YES`.
1374
1375#### Objective-C Bridging Header (`SWIFT_OBJC_BRIDGING_HEADER`)
1376Path to the header defining the Objective-C interfaces to be exposed in Swift.
1377
1378#### Objective-C Generated Interface Header Name (`SWIFT_OBJC_INTERFACE_HEADER_NAME`)
1379Name to use for the header that is generated by the Swift compiler for use in `#import` statements in Objective-C.
1380
1381#### Optimization Level (`SWIFT_OPTIMIZATION_LEVEL`)
1382- None: Compile without any optimization. `-Onone`
1383- Fast, Single-File Optimization:-O
1384- Fast, Whole Module Optimization:-O `-whole-module-optimization`
1385
1386#### Reflection Metadata Level (`SWIFT_REFLECTION_METADATA_LEVEL`)
1387This setting controls the level of reflection metadata the Swift compiler emits.
1388
1389- All: Type information about stored properties of Swift structs and classes, Swift enum cases, and their names, are emitted into the binary for reflection and analysis in the Memory Graph Debugger.
1390- Without Names: Only type information about stored properties and cases are emitted into the binary, with their names omitted. `-disable-reflection-names`
1391- None: No reflection metadata is emitted into the binary. Accuracy of detecting memory issues involving Swift types in the Memory Graph Debugger will be degraded and reflection in Swift code may not be able to discover children of types, such as properties and enum cases. `-disable-reflection-metadata`
1392
1393#### Suppress Warnings (`SWIFT_SUPPRESS_WARNINGS`)
1394Don't emit any warnings.
1395
1396#### Treat Warnings as Errors (`SWIFT_TREAT_WARNINGS_AS_ERRORS`)
1397Treat all warnings as errors.
1398
1399#### Build Products Path (`SYMROOT`)
1400The path at which all products will be placed when performing a build. Typically this path is not set per target, but is set per-project or per-user. By default, this is set to `$(PROJECT_DIR)`/build.
1401
1402#### Text-Based InstallAPI Verification Mode (`TAPI_VERIFY_MODE`)
1403Selects the level of warnings and errors to report when building Text-Based InstallAPI.
1404
1405#### Targeted Device Family (`TARGETED_DEVICE_FAMILY`)
1406The build system uses the selected device to set the correct value for the UIDeviceFamily key it adds to the target's `Info.plist` file.
1407
1408#### TARGET_BUILD_DIR
1409Identifies the root of the directory hierarchy that contains the product’s files (no intermediate build files). Run Script build phases that operate on product files of the target that defines them should use the value of this build setting, but Run Script build phases that operate on product files of other targets should use `BUILT_PRODUCTS_DIR` instead.
1410
1411#### Target Name (`TARGET_NAME`)
1412The name of the current target.
1413
1414#### TARGET_TEMP_DIR
1415Identifies the directory containing the target’s intermediate build files. Run Script build phases should place intermediate files at the location indicated by DERIVED_FILE_DIR, not the directory identified by this build setting.
1416
1417#### Test Host (`TEST_HOST`)
1418Path to the executable into which a bundle of tests is injected. Only specify this setting if testing an application or other executable.
1419
1420#### Text-Based InstallAPI File (`TEXT_BASED_API_FILE`)
1421If provided and Text-Based InstallAPI is enabled, the path to a file to use as the Text-Based InstallAPI for the product instead of generating the API from the installed header content.
1422
1423#### Treat missing baselines as test failures (`TREAT_MISSING_BASELINES_AS_TEST_FAILURES`)
1424When running tests that measure performance via XCTestCase, report missing baselines as test failures.
1425
1426#### Unexported Symbols File (`UNEXPORTED_SYMBOLS_FILE`)
1427A project-relative path to a file that lists the symbols not to export. See `ld -exported_symbols_list` for details on exporting symbols.
1428
1429#### UNLOCALIZED_RESOURCES_FOLDER_PATH
1430Specifies the directory that contains the product’s unlocalized resources.
1431
1432#### User Header Search Paths (`USER_HEADER_SEARCH_PATHS`)
1433This is a list of paths to folders to be searched by the compiler for included or imported user header files (those headers listed in quotes) when compiling C, Objective-C, C++, or Objective-C++. Paths are delimited by whitespace, so any paths with spaces in them need to be properly quoted. See Always Search User Paths (`ALWAYS_SEARCH_USER_PATHS`) for more details on how this setting is used. If the compiler doesn't support the concept of user headers, then the search paths are prepended to the any existing header search paths defined in Header Search Paths (`HEADER_SEARCH_PATHS`).
1434
1435#### Use Header Maps (`USE_HEADERMAP`)
1436Enable the use of Header Maps, which provide the compiler with a mapping from textual header names to their locations, bypassing the normal compiler header search path mechanisms. This allows source code to include headers from various locations in the file system without needing to update the header search path build settings.
1437
1438#### Validate Built Product (`VALIDATE_PRODUCT`)
1439If enabled, perform validation checks on the product as part of the build process.
1440
1441#### Valid Architectures (`VALID_ARCHS`)
1442A space-separated list of architectures for which the target should actually be built. For each target, this list is intersected with the list specified in Architectures (`ARCHS`), and the resulting set is built. This allows individual targets to opt out of building for particular architectures. If the resulting set of architectures is empty, no executable will be produced.
1443
1444#### VERBOSE_PBXCP
1445Specifies whether the target’s Copy Files build phases generate additional information when copying files.
1446
1447#### Versioning System (`VERSIONING_SYSTEM`)
1448Selects the process used for version-stamping generated files.
1449
1450- None: Use no versioning system.
1451- Apple Generic: Use the current project version setting. apple-generic
1452
1453#### Versioning Username (`VERSION_INFO_BUILDER`)
1454This defines a reference to the user performing a build to be included in the generated Apple Generic Versioning stub. Defaults to the value of the USER environment variable.
1455
1456#### Generated Versioning Variables (`VERSION_INFO_EXPORT_DECL`)
1457This defines a prefix string for the version info symbol declaration in the generated Apple Generic Versioning stub. This can be used, for example, to add an optional export keyword to the version symbol declaration. This should rarely be changed.
1458
1459#### Generated Versioning Source Filename (`VERSION_INFO_FILE`)
1460Used to specify a name for the source file that will be generated by Apple Generic Versioning and compiled into your product. By default, this is set to `$(PRODUCT_NAME)_vers.c`.
1461
1462#### Versioning Name Prefix (`VERSION_INFO_PREFIX`)
1463Used as a prefix for the name of the version info symbol in the generated versioning source file. If you prefix your exported symbols you will probably want to set this to the same prefix.
1464
1465#### Versioning Name Suffix (`VERSION_INFO_SUFFIX`)
1466Used as a suffix for the name of the version info symbol in the generated versioning source file. This is rarely used.
1467
1468#### Other Warning Flags (`WARNING_CFLAGS`)
1469Space-separated list of additional warning flags to pass to the compiler. Use this setting if Xcode does not already provide UI for a particular compiler warning flag.
1470
1471#### Warning Linker Flags (`WARNING_LDFLAGS`)
1472These flags are passed with linker invocations, and by default give the `-no_arch_warnings` flag to the linker to avoid many warnings being generated during multi-architecture builds.
1473
1474#### Wrapper Extension (`WRAPPER_EXTENSION`)
1475The extension used for product wrappers, which has a default value based on the product type.
1476
1477#### WRAPPER_NAME
1478Specifies the filename, including the appropriate extension, of the product bundle.
1479
1480#### WRAPPER_SUFFIX
1481Specifies the suffix of the product bundle name, including the character that separates the extension from the rest of the bundle name.
1482
1483#### Append Plug-in Data (`XCODE_PLUGINCOMPILER_APPEND`)
1484Append compiled plug-in data to existing plug-in data, instead of overwriting it.
1485
1486#### Copy Original Plug-in Data (`XCODE_PLUGINCOMPILER_COPY_ORIGINAL`)
1487Copy original (`uncompiled`) plugin data to output alongside compiled plug-in data.
1488
1489#### Include Extension XML (`XCODE_PLUGINCOMPILER_INCLUDE_EXTENSION_XML`)
1490Include extension XML data in the resulting `.xcplugindata` files.
1491
1492#### Plug-in Data Format (`XCODE_PLUGINCOMPILER_OUTPUT_FORMAT`)
1493The property list format, binary or XML, to use for the resulting `.xcplugindata` file.
1494
1495#### Plug-in Maximum Developer Tools Version (`XCODE_PLUGINCOMPILER_TOOLS_VERSION_MAX`)
1496Latest version of Developer Tools on which this plugin will be used.
1497
1498#### Plug-in Minimum Developer Tools Version (`XCODE_PLUGINCOMPILER_TOOLS_VERSION_MIN`)
1499Earliest version of Developer Tools on which this plugin will be used.
1500
1501#### Other Yacc Flags (`YACCFLAGS`)
1502Space-separated list of additional flags to pass to yacc. Be sure to backslash-escape any arguments that contain spaces or special characters, such as path names that may contain spaces. Use this setting if Xcode does not already provide UI for a yacc flag.
1503
1504#### Generated File Stem (`YACC_GENERATED_FILE_STEM`)
1505The file stem to use for the files generated by yacc. The files will be named `<stem>.tab.c` and `<stem>.tab.h` based on the value of this setting. The Standard (`y`) option will cause all yacc source files in the same target to produce the same output file, and it is not recommended for targets containing multiple yacc source files.
1506
1507#### Generate Debugging Directives (`YACC_GENERATE_DEBUGGING_DIRECTIVES`)
1508Enabling this option changes the preprocessor directives generated by yacc so that debugging statements will be incorporated in the compiled code.
1509
1510#### Insert `#line` Directives (`YACC_INSERT_LINE_DIRECTIVES`)
1511Enabling this option causes yacc to insert the `#line` directives in the generated code. The `#line` directives let the C compiler relate errors in the generated code to the user's original code. If this option is disabled, `#line` directives specified by the user in the source file will still be retained.