├── Obfuscator.xcplugin └── Contents │ ├── Info.plist │ ├── MacOS │ └── Clang LLVM 1.0 │ ├── Resources │ ├── Default Compiler.xcspec │ ├── English.lproj │ │ ├── Default Compiler.strings │ │ └── Obfuscator 4.0.strings │ └── Obfuscator.xcspec │ ├── _CodeSignature │ └── CodeResources │ └── version.plist └── README.md /Obfuscator.xcplugin/Contents/Info.plist: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/obaby/xcode-obfuscator-llvm-plugin/2b8ac3411c91ed16a85c48e45a861fe00a3c094b/Obfuscator.xcplugin/Contents/Info.plist -------------------------------------------------------------------------------- /Obfuscator.xcplugin/Contents/MacOS/Clang LLVM 1.0: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/obaby/xcode-obfuscator-llvm-plugin/2b8ac3411c91ed16a85c48e45a861fe00a3c094b/Obfuscator.xcplugin/Contents/MacOS/Clang LLVM 1.0 -------------------------------------------------------------------------------- /Obfuscator.xcplugin/Contents/Resources/Default Compiler.xcspec: -------------------------------------------------------------------------------- 1 | /** 2 | Default compiler specification 3 | 4 | Copyright (c) 2000-2012 Apple Inc. 5 | All Rights Reserved. 6 | */ 7 | 8 | { Type = Compiler; 9 | Identifier = com.apple.compilers.gcc; 10 | Class = PBXCompilerSpecificationGcc; 11 | Name = "Default Compiler"; 12 | Description = "Default Compiler"; 13 | Version = "Default"; 14 | Vendor = "Apple"; 15 | Architectures = ( 16 | i386, 17 | ppc, 18 | ppc7400, 19 | ppc7450, 20 | ppc970, 21 | ppc64, 22 | "x86_64", 23 | armv6, 24 | armv7, 25 | ); 26 | FileTypes = (sourcecode.c.c, sourcecode.c.objc, sourcecode.cpp.cpp, sourcecode.cpp.objcpp, sourcecode.asm); 27 | BuiltinJambaseRuleName = "ProcessC"; // <== is this still used? A.B. 2004.09.20 28 | CommandOutputParser = XCGccCommandOutputParser; 29 | OptionConditionFlavors = ( 30 | arch, 31 | sdk, 32 | ); 33 | SupportsHeadermaps = Yes; 34 | DashIFlagAcceptsHeadermaps = No; 35 | UseCPlusPlusCompilerDriverWhenBundlizing = No; 36 | SupportsIsysroot = NO; 37 | ExecDescription = "Compile $(InputFile)"; 38 | ProgressDescription = "Compiling $(CommandProgressByType) source files"; 39 | ExecDescriptionForPrecompile = "Precompile $(InputFile)"; 40 | ProgressDescriptionForPrecompile = "Precompiling $(CommandProgressByType) prefix headers"; 41 | } 42 | -------------------------------------------------------------------------------- /Obfuscator.xcplugin/Contents/Resources/English.lproj/Default Compiler.strings: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/obaby/xcode-obfuscator-llvm-plugin/2b8ac3411c91ed16a85c48e45a861fe00a3c094b/Obfuscator.xcplugin/Contents/Resources/English.lproj/Default Compiler.strings -------------------------------------------------------------------------------- /Obfuscator.xcplugin/Contents/Resources/English.lproj/Obfuscator 4.0.strings: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | Description 6 | Obfuscator 4.0 compiler 7 | Name 8 | Obfuscator 4.0 9 | Vendor 10 | HEIG-VD 11 | Version 12 | 4.0 13 | [ASANPolicy]-category 14 | Address Sanitizer 15 | [CLANG_ADDRESS_SANITIZER_CONTAINER_OVERFLOW]-description 16 | Check 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. 17 | [CLANG_ADDRESS_SANITIZER_CONTAINER_OVERFLOW]-name 18 | Enable C++ Container Overflow Checks 19 | [CLANG_ADDRESS_SANITIZER_CONTAINER_OVERFLOW]-value-[NO] 20 | No 21 | [CLANG_ADDRESS_SANITIZER_CONTAINER_OVERFLOW]-value-[YES] 22 | Yes 23 | [CLANG_ANALYZER_DEADCODE_DEADSTORES]-description 24 | Check for values stored to variables and never read again. 25 | [CLANG_ANALYZER_DEADCODE_DEADSTORES]-name 26 | Dead Stores 27 | [CLANG_ANALYZER_DEADCODE_DEADSTORES]-value-[NO] 28 | No 29 | [CLANG_ANALYZER_DEADCODE_DEADSTORES]-value-[YES] 30 | Yes 31 | [CLANG_ANALYZER_DEADCODE_IDEMPOTENT_OPERATIONS]-description 32 | This checker is a form of dead code analysis, and flags various "idempotent operations" (operations that effectively do nothing). Examples include always assigning a value to variable that never changes the original value, always adding 0 to a variable, etc. 33 | [CLANG_ANALYZER_DEADCODE_IDEMPOTENT_OPERATIONS]-name 34 | Idempotent Operations 35 | [CLANG_ANALYZER_DEADCODE_IDEMPOTENT_OPERATIONS]-value-[NO] 36 | No 37 | [CLANG_ANALYZER_DEADCODE_IDEMPOTENT_OPERATIONS]-value-[YES] 38 | Yes 39 | [CLANG_ANALYZER_GCD]-description 40 | Check for misuses of the Grand Central Dispatch API. 41 | [CLANG_ANALYZER_GCD]-name 42 | Misuse of Grand Central Dispatch 43 | [CLANG_ANALYZER_GCD]-value-[NO] 44 | No 45 | [CLANG_ANALYZER_GCD]-value-[YES] 46 | Yes 47 | [CLANG_ANALYZER_LOCALIZABILITY_EMPTY_CONTEXT]-description 48 | Warn when a call to an `NSLocalizedString()` macro is missing a context comment for the localizer. 49 | [CLANG_ANALYZER_LOCALIZABILITY_EMPTY_CONTEXT]-name 50 | Missing Localization Context Comment 51 | [CLANG_ANALYZER_LOCALIZABILITY_EMPTY_CONTEXT]-value-[NO] 52 | No 53 | [CLANG_ANALYZER_LOCALIZABILITY_EMPTY_CONTEXT]-value-[YES] 54 | Yes 55 | [CLANG_ANALYZER_LOCALIZABILITY_NONLOCALIZED]-description 56 | Warn when a nonlocalized string is passed to a user interface method expecting a localized string. 57 | [CLANG_ANALYZER_LOCALIZABILITY_NONLOCALIZED]-name 58 | Missing Localizability 59 | [CLANG_ANALYZER_LOCALIZABILITY_NONLOCALIZED]-value-[NO] 60 | No 61 | [CLANG_ANALYZER_LOCALIZABILITY_NONLOCALIZED]-value-[YES] 62 | Yes 63 | [CLANG_ANALYZER_MEMORY_MANAGEMENT]-description 64 | Warn about memory leaks, use-after-free, and other API misuses. 65 | [CLANG_ANALYZER_MEMORY_MANAGEMENT]-name 66 | Improper Memory Management 67 | [CLANG_ANALYZER_MEMORY_MANAGEMENT]-value-[NO] 68 | No 69 | [CLANG_ANALYZER_MEMORY_MANAGEMENT]-value-[YES] 70 | Yes 71 | [CLANG_ANALYZER_NONNULL]-description 72 | Check for misuses of `nonnull` parameter and return types. 73 | [CLANG_ANALYZER_NONNULL]-name 74 | Misuse of 'nonnull' 75 | [CLANG_ANALYZER_NONNULL]-value-[NO] 76 | No 77 | [CLANG_ANALYZER_NONNULL]-value-[YES] 78 | Yes (Aggressive) 79 | [CLANG_ANALYZER_NONNULL]-value-[YES_NONAGGRESSIVE] 80 | Yes 81 | [CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION]-description 82 | Warn when a number object, such as an instance of `NSNumber`, `CFNumberRef`, `OSNumber`, or `OSBoolean` is compared or converted to a primitive value instead of another object. 83 | [CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION]-name 84 | Suspicious Conversions of NSNumber and CFNumberRef 85 | [CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION]-value-[NO] 86 | No 87 | [CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION]-value-[YES] 88 | Yes 89 | [CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION]-value-[YES_AGGRESSIVE] 90 | Yes (Aggressive) 91 | [CLANG_ANALYZER_OBJC_ATSYNC]-description 92 | Warn on `nil` pointers used as mutexes for `@synchronized`. 93 | [CLANG_ANALYZER_OBJC_ATSYNC]-name 94 | @synchronized with nil mutex 95 | [CLANG_ANALYZER_OBJC_ATSYNC]-value-[NO] 96 | No 97 | [CLANG_ANALYZER_OBJC_ATSYNC]-value-[YES] 98 | Yes 99 | [CLANG_ANALYZER_OBJC_COLLECTIONS]-description 100 | Warn if `CF` collections are created with non-pointer-size values. Check if `NS` collections are initialized with non-Objective-C type elements. 101 | [CLANG_ANALYZER_OBJC_COLLECTIONS]-name 102 | Misuse of Collections API 103 | [CLANG_ANALYZER_OBJC_COLLECTIONS]-value-[NO] 104 | No 105 | [CLANG_ANALYZER_OBJC_COLLECTIONS]-value-[YES] 106 | Yes 107 | [CLANG_ANALYZER_OBJC_DEALLOC]-description 108 | Warn when an instance is improperly cleaned up in `-dealloc`. 109 | [CLANG_ANALYZER_OBJC_DEALLOC]-name 110 | Improper Instance Cleanup in '-dealloc' 111 | [CLANG_ANALYZER_OBJC_DEALLOC]-value-[NO] 112 | No 113 | [CLANG_ANALYZER_OBJC_DEALLOC]-value-[YES] 114 | Yes 115 | [CLANG_ANALYZER_OBJC_GENERICS]-description 116 | Warn if a specialized generic type is converted to an incompatible type. 117 | [CLANG_ANALYZER_OBJC_GENERICS]-name 118 | Misuse of Objective-C generics 119 | [CLANG_ANALYZER_OBJC_GENERICS]-value-[NO] 120 | No 121 | [CLANG_ANALYZER_OBJC_GENERICS]-value-[YES] 122 | Yes 123 | [CLANG_ANALYZER_OBJC_INCOMP_METHOD_TYPES]-description 124 | Warn about Objective-C method signatures with type incompatibilities. 125 | [CLANG_ANALYZER_OBJC_INCOMP_METHOD_TYPES]-name 126 | Method Signatures Mismatch 127 | [CLANG_ANALYZER_OBJC_INCOMP_METHOD_TYPES]-value-[NO] 128 | No 129 | [CLANG_ANALYZER_OBJC_INCOMP_METHOD_TYPES]-value-[YES] 130 | Yes 131 | [CLANG_ANALYZER_OBJC_NSCFERROR]-description 132 | Warn if functions accepting `CFErrorRef` or `NSError` cannot indicate that an error occurred. 133 | [CLANG_ANALYZER_OBJC_NSCFERROR]-name 134 | Improper Handling of CFError and NSError 135 | [CLANG_ANALYZER_OBJC_NSCFERROR]-value-[NO] 136 | No 137 | [CLANG_ANALYZER_OBJC_NSCFERROR]-value-[YES] 138 | Yes 139 | [CLANG_ANALYZER_OBJC_RETAIN_COUNT]-description 140 | Warn on leaks and improper reference count management. 141 | [CLANG_ANALYZER_OBJC_RETAIN_COUNT]-name 142 | Violation of Reference Counting Rules 143 | [CLANG_ANALYZER_OBJC_RETAIN_COUNT]-value-[NO] 144 | No 145 | [CLANG_ANALYZER_OBJC_RETAIN_COUNT]-value-[YES] 146 | Yes 147 | [CLANG_ANALYZER_OBJC_SELF_INIT]-description 148 | Check that `super init` is properly called within an Objective-C initialization method. 149 | [CLANG_ANALYZER_OBJC_SELF_INIT]-name 150 | Violation of 'self = [super init]' Rule 151 | [CLANG_ANALYZER_OBJC_SELF_INIT]-value-[NO] 152 | No 153 | [CLANG_ANALYZER_OBJC_SELF_INIT]-value-[YES] 154 | Yes 155 | [CLANG_ANALYZER_OBJC_UNUSED_IVARS]-description 156 | Warn about private ivars that are never used. 157 | [CLANG_ANALYZER_OBJC_UNUSED_IVARS]-name 158 | Unused Ivars 159 | [CLANG_ANALYZER_OBJC_UNUSED_IVARS]-value-[NO] 160 | No 161 | [CLANG_ANALYZER_OBJC_UNUSED_IVARS]-value-[YES] 162 | Yes 163 | [CLANG_ANALYZER_SECURITY_BUFFER_OVERFLOW_EXPERIMENTAL]-description 164 | Check for potential buffer overflows. 165 | [CLANG_ANALYZER_SECURITY_BUFFER_OVERFLOW_EXPERIMENTAL]-name 166 | *EXPERIMENTAL* Buffer overflows 167 | [CLANG_ANALYZER_SECURITY_BUFFER_OVERFLOW_EXPERIMENTAL]-value-[NO] 168 | No 169 | [CLANG_ANALYZER_SECURITY_BUFFER_OVERFLOW_EXPERIMENTAL]-value-[YES] 170 | Yes 171 | [CLANG_ANALYZER_SECURITY_FLOATLOOPCOUNTER]-description 172 | Warn on using a floating point value as a loop counter (CERT: FLP30-C, FLP30-CPP). 173 | [CLANG_ANALYZER_SECURITY_FLOATLOOPCOUNTER]-name 174 | Floating Point Value Used as Loop Counter 175 | [CLANG_ANALYZER_SECURITY_FLOATLOOPCOUNTER]-value-[NO] 176 | No 177 | [CLANG_ANALYZER_SECURITY_FLOATLOOPCOUNTER]-value-[YES] 178 | Yes 179 | [CLANG_ANALYZER_SECURITY_INSECUREAPI_GETPW_GETS]-description 180 | Warn on uses of `getpw` and `gets`. The functions are dangerous as they may trigger a buffer overflow. 181 | [CLANG_ANALYZER_SECURITY_INSECUREAPI_GETPW_GETS]-name 182 | Use of 'getpw', 'gets' (Buffer Overflow) 183 | [CLANG_ANALYZER_SECURITY_INSECUREAPI_GETPW_GETS]-value-[NO] 184 | No 185 | [CLANG_ANALYZER_SECURITY_INSECUREAPI_GETPW_GETS]-value-[YES] 186 | Yes 187 | [CLANG_ANALYZER_SECURITY_INSECUREAPI_MKSTEMP]-description 188 | Warn 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. 189 | [CLANG_ANALYZER_SECURITY_INSECUREAPI_MKSTEMP]-name 190 | Use of 'mktemp' or Predictable 'mktemps' 191 | [CLANG_ANALYZER_SECURITY_INSECUREAPI_MKSTEMP]-value-[NO] 192 | No 193 | [CLANG_ANALYZER_SECURITY_INSECUREAPI_MKSTEMP]-value-[YES] 194 | Yes 195 | [CLANG_ANALYZER_SECURITY_INSECUREAPI_RAND]-description 196 | Warn on uses of `rand`, `random`, and related functions, which produce predictable random number sequences. Use `arc4random` instead. 197 | [CLANG_ANALYZER_SECURITY_INSECUREAPI_RAND]-name 198 | Use of 'rand' Functions 199 | [CLANG_ANALYZER_SECURITY_INSECUREAPI_RAND]-value-[NO] 200 | No 201 | [CLANG_ANALYZER_SECURITY_INSECUREAPI_RAND]-value-[YES] 202 | Yes 203 | [CLANG_ANALYZER_SECURITY_INSECUREAPI_STRCPY]-description 204 | Warn on uses of the `strcpy` and `strcat` functions, which can result in buffer overflows. Use `strlcpy` or `strlcat` instead. 205 | [CLANG_ANALYZER_SECURITY_INSECUREAPI_STRCPY]-name 206 | Use of 'strcpy' and 'strcat' 207 | [CLANG_ANALYZER_SECURITY_INSECUREAPI_STRCPY]-value-[NO] 208 | No 209 | [CLANG_ANALYZER_SECURITY_INSECUREAPI_STRCPY]-value-[YES] 210 | Yes 211 | [CLANG_ANALYZER_SECURITY_INSECUREAPI_UNCHECKEDRETURN]-description 212 | Warn on uses of sensitive functions whose return values must be always checked. 213 | [CLANG_ANALYZER_SECURITY_INSECUREAPI_UNCHECKEDRETURN]-name 214 | Unchecked Return Values 215 | [CLANG_ANALYZER_SECURITY_INSECUREAPI_UNCHECKEDRETURN]-value-[NO] 216 | No 217 | [CLANG_ANALYZER_SECURITY_INSECUREAPI_UNCHECKEDRETURN]-value-[YES] 218 | Yes 219 | [CLANG_ANALYZER_SECURITY_INSECUREAPI_VFORK]-description 220 | Warn on uses of the `vfork` function, which is inherently insecure. Use the safer `posix_spawn` function instead. 221 | [CLANG_ANALYZER_SECURITY_INSECUREAPI_VFORK]-name 222 | Use of 'vfork' 223 | [CLANG_ANALYZER_SECURITY_INSECUREAPI_VFORK]-value-[NO] 224 | No 225 | [CLANG_ANALYZER_SECURITY_INSECUREAPI_VFORK]-value-[YES] 226 | Yes 227 | [CLANG_ANALYZER_SECURITY_KEYCHAIN_API]-description 228 | Check for misuse of the Keychain Services API. 229 | [CLANG_ANALYZER_SECURITY_KEYCHAIN_API]-name 230 | Misuse of Keychain Services API 231 | [CLANG_ANALYZER_SECURITY_KEYCHAIN_API]-value-[NO] 232 | No 233 | [CLANG_ANALYZER_SECURITY_KEYCHAIN_API]-value-[YES] 234 | Yes 235 | [CLANG_CXX_LANGUAGE_STANDARD]-description 236 | Choose a standard or non-standard C++ language dialect. Options include: 237 | 238 | * *C++98:* Accept ISO C++ 1998 with amendments, but not GNU extensions. [-std=c++98] 239 | * *GNU++98:* Accept ISO C++ 1998 with amendments and GNU extensions. [-std=gnu++98] 240 | * *C++11:* Accept the ISO C++ 2011 standard with amendments, but not GNU extensions. [-std=c++11] 241 | * *GNU++11:* Accept the ISO C++ 2011 standard with amendments and GNU extensions. [-std=gnu++11] 242 | * *C++14:* Accept the ISO C++ 2014 standard with amendments, but not GNU extensions. [-std=c++14] 243 | * *GNU++14:* Accept the ISO C++ 2014 standard with amendments and GNU extensions. [-std=gnu++14] 244 | * *C++17:* Accept the ISO C++ 2017 standard with amendments, but not GNU extensions. [-std=c++17] 245 | * *GNU++17:* Accept the ISO C++ 2017 standard with amendments and GNU extensions. [-std=gnu++17] 246 | * *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.) 247 | [CLANG_CXX_LANGUAGE_STANDARD]-description-[c++0x] 248 | Accept the ISO C++ 2011 standard with amendments, but not GNU extensions. [-std=c++11] 249 | [CLANG_CXX_LANGUAGE_STANDARD]-description-[c++14] 250 | Accept the ISO C++ 2014 standard with amendments, but not GNU extensions. [-std=c++14] 251 | [CLANG_CXX_LANGUAGE_STANDARD]-description-[c++17] 252 | Accept the ISO C++ 2017 standard with amendments, but not GNU extensions. [-std=c++17] 253 | [CLANG_CXX_LANGUAGE_STANDARD]-description-[c++98] 254 | Accept ISO C++ 1998 with amendments, but not GNU extensions. [-std=c++98] 255 | [CLANG_CXX_LANGUAGE_STANDARD]-description-[compiler-default] 256 | Tells the compiler to use its default C++ language dialect. This is normally the best choice unless you have specific needs. (Currently equivalent to GNUC++98.) 257 | [CLANG_CXX_LANGUAGE_STANDARD]-description-[gnu++0x] 258 | Accept the ISO C++ 2011 standard with amendments and GNU extensions. [-std=gnu++11] 259 | [CLANG_CXX_LANGUAGE_STANDARD]-description-[gnu++14] 260 | Accept the ISO C++ 2014 standard with amendments and GNU extensions. [-std=gnu++14] 261 | [CLANG_CXX_LANGUAGE_STANDARD]-description-[gnu++17] 262 | Accept the ISO C++ 2017 standard with amendments and GNU extensions. [-std=gnu++17] 263 | [CLANG_CXX_LANGUAGE_STANDARD]-description-[gnu++98] 264 | Accept ISO C++ 1998 with amendments and GNU extensions. [-std=gnu++98] 265 | [CLANG_CXX_LANGUAGE_STANDARD]-name 266 | C++ Language Dialect 267 | [CLANG_CXX_LANGUAGE_STANDARD]-value-[c++0x] 268 | C++11 [-std=c++11] 269 | [CLANG_CXX_LANGUAGE_STANDARD]-value-[c++14] 270 | C++14 [-std=c++14] 271 | [CLANG_CXX_LANGUAGE_STANDARD]-value-[c++17] 272 | C++17 [-std=c++17] 273 | [CLANG_CXX_LANGUAGE_STANDARD]-value-[c++98] 274 | C++98 [-std=c++98] 275 | [CLANG_CXX_LANGUAGE_STANDARD]-value-[compiler-default] 276 | Compiler Default 277 | [CLANG_CXX_LANGUAGE_STANDARD]-value-[gnu++0x] 278 | GNU++11 [-std=gnu++11] 279 | [CLANG_CXX_LANGUAGE_STANDARD]-value-[gnu++14] 280 | GNU++14 [-std=gnu++14] 281 | [CLANG_CXX_LANGUAGE_STANDARD]-value-[gnu++17] 282 | GNU++17 [-std=gnu++17] 283 | [CLANG_CXX_LANGUAGE_STANDARD]-value-[gnu++98] 284 | GNU++98 [-std=gnu++98] 285 | [CLANG_CXX_LIBRARY]-description 286 | Choose a version of the C++ standard library to use. 287 | 288 | * *libstdc++:* A traditional C++ standard library that works with GCC and the LLVM Compiler (default). 289 | * *libc++:* A highly optimized C++ standard library that works only with the LLVM Compiler, and is designed to support new C++11 features. 290 | [CLANG_CXX_LIBRARY]-description-[compiler-default] 291 | Tells the compiler to use its default C++ standard library. (Currently equivalent to libstdc++) 292 | [CLANG_CXX_LIBRARY]-description-[libc++] 293 | New optimized C++ standard library that works only with the LLVM Compiler. 294 | [CLANG_CXX_LIBRARY]-description-[libstdc++] 295 | C++ standard library that works with GCC and the LLVM Compiler. 296 | [CLANG_CXX_LIBRARY]-name 297 | C++ Standard Library 298 | [CLANG_CXX_LIBRARY]-value-[compiler-default] 299 | Compiler Default 300 | [CLANG_CXX_LIBRARY]-value-[libc++] 301 | libc++ (LLVM C++ standard library with C++11 support) 302 | [CLANG_CXX_LIBRARY]-value-[libstdc++] 303 | libstdc++ (GNU C++ standard library) 304 | [CLANG_DEBUG_INFORMATION_LEVEL]-description 305 | Toggles 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. 306 | [CLANG_DEBUG_INFORMATION_LEVEL]-name 307 | Debug Information Level 308 | [CLANG_DEBUG_INFORMATION_LEVEL]-value-[default] 309 | Compiler default 310 | [CLANG_DEBUG_INFORMATION_LEVEL]-value-[line-tables-only] 311 | Line tables only 312 | [CLANG_ENABLE_MODULES]-description 313 | Enables 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. 314 | [CLANG_ENABLE_MODULES]-name 315 | Enable Modules (C and Objective-C) 316 | [CLANG_ENABLE_MODULES]-value-[NO] 317 | No 318 | [CLANG_ENABLE_MODULES]-value-[YES] 319 | Yes 320 | [CLANG_ENABLE_OBJC_ARC]-description 321 | Compiles 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. 322 | [CLANG_ENABLE_OBJC_ARC]-name 323 | Objective-C Automatic Reference Counting 324 | [CLANG_ENABLE_OBJC_ARC]-value-[NO] 325 | Use manual (traditional) reference counting 326 | [CLANG_ENABLE_OBJC_ARC]-value-[YES] 327 | Use automated reference counting 328 | [CLANG_ENABLE_OBJC_WEAK]-description 329 | Compiles Objective-C code to enable weak references for code compiled with manual retain release (MRR) semantics. 330 | [CLANG_ENABLE_OBJC_WEAK]-name 331 | Weak References in Manual Retain Release 332 | [CLANG_ENABLE_OBJC_WEAK]-value-[NO] 333 | Do not enable weak references in MRR 334 | [CLANG_ENABLE_OBJC_WEAK]-value-[YES] 335 | Enable weak references for MRR 336 | [CLANG_LINK_OBJC_RUNTIME]-description 337 | When 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. 338 | [CLANG_LINK_OBJC_RUNTIME]-name 339 | Implicitly Link Objective-C Runtime Support 340 | [CLANG_LINK_OBJC_RUNTIME]-value-[No] 341 | No 342 | [CLANG_LINK_OBJC_RUNTIME]-value-[YES] 343 | Yes 344 | [CLANG_MODULES_AUTOLINK]-description 345 | Automatically link SDK frameworks that are referenced using `#import` or `#include`. This feature requires also enabling support for modules. 346 | [CLANG_MODULES_AUTOLINK]-name 347 | Link Frameworks Automatically 348 | [CLANG_MODULES_AUTOLINK]-value-[NO] 349 | No 350 | [CLANG_MODULES_AUTOLINK]-value-[YES] 351 | Yes (when modules are enabled) 352 | [CLANG_OPTIMIZATION_PROFILE_FILE]-description 353 | The path to the file of the profile data to use when `CLANG_USE_OPTIMIZATION_PROFILE` is enabled. 354 | [CLANG_OPTIMIZATION_PROFILE_FILE]-name 355 | Optimization Profile File 356 | [CLANG_STATIC_ANALYZER_MODE]-description 357 | The depth the static analyzer uses during the Build action. Use `Deep` to exercise the full power of the analyzer. Use `Shallow` for faster analysis. 358 | [CLANG_STATIC_ANALYZER_MODE]-name 359 | Mode of Analysis for 'Build' 360 | [CLANG_STATIC_ANALYZER_MODE]-value-[deep] 361 | Deep 362 | [CLANG_STATIC_ANALYZER_MODE]-value-[shallow] 363 | Shallow (faster) 364 | [CLANG_STATIC_ANALYZER_MODE_ON_ANALYZE_ACTION]-description 365 | The depth the static analyzer uses during the Analyze action. Use `Deep` to exercise the full power of the analyzer. Use `Shallow` for faster analysis. 366 | [CLANG_STATIC_ANALYZER_MODE_ON_ANALYZE_ACTION]-name 367 | Mode of Analysis for 'Analyze' 368 | [CLANG_STATIC_ANALYZER_MODE_ON_ANALYZE_ACTION]-value-[deep] 369 | Deep 370 | [CLANG_STATIC_ANALYZER_MODE_ON_ANALYZE_ACTION]-value-[shallow] 371 | Shallow (faster) 372 | [CLANG_UNDEFINED_BEHAVIOR_SANITIZER_INTEGER]-description 373 | Check for unsigned integer overflow, in addition to checks for signed integer overflow. 374 | [CLANG_UNDEFINED_BEHAVIOR_SANITIZER_INTEGER]-name 375 | Enable Extra Integer Checks 376 | [CLANG_UNDEFINED_BEHAVIOR_SANITIZER_INTEGER]-value-[NO] 377 | No 378 | [CLANG_UNDEFINED_BEHAVIOR_SANITIZER_INTEGER]-value-[YES] 379 | Yes 380 | [CLANG_UNDEFINED_BEHAVIOR_SANITIZER_NULLABILITY]-description 381 | Check for violations of nullability annotations in function calls, return statements, and assignments. 382 | [CLANG_UNDEFINED_BEHAVIOR_SANITIZER_NULLABILITY]-name 383 | Enable Nullability Annotation Checks 384 | [CLANG_UNDEFINED_BEHAVIOR_SANITIZER_NULLABILITY]-value-[NO] 385 | No 386 | [CLANG_UNDEFINED_BEHAVIOR_SANITIZER_NULLABILITY]-value-[YES] 387 | Yes 388 | [CLANG_USE_OPTIMIZATION_PROFILE]-description 389 | When this setting is enabled, `clang` will use the optimization profile collected for a target when building it. 390 | [CLANG_USE_OPTIMIZATION_PROFILE]-name 391 | Use Optimization Profile 392 | [CLANG_USE_OPTIMIZATION_PROFILE]-value-[NO] 393 | No 394 | [CLANG_USE_OPTIMIZATION_PROFILE]-value-[YES] 395 | Yes 396 | [CLANG_WARN_ASSIGN_ENUM]-description 397 | Warn about assigning integer constants to enum values that are out of the range of the enumerated type. 398 | [CLANG_WARN_ASSIGN_ENUM]-name 399 | Out-of-Range Enum Assignments 400 | [CLANG_WARN_ASSIGN_ENUM]-value-[NO] 401 | No 402 | [CLANG_WARN_ASSIGN_ENUM]-value-[YES] 403 | Yes 404 | [CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING]-description 405 | Warn about block captures of implicitly autoreleasing parameters. 406 | [CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING]-name 407 | Block Capture of Autoreleasing 408 | [CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING]-value-[NO] 409 | No 410 | [CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING]-value-[YES] 411 | Yes 412 | [CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING]-value-[YES_ERROR] 413 | Yes (Error) 414 | [CLANG_WARN_BOOL_CONVERSION]-description 415 | Warn 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. 416 | [CLANG_WARN_BOOL_CONVERSION]-name 417 | Implicit Boolean Conversions 418 | [CLANG_WARN_BOOL_CONVERSION]-value-[NO] 419 | No 420 | [CLANG_WARN_BOOL_CONVERSION]-value-[YES] 421 | Yes 422 | [CLANG_WARN_BOOL_CONVERSION]-value-[YES_ERROR] 423 | Yes (Error) 424 | [CLANG_WARN_COMMA]-description 425 | Warn about suspicious uses of the comma operator. 426 | [CLANG_WARN_COMMA]-name 427 | Suspicious Commas 428 | [CLANG_WARN_COMMA]-value-[NO] 429 | No 430 | [CLANG_WARN_COMMA]-value-[YES] 431 | Yes 432 | [CLANG_WARN_COMMA]-value-[YES_ERROR] 433 | Yes (Error) 434 | [CLANG_WARN_CONSTANT_CONVERSION]-description 435 | Warn about implicit conversions of constant values that cause the constant value to change, either through a loss of precision, or entirely in its meaning. 436 | [CLANG_WARN_CONSTANT_CONVERSION]-name 437 | Implicit Constant Conversions 438 | [CLANG_WARN_CONSTANT_CONVERSION]-value-[NO] 439 | No 440 | [CLANG_WARN_CONSTANT_CONVERSION]-value-[YES] 441 | Yes 442 | [CLANG_WARN_CONSTANT_CONVERSION]-value-[YES_ERROR] 443 | Yes (Error) 444 | [CLANG_WARN_CXX0X_EXTENSIONS]-description 445 | When compiling C++ code using a language standard older than C++11, warn about the use of C++11 extensions. 446 | [CLANG_WARN_CXX0X_EXTENSIONS]-name 447 | Using C++11 extensions in earlier versions of C++ 448 | [CLANG_WARN_CXX0X_EXTENSIONS]-value-[NO] 449 | No 450 | [CLANG_WARN_CXX0X_EXTENSIONS]-value-[YES] 451 | Yes 452 | [CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS]-description 453 | Warn if an Objective-C class either subclasses a deprecated class or overrides a method that has been marked deprecated. 454 | [CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS]-name 455 | Overriding Deprecated Objective-C Methods 456 | [CLANG_WARN_DIRECT_OBJC_ISA_USAGE]-description 457 | Warn about direct accesses to the Objective-C `isa` pointer instead of using a runtime API. 458 | [CLANG_WARN_DIRECT_OBJC_ISA_USAGE]-name 459 | Direct usage of 'isa' 460 | [CLANG_WARN_DIRECT_OBJC_ISA_USAGE]-value-[NO] 461 | No 462 | [CLANG_WARN_DIRECT_OBJC_ISA_USAGE]-value-[YES] 463 | Yes 464 | [CLANG_WARN_DIRECT_OBJC_ISA_USAGE]-value-[YES_ERROR] 465 | Yes (treat as error) 466 | [CLANG_WARN_DOCUMENTATION_COMMENTS]-description 467 | Warns about issues in documentation comments (`doxygen`-style) such as missing or incorrect documentation tags. 468 | [CLANG_WARN_DOCUMENTATION_COMMENTS]-name 469 | Documentation Comments 470 | [CLANG_WARN_DOCUMENTATION_COMMENTS]-value-[NO] 471 | No 472 | [CLANG_WARN_DOCUMENTATION_COMMENTS]-value-[YES] 473 | Yes 474 | [CLANG_WARN_EMPTY_BODY]-description 475 | Warn about loop bodies that are suspiciously empty. 476 | [CLANG_WARN_EMPTY_BODY]-name 477 | Empty Loop Bodies 478 | [CLANG_WARN_EMPTY_BODY]-value-[NO] 479 | No 480 | [CLANG_WARN_EMPTY_BODY]-value-[YES] 481 | Yes 482 | [CLANG_WARN_ENUM_CONVERSION]-description 483 | Warn 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. 484 | [CLANG_WARN_ENUM_CONVERSION]-name 485 | Implicit Enum Conversions 486 | [CLANG_WARN_ENUM_CONVERSION]-value-[NO] 487 | No 488 | [CLANG_WARN_ENUM_CONVERSION]-value-[YES] 489 | Yes 490 | [CLANG_WARN_ENUM_CONVERSION]-value-[YES_ERROR] 491 | Yes (Error) 492 | [CLANG_WARN_FLOAT_CONVERSION]-description 493 | Warn about implicit conversions that turn floating-point numbers into integers. 494 | [CLANG_WARN_FLOAT_CONVERSION]-name 495 | Implicit Float Conversions 496 | [CLANG_WARN_FLOAT_CONVERSION]-value-[NO] 497 | No 498 | [CLANG_WARN_FLOAT_CONVERSION]-value-[YES] 499 | Yes 500 | [CLANG_WARN_FLOAT_CONVERSION]-value-[YES_ERROR] 501 | Yes (Error) 502 | [CLANG_WARN_IMPLICIT_SIGN_CONVERSION]-description 503 | Warn about implicit integer conversions that change the signedness of an integer value. 504 | [CLANG_WARN_IMPLICIT_SIGN_CONVERSION]-name 505 | Implicit Signedness Conversions 506 | [CLANG_WARN_IMPLICIT_SIGN_CONVERSION]-value-[NO] 507 | No 508 | [CLANG_WARN_IMPLICIT_SIGN_CONVERSION]-value-[YES] 509 | Yes 510 | [CLANG_WARN_IMPLICIT_SIGN_CONVERSION]-value-[YES_ERROR] 511 | Yes (Error) 512 | [CLANG_WARN_INFINITE_RECURSION]-description 513 | Warn if all paths through a function call itself. 514 | [CLANG_WARN_INFINITE_RECURSION]-name 515 | Infinite Recursion 516 | [CLANG_WARN_INFINITE_RECURSION]-value-[NO] 517 | No 518 | [CLANG_WARN_INFINITE_RECURSION]-value-[YES] 519 | Yes 520 | [CLANG_WARN_INT_CONVERSION]-description 521 | Warn about implicit conversions between pointers and integers. For example, this can catch issues when one incorrectly intermixes using `NSNumber*`'s and raw integers. 522 | [CLANG_WARN_INT_CONVERSION]-name 523 | Implicit Integer to Pointer Conversions 524 | [CLANG_WARN_INT_CONVERSION]-value-[NO] 525 | No 526 | [CLANG_WARN_INT_CONVERSION]-value-[YES] 527 | Yes 528 | [CLANG_WARN_INT_CONVERSION]-value-[YES_ERROR] 529 | Yes (Error) 530 | [CLANG_WARN_NON_LITERAL_NULL_CONVERSION]-description 531 | Warn about non-literal expressions that evaluate to zero being treated as a null pointer. 532 | [CLANG_WARN_NON_LITERAL_NULL_CONVERSION]-name 533 | Implicit Non-Literal Null Conversions 534 | [CLANG_WARN_NON_LITERAL_NULL_CONVERSION]-value-[NO] 535 | No 536 | [CLANG_WARN_NON_LITERAL_NULL_CONVERSION]-value-[YES] 537 | Yes 538 | [CLANG_WARN_NON_LITERAL_NULL_CONVERSION]-value-[YES_ERROR] 539 | Yes (Error) 540 | [CLANG_WARN_NULLABLE_TO_NONNULL_CONVERSION]-description 541 | Warns when a nullable expression is used somewhere it’s not allowed, such as when passed as a `_Nonnull` parameter. 542 | [CLANG_WARN_NULLABLE_TO_NONNULL_CONVERSION]-name 543 | Incorrect Uses of Nullable Values 544 | [CLANG_WARN_NULLABLE_TO_NONNULL_CONVERSION]-value-[NO] 545 | No 546 | [CLANG_WARN_NULLABLE_TO_NONNULL_CONVERSION]-value-[YES] 547 | Yes 548 | [CLANG_WARN_OBJCPP_ARC_ABI]-description 549 | When compiling Objective-C++ code that uses Automatic Reference Counting, report code that may cause ABI issues when linking ARC code with traditional manual reference counting code. 550 | [CLANG_WARN_OBJCPP_ARC_ABI]-name 551 | Objective-C++ Automatic Reference Counting ABI incompatibilities 552 | [CLANG_WARN_OBJCPP_ARC_ABI]-value-[NO] 553 | No 554 | [CLANG_WARN_OBJCPP_ARC_ABI]-value-[YES] 555 | Yes 556 | [CLANG_WARN_OBJC_EXPLICIT_OWNERSHIP_TYPE]-description 557 | Warn 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`. 558 | [CLANG_WARN_OBJC_EXPLICIT_OWNERSHIP_TYPE]-name 559 | Implicit ownership types on out parameters 560 | [CLANG_WARN_OBJC_EXPLICIT_OWNERSHIP_TYPE]-value-[NO] 561 | No 562 | [CLANG_WARN_OBJC_EXPLICIT_OWNERSHIP_TYPE]-value-[YES] 563 | Yes 564 | [CLANG_WARN_OBJC_IMPLICIT_ATOMIC_PROPERTIES]-description 565 | Warn about `@property` declarations that are implicitly atomic. 566 | [CLANG_WARN_OBJC_IMPLICIT_ATOMIC_PROPERTIES]-name 567 | Implicit Atomic Objective-C Properties 568 | [CLANG_WARN_OBJC_IMPLICIT_ATOMIC_PROPERTIES]-value-[NO] 569 | No 570 | [CLANG_WARN_OBJC_IMPLICIT_ATOMIC_PROPERTIES]-value-[YES] 571 | Yes 572 | [CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF]-description 573 | Warn about implicit retains of `self` within blocks, which can create a retain-cycle. 574 | [CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF]-name 575 | Implicit retain of 'self' within blocks 576 | [CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF]-value-[NO] 577 | No 578 | [CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF]-value-[YES] 579 | Yes 580 | [CLANG_WARN_OBJC_LITERAL_CONVERSION]-description 581 | Warn about implicit conversions from Objective-C literals to values of incompatible type. 582 | [CLANG_WARN_OBJC_LITERAL_CONVERSION]-name 583 | Implicit Objective-C Literal Conversions 584 | [CLANG_WARN_OBJC_LITERAL_CONVERSION]-value-[NO] 585 | No 586 | [CLANG_WARN_OBJC_LITERAL_CONVERSION]-value-[YES] 587 | Yes 588 | [CLANG_WARN_OBJC_LITERAL_CONVERSION]-value-[YES_ERROR] 589 | Yes (Error) 590 | [CLANG_WARN_OBJC_MISSING_PROPERTY_SYNTHESIS]-description 591 | Starting 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`. 592 | [CLANG_WARN_OBJC_MISSING_PROPERTY_SYNTHESIS]-name 593 | Implicit Synthesized Properties 594 | [CLANG_WARN_OBJC_MISSING_PROPERTY_SYNTHESIS]-value-[NO] 595 | No 596 | [CLANG_WARN_OBJC_MISSING_PROPERTY_SYNTHESIS]-value-[YES] 597 | Yes 598 | [CLANG_WARN_OBJC_REPEATED_USE_OF_WEAK]-description 599 | Warn 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. 600 | [CLANG_WARN_OBJC_REPEATED_USE_OF_WEAK]-name 601 | Repeatedly using a __weak reference 602 | [CLANG_WARN_OBJC_REPEATED_USE_OF_WEAK]-value-[NO] 603 | No 604 | [CLANG_WARN_OBJC_REPEATED_USE_OF_WEAK]-value-[YES] 605 | Yes 606 | [CLANG_WARN_OBJC_REPEATED_USE_OF_WEAK]-value-[YES_AGGRESSIVE] 607 | Yes (Aggressive) 608 | [CLANG_WARN_OBJC_ROOT_CLASS]-description 609 | Warn about classes that unintentionally do not subclass a root class, such as `NSObject`. 610 | [CLANG_WARN_OBJC_ROOT_CLASS]-name 611 | Unintentional Root Class 612 | [CLANG_WARN_OBJC_ROOT_CLASS]-value-[NO] 613 | No 614 | [CLANG_WARN_OBJC_ROOT_CLASS]-value-[YES] 615 | Yes 616 | [CLANG_WARN_OBJC_ROOT_CLASS]-value-[YES_ERROR] 617 | Yes (treat as error) 618 | [CLANG_WARN_RANGE_LOOP_ANALYSIS]-description 619 | Warn about ranged-based for loops. 620 | [CLANG_WARN_RANGE_LOOP_ANALYSIS]-name 621 | Range-based For Loops 622 | [CLANG_WARN_RANGE_LOOP_ANALYSIS]-value-[NO] 623 | No 624 | [CLANG_WARN_RANGE_LOOP_ANALYSIS]-value-[YES] 625 | Yes 626 | [CLANG_WARN_STRICT_PROTOTYPES]-description 627 | Warn about non-prototype declarations. 628 | [CLANG_WARN_STRICT_PROTOTYPES]-name 629 | Strict Prototypes 630 | [CLANG_WARN_STRICT_PROTOTYPES]-value-[NO] 631 | No 632 | [CLANG_WARN_STRICT_PROTOTYPES]-value-[YES] 633 | Yes 634 | [CLANG_WARN_STRICT_PROTOTYPES]-value-[YES_ERROR] 635 | Yes (Error) 636 | [CLANG_WARN_SUSPICIOUS_IMPLICIT_CONVERSION]-description 637 | Warn about various implicit conversions that can lose information or are otherwise suspicious. 638 | [CLANG_WARN_SUSPICIOUS_IMPLICIT_CONVERSION]-name 639 | Suspicious Implicit Conversions 640 | [CLANG_WARN_SUSPICIOUS_IMPLICIT_CONVERSION]-value-[NO] 641 | No 642 | [CLANG_WARN_SUSPICIOUS_IMPLICIT_CONVERSION]-value-[YES] 643 | Yes 644 | [CLANG_WARN_SUSPICIOUS_IMPLICIT_CONVERSION]-value-[YES_ERROR] 645 | Yes (Error) 646 | [CLANG_WARN_SUSPICIOUS_MOVE]-description 647 | Warn about suspicious uses of `std::move`. 648 | [CLANG_WARN_SUSPICIOUS_MOVE]-name 649 | Suspicious Moves 650 | [CLANG_WARN_SUSPICIOUS_MOVE]-value-[NO] 651 | No 652 | [CLANG_WARN_SUSPICIOUS_MOVE]-value-[YES] 653 | Yes 654 | [CLANG_WARN_UNGUARDED_AVAILABILITY]-description 655 | Warn if an API that is newer than the deployment target is used without "if (@available(...))" guards. 656 | [CLANG_WARN_UNGUARDED_AVAILABILITY]-name 657 | Unguarded availability 658 | [CLANG_WARN_UNGUARDED_AVAILABILITY]-value-[NO] 659 | No 660 | [CLANG_WARN_UNGUARDED_AVAILABILITY]-value-[YES] 661 | Yes 662 | [CLANG_WARN_UNGUARDED_AVAILABILITY]-value-[YES_AGGRESSIVE] 663 | Yes (All Versions) 664 | [CLANG_WARN_UNREACHABLE_CODE]-description 665 | Warns about potentially unreachable code. 666 | [CLANG_WARN_UNREACHABLE_CODE]-name 667 | Unreachable Code 668 | [CLANG_WARN_UNREACHABLE_CODE]-value-[NO] 669 | No 670 | [CLANG_WARN_UNREACHABLE_CODE]-value-[YES] 671 | Yes 672 | [CLANG_WARN_UNREACHABLE_CODE]-value-[YES_AGGRESSIVE] 673 | Yes (Aggressive) 674 | [CLANG_WARN__ARC_BRIDGE_CAST_NONARC]-description 675 | Warn about using `__bridge` casts when not using ARC, where they have no effect. 676 | [CLANG_WARN__ARC_BRIDGE_CAST_NONARC]-name 677 | Using __bridge Casts Outside of ARC 678 | [CLANG_WARN__ARC_BRIDGE_CAST_NONARC]-value-[NO] 679 | No 680 | [CLANG_WARN__ARC_BRIDGE_CAST_NONARC]-value-[YES] 681 | Yes 682 | [CLANG_WARN__DUPLICATE_METHOD_MATCH]-description 683 | Warn about declaring the same method more than once within the same `@interface`. 684 | [CLANG_WARN__DUPLICATE_METHOD_MATCH]-name 685 | Duplicate Method Definitions 686 | [CLANG_WARN__DUPLICATE_METHOD_MATCH]-value-[NO] 687 | No 688 | [CLANG_WARN__DUPLICATE_METHOD_MATCH]-value-[YES] 689 | Yes 690 | [CLANG_WARN__EXIT_TIME_DESTRUCTORS]-description 691 | Warn about destructors for C++ objects that are called when an application is terminating. 692 | [CLANG_WARN__EXIT_TIME_DESTRUCTORS]-name 693 | Exit-Time C++ Destructors 694 | [CLANG_WARN__EXIT_TIME_DESTRUCTORS]-value-[NO] 695 | No 696 | [CLANG_WARN__EXIT_TIME_DESTRUCTORS]-value-[YES] 697 | Yes 698 | [CLANG_X86_VECTOR_INSTRUCTIONS]-value-[avx2] 699 | AVX 2 700 | [CLANG_X86_VECTOR_INSTRUCTIONS]-value-[avx] 701 | AVX 702 | [CLANG_X86_VECTOR_INSTRUCTIONS]-value-[default] 703 | Platform default 704 | [CLANG_X86_VECTOR_INSTRUCTIONS]-value-[sse3] 705 | SSE 3 706 | [CLANG_X86_VECTOR_INSTRUCTIONS]-value-[sse4.1] 707 | SSE 4.1 708 | [CLANG_X86_VECTOR_INSTRUCTIONS]-value-[sse4.2] 709 | SSE 4.2 710 | [CLANG_X86_VECTOR_INSTRUCTIONS]-value-[ssse3] 711 | SSE 3 (with supplemental extensions) 712 | [CodeGeneration]-category 713 | Code Generation 714 | [CustomFlags]-category 715 | Custom Compiler Flags 716 | [ENABLE_NS_ASSERTIONS]-description 717 | Controls whether assertion logic provided by `NSAssert` is included in the preprocessed source code or is elided during preprocessing. Disabling assertions can improve code performance. 718 | [ENABLE_NS_ASSERTIONS]-name 719 | Enable Foundation Assertions 720 | [ENABLE_NS_ASSERTIONS]-value-[NO] 721 | No 722 | [ENABLE_NS_ASSERTIONS]-value-[YES] 723 | Yes 724 | [ENABLE_STRICT_OBJC_MSGSEND]-description 725 | Controls whether `objc_msgSend` calls must be cast to the appropriate function pointer type before being called. 726 | [ENABLE_STRICT_OBJC_MSGSEND]-name 727 | Enable Strict Checking of objc_msgSend Calls 728 | [ENABLE_STRICT_OBJC_MSGSEND]-value-[NO] 729 | No 730 | [ENABLE_STRICT_OBJC_MSGSEND]-value-[YES] 731 | Yes 732 | [GCC_CHAR_IS_UNSIGNED_CHAR]-description 733 | Enabling this setting causes `char` to be unsigned by default, disabling it causes `char` to be signed by default. 734 | [GCC_CHAR_IS_UNSIGNED_CHAR]-name 735 | 'char' Type Is Unsigned 736 | [GCC_CHAR_IS_UNSIGNED_CHAR]-value-[NO] 737 | No 738 | [GCC_CHAR_IS_UNSIGNED_CHAR]-value-[YES] 739 | Yes 740 | [GCC_CW_ASM_SYNTAX]-description 741 | Enable the CodeWarrior/Microsoft syntax for inline assembly code in addition to the standard GCC syntax. 742 | [GCC_CW_ASM_SYNTAX]-name 743 | CodeWarrior/MS-Style Inline Assembly 744 | [GCC_CW_ASM_SYNTAX]-value-[NO] 745 | No 746 | [GCC_CW_ASM_SYNTAX]-value-[YES] 747 | Yes 748 | [GCC_C_LANGUAGE_STANDARD]-description 749 | Choose a standard or non-standard C language dialect. 750 | 751 | * *ANSI C:* Accept ISO C90 and ISO C++, turning off GNU extensions that are incompatible. [-ansi] 752 | Incompatible GNU extensions include the `asm`, `inline`, and `typeof` keywords (but not the equivalent `\_\_asm\_\_`, `\_\_inline\_\_`, and `\_\_typeof\_\_` forms), and the `//` syntax for comments. 753 | This setting also enables trigraphs. 754 | * *C89:* Accept ISO C90 (1990), but not GNU extensions. [-std=c89] 755 | * *GNU89:* Accept ISO C90 and GNU extensions. [-std=gnu89] 756 | * *C99:* Accept ISO C99 (1999), but not GNU extensions. [-std=c99] 757 | * *GNU99:* Accept ISO C99 and GNU extensions. [-std=gnu99] 758 | * *C11:* Accept ISO C11 (2011), but not GNU extensions. [-std=c11] 759 | * *GNU11:* Accept ISO C11 and GNU extensions. [-std=gnu11] 760 | * *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.) 761 | [GCC_C_LANGUAGE_STANDARD]-description-[ansi] 762 | Accept ISO C90 and ISO C++, turning off GNU extensions that are incompatible. [-ansi] 763 | [GCC_C_LANGUAGE_STANDARD]-description-[c89] 764 | Accept ISO C90, but not GNU extensions. [-std=c89] 765 | [GCC_C_LANGUAGE_STANDARD]-description-[c99] 766 | Accept ISO C99, but not GNU extensions. [-std=c99] 767 | [GCC_C_LANGUAGE_STANDARD]-description-[compiler-default] 768 | 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.) 769 | [GCC_C_LANGUAGE_STANDARD]-description-[gnu89] 770 | Accept ISO C90 and GNU extensions. [-std=gnu89] 771 | [GCC_C_LANGUAGE_STANDARD]-description-[gnu99] 772 | Accept ISO C99 and GNU extensions. [-std=gnu99] 773 | [GCC_C_LANGUAGE_STANDARD]-name 774 | C Language Dialect 775 | [GCC_C_LANGUAGE_STANDARD]-value-[ansi] 776 | ANSI C [-ansi] 777 | [GCC_C_LANGUAGE_STANDARD]-value-[c89] 778 | C89 [-std=c89] 779 | [GCC_C_LANGUAGE_STANDARD]-value-[c99] 780 | C99 [-std=c99] 781 | [GCC_C_LANGUAGE_STANDARD]-value-[compiler-default] 782 | Compiler Default 783 | [GCC_C_LANGUAGE_STANDARD]-value-[gnu89] 784 | GNU89 [-std=gnu89] 785 | [GCC_C_LANGUAGE_STANDARD]-value-[gnu99] 786 | GNU99 [-std=gnu99] 787 | [GCC_DYNAMIC_NO_PIC]-description 788 | Faster function calls for applications. Not appropriate for shared libraries, which need to be position-independent. 789 | [GCC_DYNAMIC_NO_PIC]-name 790 | Generate Position-Dependent Code 791 | [GCC_DYNAMIC_NO_PIC]-value-[NO] 792 | No 793 | [GCC_DYNAMIC_NO_PIC]-value-[YES] 794 | Yes 795 | [GCC_ENABLE_ASM_KEYWORD]-description 796 | Controls whether `asm`, `inline`, and `typeof` are treated as keywords or whether they can be used as identifiers. 797 | [GCC_ENABLE_ASM_KEYWORD]-name 798 | Allow 'asm', 'inline', 'typeof' 799 | [GCC_ENABLE_ASM_KEYWORD]-value-[NO] 800 | No 801 | [GCC_ENABLE_ASM_KEYWORD]-value-[YES] 802 | Yes 803 | [GCC_ENABLE_BUILTIN_FUNCTIONS]-description 804 | Controls whether builtin functions that do not begin with `\_\_builtin\_` as prefix are recognized. 805 | 806 | GCC normally generates special code to handle certain builtin 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 builtin 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. 807 | [GCC_ENABLE_BUILTIN_FUNCTIONS]-name 808 | Recognize Builtin Functions 809 | [GCC_ENABLE_BUILTIN_FUNCTIONS]-value-[NO] 810 | No 811 | [GCC_ENABLE_BUILTIN_FUNCTIONS]-value-[YES] 812 | Yes 813 | [GCC_ENABLE_CPP_EXCEPTIONS]-description 814 | Enable 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++. 815 | [GCC_ENABLE_CPP_EXCEPTIONS]-name 816 | Enable C++ Exceptions 817 | [GCC_ENABLE_CPP_EXCEPTIONS]-value-[NO] 818 | No 819 | [GCC_ENABLE_CPP_EXCEPTIONS]-value-[YES] 820 | Yes 821 | [GCC_ENABLE_CPP_RTTI]-description 822 | Enable 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. 823 | [GCC_ENABLE_CPP_RTTI]-name 824 | Enable C++ Runtime Types 825 | [GCC_ENABLE_CPP_RTTI]-value-[NO] 826 | No 827 | [GCC_ENABLE_CPP_RTTI]-value-[YES] 828 | Yes 829 | [GCC_ENABLE_EXCEPTIONS]-description 830 | Enable 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. 831 | [GCC_ENABLE_EXCEPTIONS]-name 832 | Enable Exceptions 833 | [GCC_ENABLE_EXCEPTIONS]-value-[NO] 834 | No 835 | [GCC_ENABLE_EXCEPTIONS]-value-[YES] 836 | Yes 837 | [GCC_ENABLE_FLOATING_POINT_LIBRARY_CALLS]-description 838 | Generate output containing library calls for floating point. 839 | [GCC_ENABLE_FLOATING_POINT_LIBRARY_CALLS]-name 840 | Generate Floating Point Library Calls 841 | [GCC_ENABLE_FLOATING_POINT_LIBRARY_CALLS]-value-[NO] 842 | No 843 | [GCC_ENABLE_FLOATING_POINT_LIBRARY_CALLS]-value-[YES] 844 | Yes 845 | [GCC_ENABLE_KERNEL_DEVELOPMENT]-description 846 | Activating this setting enables kernel development mode. 847 | [GCC_ENABLE_KERNEL_DEVELOPMENT]-name 848 | Kernel Development Mode 849 | [GCC_ENABLE_KERNEL_DEVELOPMENT]-value-[NO] 850 | No 851 | [GCC_ENABLE_KERNEL_DEVELOPMENT]-value-[YES] 852 | Yes 853 | [GCC_ENABLE_OBJC_EXCEPTIONS]-description 854 | This setting enables `@try`/`@catch`/`@throw` syntax for handling exceptions in Objective-C code. Only applies to Objective-C. 855 | [GCC_ENABLE_OBJC_EXCEPTIONS]-name 856 | Enable Objective-C Exceptions 857 | [GCC_ENABLE_OBJC_EXCEPTIONS]-value-[NO] 858 | No 859 | [GCC_ENABLE_OBJC_EXCEPTIONS]-value-[YES] 860 | Yes 861 | [GCC_ENABLE_PASCAL_STRINGS]-description 862 | Recognize and construct Pascal-style string literals. Its use in new code is discouraged. 863 | 864 | Pascal 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. 865 | [GCC_ENABLE_PASCAL_STRINGS]-name 866 | Recognize Pascal Strings 867 | [GCC_ENABLE_PASCAL_STRINGS]-value-[NO] 868 | No 869 | [GCC_ENABLE_PASCAL_STRINGS]-value-[YES] 870 | Yes 871 | [GCC_ENABLE_TRIGRAPHS]-description 872 | Controls whether or not trigraphs are permitted in the source code. 873 | [GCC_ENABLE_TRIGRAPHS]-name 874 | Enable Trigraphs 875 | [GCC_ENABLE_TRIGRAPHS]-value-[NO] 876 | No 877 | [GCC_ENABLE_TRIGRAPHS]-value-[YES] 878 | Yes 879 | [GCC_FAST_MATH]-description 880 | Enables 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. 881 | [GCC_FAST_MATH]-name 882 | Relax IEEE Compliance 883 | [GCC_FAST_MATH]-value-[NO] 884 | No 885 | [GCC_FAST_MATH]-value-[YES] 886 | Yes 887 | [GCC_FAST_OBJC_DISPATCH]-description 888 | This setting enables highly accelerated dispatch to the Objective-C runtime. Only applies to Objective-C. 889 | [GCC_FAST_OBJC_DISPATCH]-name 890 | Accelerated Objective-C Dispatch 891 | [GCC_FAST_OBJC_DISPATCH]-value-[NO] 892 | No 893 | [GCC_FAST_OBJC_DISPATCH]-value-[YES] 894 | Yes 895 | [GCC_GENERATE_DEBUGGING_SYMBOLS]-description 896 | Enables or disables generation of debug symbols. When debug symbols are enabled, the level of detail can be controlled by the `DEBUG_INFORMATION_FORMAT` setting. 897 | [GCC_GENERATE_DEBUGGING_SYMBOLS]-name 898 | Generate Debug Symbols 899 | [GCC_GENERATE_DEBUGGING_SYMBOLS]-value-[NO] 900 | No 901 | [GCC_GENERATE_DEBUGGING_SYMBOLS]-value-[YES] 902 | Yes 903 | [GCC_GENERATE_TEST_COVERAGE_FILES]-description 904 | Activating this setting causes a `notes` file to be produced that the `gcov` code-coverage utility can use to show program coverage. 905 | [GCC_GENERATE_TEST_COVERAGE_FILES]-name 906 | Generate Legacy Test Coverage Files 907 | [GCC_GENERATE_TEST_COVERAGE_FILES]-value-[NO] 908 | No 909 | [GCC_GENERATE_TEST_COVERAGE_FILES]-value-[YES] 910 | Yes 911 | [GCC_INCREASE_PRECOMPILED_HEADER_SHARING]-description 912 | Enabling this option will enable increased sharing of precompiled headers among targets that share the same prefix header and precompiled header directory. 913 | 914 | Xcode 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. 915 | 916 | Enabling 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. 917 | [GCC_INCREASE_PRECOMPILED_HEADER_SHARING]-name 918 | Increase Sharing of Precompiled Headers 919 | [GCC_INCREASE_PRECOMPILED_HEADER_SHARING]-value-[NO] 920 | No 921 | [GCC_INCREASE_PRECOMPILED_HEADER_SHARING]-value-[YES] 922 | Yes 923 | [GCC_INLINES_ARE_PRIVATE_EXTERN]-description 924 | When enabled, out-of-line copies of inline methods are declared `private extern`. 925 | [GCC_INLINES_ARE_PRIVATE_EXTERN]-name 926 | Inline Methods Hidden 927 | [GCC_INLINES_ARE_PRIVATE_EXTERN]-value-[NO] 928 | No 929 | [GCC_INLINES_ARE_PRIVATE_EXTERN]-value-[YES] 930 | Yes 931 | [GCC_INPUT_FILETYPE]-description 932 | Specifies 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. 933 | [GCC_INPUT_FILETYPE]-name 934 | Compile Sources As 935 | [GCC_INPUT_FILETYPE]-value-[automatic] 936 | According to File Type 937 | [GCC_INPUT_FILETYPE]-value-[sourcecode.c.c] 938 | C 939 | [GCC_INPUT_FILETYPE]-value-[sourcecode.c.objc] 940 | Objective-C 941 | [GCC_INPUT_FILETYPE]-value-[sourcecode.cpp.cpp] 942 | C++ 943 | [GCC_INPUT_FILETYPE]-value-[sourcecode.cpp.objcpp] 944 | Objective-C++ 945 | [GCC_INSTRUMENT_PROGRAM_FLOW_ARCS]-description 946 | Activating this setting indicates that code should be added so program flow arcs are instrumented. 947 | [GCC_INSTRUMENT_PROGRAM_FLOW_ARCS]-name 948 | Instrument Program Flow 949 | [GCC_INSTRUMENT_PROGRAM_FLOW_ARCS]-value-[NO] 950 | No 951 | [GCC_INSTRUMENT_PROGRAM_FLOW_ARCS]-value-[YES] 952 | Yes 953 | [GCC_LINK_WITH_DYNAMIC_LIBRARIES]-description 954 | Enabling this option allows linking with the shared libraries. This is the default for most product types. 955 | [GCC_LINK_WITH_DYNAMIC_LIBRARIES]-name 956 | Enable Linking With Shared Libraries 957 | [GCC_LINK_WITH_DYNAMIC_LIBRARIES]-value-[NO] 958 | No 959 | [GCC_LINK_WITH_DYNAMIC_LIBRARIES]-value-[YES] 960 | Yes 961 | [GCC_NO_COMMON_BLOCKS]-description 962 | In 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. 963 | [GCC_NO_COMMON_BLOCKS]-name 964 | No Common Blocks 965 | [GCC_NO_COMMON_BLOCKS]-value-[NO] 966 | No 967 | [GCC_NO_COMMON_BLOCKS]-value-[YES] 968 | Yes 969 | [GCC_OPTIMIZATION_LEVEL]-description 970 | Specifies the degree to which the generated code is optimized for speed and binary size. 971 | 972 | * *None:* Do not optimize. [-O0] 973 | 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. 974 | * *Fast:* Optimizing compilation takes somewhat more time, and a lot more memory for a large function. [-O1] 975 | 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. 976 | * *Faster:* The compiler performs nearly all supported optimizations that do not involve a space-speed tradeoff. [-O2] 977 | 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. 978 | * *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] 979 | * *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] 980 | * *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] 981 | [GCC_OPTIMIZATION_LEVEL]-name 982 | Optimization Level 983 | [GCC_OPTIMIZATION_LEVEL]-value-[0] 984 | None [-O0] 985 | [GCC_OPTIMIZATION_LEVEL]-value-[1] 986 | Fast [-O, O1] 987 | [GCC_OPTIMIZATION_LEVEL]-value-[2] 988 | Faster [-O2] 989 | [GCC_OPTIMIZATION_LEVEL]-value-[3] 990 | Fastest [-O3] 991 | [GCC_OPTIMIZATION_LEVEL]-value-[fast] 992 | Fastest, Aggressive Optimizations [-Ofast] 993 | [GCC_OPTIMIZATION_LEVEL]-value-[s] 994 | Fastest, Smallest [-Os] 995 | [GCC_PRECOMPILE_PREFIX_HEADER]-description 996 | Generates a precompiled header for the prefix header, which should reduce overall build times. 997 | 998 | 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. 999 | [GCC_PRECOMPILE_PREFIX_HEADER]-name 1000 | Precompile Prefix Header 1001 | [GCC_PRECOMPILE_PREFIX_HEADER]-value-[NO] 1002 | No 1003 | [GCC_PRECOMPILE_PREFIX_HEADER]-value-[YES] 1004 | Yes 1005 | [GCC_PREFIX_HEADER]-description 1006 | Implicitly include the named header. The path given should either be a project relative path or an absolute path. 1007 | [GCC_PREFIX_HEADER]-name 1008 | Prefix Header 1009 | [GCC_PREFIX_HEADER]-value-[NO] 1010 | No 1011 | [GCC_PREFIX_HEADER]-value-[YES] 1012 | Yes 1013 | [GCC_PREPROCESSOR_DEFINITIONS]-description 1014 | Space-separated list of preprocessor macros of the form `foo` or `foo=bar`. 1015 | [GCC_PREPROCESSOR_DEFINITIONS]-name 1016 | Preprocessor Macros 1017 | [GCC_PREPROCESSOR_DEFINITIONS_NOT_USED_IN_PRECOMPS]-description 1018 | Space-separated list of preprocessor macros of the form `foo` or `foo=bar`. These macros are not used when precompiling a prefix header file. 1019 | [GCC_PREPROCESSOR_DEFINITIONS_NOT_USED_IN_PRECOMPS]-name 1020 | Preprocessor Macros Not Used In Precompiled Headers 1021 | [GCC_REUSE_STRINGS]-description 1022 | Reuse string literals. 1023 | [GCC_REUSE_STRINGS]-name 1024 | Make Strings Read-Only 1025 | [GCC_REUSE_STRINGS]-value-[NO] 1026 | No 1027 | [GCC_REUSE_STRINGS]-value-[YES] 1028 | Yes 1029 | [GCC_SHORT_ENUMS]-description 1030 | Make enums only as large as needed for the range of possible values. 1031 | 1032 | This setting generates code that may not binary compatible with code generated without this setting or with macOS frameworks. 1033 | [GCC_SHORT_ENUMS]-name 1034 | Short Enumeration Constants 1035 | [GCC_SHORT_ENUMS]-value-[NO] 1036 | No 1037 | [GCC_SHORT_ENUMS]-value-[YES] 1038 | Yes 1039 | [GCC_STRICT_ALIASING]-description 1040 | Optimize 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. 1041 | [GCC_STRICT_ALIASING]-name 1042 | Enforce Strict Aliasing 1043 | [GCC_STRICT_ALIASING]-value-[NO] 1044 | No 1045 | [GCC_STRICT_ALIASING]-value-[YES] 1046 | Yes 1047 | [GCC_SYMBOLS_PRIVATE_EXTERN]-description 1048 | When 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](https://developer.apple.com/library/content/documentation/DeveloperTools/Conceptual/CppRuntimeEnv/Articles/SymbolVisibility.html#//apple_ref/doc/uid/TP40001670-CJBGBHEJ) in [C++ Runtime Environment Programming Guide](https://developer.apple.com/library/content/documentation/DeveloperTools/Conceptual/CppRuntimeEnv/CPPRuntimeEnv.html). 1049 | [GCC_SYMBOLS_PRIVATE_EXTERN]-name 1050 | Symbols Hidden by Default 1051 | [GCC_SYMBOLS_PRIVATE_EXTERN]-value-[NO] 1052 | No 1053 | [GCC_SYMBOLS_PRIVATE_EXTERN]-value-[YES] 1054 | Yes 1055 | [GCC_TREAT_IMPLICIT_FUNCTION_DECLARATIONS_AS_ERRORS]-description 1056 | Causes warnings about missing function prototypes to be treated as errors. Only applies to C and Objective-C. 1057 | [GCC_TREAT_IMPLICIT_FUNCTION_DECLARATIONS_AS_ERRORS]-name 1058 | Treat Missing Function Prototypes as Errors 1059 | [GCC_TREAT_IMPLICIT_FUNCTION_DECLARATIONS_AS_ERRORS]-value-[NO] 1060 | No 1061 | [GCC_TREAT_IMPLICIT_FUNCTION_DECLARATIONS_AS_ERRORS]-value-[YES] 1062 | Yes 1063 | [GCC_TREAT_INCOMPATIBLE_POINTER_TYPE_WARNINGS_AS_ERRORS]-description 1064 | Enabling this option causes warnings about incompatible pointer types to be treated as errors. 1065 | [GCC_TREAT_INCOMPATIBLE_POINTER_TYPE_WARNINGS_AS_ERRORS]-name 1066 | Treat Incompatible Pointer Type Warnings as Errors 1067 | [GCC_TREAT_INCOMPATIBLE_POINTER_TYPE_WARNINGS_AS_ERRORS]-value-[NO] 1068 | No 1069 | [GCC_TREAT_INCOMPATIBLE_POINTER_TYPE_WARNINGS_AS_ERRORS]-value-[YES] 1070 | Yes 1071 | [GCC_TREAT_WARNINGS_AS_ERRORS]-description 1072 | Enabling this option causes all warnings to be treated as errors. 1073 | [GCC_TREAT_WARNINGS_AS_ERRORS]-name 1074 | Treat Warnings as Errors 1075 | [GCC_TREAT_WARNINGS_AS_ERRORS]-value-[NO] 1076 | No 1077 | [GCC_TREAT_WARNINGS_AS_ERRORS]-value-[YES] 1078 | Yes 1079 | [GCC_UNROLL_LOOPS]-description 1080 | Unrolls loops. Unrolling makes the code larger, but may make it faster by reducing the number of branches executed. 1081 | [GCC_UNROLL_LOOPS]-name 1082 | Unroll Loops 1083 | [GCC_UNROLL_LOOPS]-value-[NO] 1084 | No 1085 | [GCC_UNROLL_LOOPS]-value-[YES] 1086 | Yes 1087 | [GCC_USE_STANDARD_INCLUDE_SEARCHING]-description 1088 | Controls 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. 1089 | [GCC_USE_STANDARD_INCLUDE_SEARCHING]-name 1090 | Use Standard System Header Directory Searching 1091 | [GCC_USE_STANDARD_INCLUDE_SEARCHING]-value-[NO] 1092 | No 1093 | [GCC_USE_STANDARD_INCLUDE_SEARCHING]-value-[YES] 1094 | Yes 1095 | [GCC_WARN_64_TO_32_BIT_CONVERSION]-description 1096 | Warn if a value is implicitly converted from a 64-bit type to a 32-bit type. This is a subset of the warnings provided by -Wconversion. 1097 | [GCC_WARN_64_TO_32_BIT_CONVERSION]-name 1098 | Implicit Conversion to 32 Bit Type 1099 | [GCC_WARN_64_TO_32_BIT_CONVERSION]-value-[NO] 1100 | No 1101 | [GCC_WARN_64_TO_32_BIT_CONVERSION]-value-[YES] 1102 | Yes 1103 | [GCC_WARN_64_TO_32_BIT_CONVERSION]-value-[YES_ERROR] 1104 | Yes (Error) 1105 | [GCC_WARN_ABOUT_DEPRECATED_FUNCTIONS]-description 1106 | Warn about the use of deprecated functions, variables, and types (as indicated by the `deprecated` attribute). 1107 | [GCC_WARN_ABOUT_DEPRECATED_FUNCTIONS]-name 1108 | Deprecated Functions 1109 | [GCC_WARN_ABOUT_DEPRECATED_FUNCTIONS]-value-[NO] 1110 | No 1111 | [GCC_WARN_ABOUT_DEPRECATED_FUNCTIONS]-value-[YES] 1112 | Yes 1113 | [GCC_WARN_ABOUT_INVALID_OFFSETOF_MACRO]-description 1114 | Unchecking 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. 1115 | 1116 | The restrictions on `offsetof` may be relaxed in a future version of the C++ standard. 1117 | [GCC_WARN_ABOUT_INVALID_OFFSETOF_MACRO]-name 1118 | Undefined Use of offsetof Macro 1119 | [GCC_WARN_ABOUT_INVALID_OFFSETOF_MACRO]-value-[NO] 1120 | No 1121 | [GCC_WARN_ABOUT_INVALID_OFFSETOF_MACRO]-value-[YES] 1122 | Yes 1123 | [GCC_WARN_ABOUT_MISSING_FIELD_INITIALIZERS]-description 1124 | Warn 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: 1125 | 1126 | struct s { int f, g, h; }; 1127 | struct s x = { 3, 4 }; 1128 | 1129 | This option does not warn about designated initializers, so the following modification would not trigger a warning: 1130 | 1131 | struct s { int f, g, h; }; 1132 | struct s x = { .f = 3, .g = 4 }; 1133 | [GCC_WARN_ABOUT_MISSING_FIELD_INITIALIZERS]-name 1134 | Missing Fields in Structure Initializers 1135 | [GCC_WARN_ABOUT_MISSING_FIELD_INITIALIZERS]-value-[NO] 1136 | No 1137 | [GCC_WARN_ABOUT_MISSING_FIELD_INITIALIZERS]-value-[YES] 1138 | Yes 1139 | [GCC_WARN_ABOUT_MISSING_NEWLINE]-description 1140 | Warn when a source file does not end with a newline. 1141 | [GCC_WARN_ABOUT_MISSING_NEWLINE]-name 1142 | Missing Newline At End Of File 1143 | [GCC_WARN_ABOUT_MISSING_NEWLINE]-value-[NO] 1144 | No 1145 | [GCC_WARN_ABOUT_MISSING_NEWLINE]-value-[YES] 1146 | Yes 1147 | [GCC_WARN_ABOUT_MISSING_PROTOTYPES]-description 1148 | Causes warnings to be emitted about missing prototypes. 1149 | [GCC_WARN_ABOUT_MISSING_PROTOTYPES]-name 1150 | Missing Function Prototypes 1151 | [GCC_WARN_ABOUT_MISSING_PROTOTYPES]-value-[NO] 1152 | No 1153 | [GCC_WARN_ABOUT_MISSING_PROTOTYPES]-value-[YES] 1154 | Yes 1155 | [GCC_WARN_ABOUT_POINTER_SIGNEDNESS]-description 1156 | Warn when pointers passed via arguments or assigned to a variable differ in sign. 1157 | [GCC_WARN_ABOUT_POINTER_SIGNEDNESS]-name 1158 | Pointer Sign Comparison 1159 | [GCC_WARN_ABOUT_POINTER_SIGNEDNESS]-value-[NO] 1160 | No 1161 | [GCC_WARN_ABOUT_POINTER_SIGNEDNESS]-value-[YES] 1162 | Yes 1163 | [GCC_WARN_ABOUT_RETURN_TYPE]-description 1164 | Causes 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. 1165 | [GCC_WARN_ABOUT_RETURN_TYPE]-name 1166 | Mismatched Return Type 1167 | [GCC_WARN_ABOUT_RETURN_TYPE]-value-[NO] 1168 | No 1169 | [GCC_WARN_ABOUT_RETURN_TYPE]-value-[YES] 1170 | Yes 1171 | [GCC_WARN_ABOUT_RETURN_TYPE]-value-[YES_ERROR] 1172 | Yes (treat as error) 1173 | [GCC_WARN_ALLOW_INCOMPLETE_PROTOCOL]-description 1174 | Warn if methods required by a protocol are not implemented in the class adopting it. Only applies to Objective-C. 1175 | [GCC_WARN_ALLOW_INCOMPLETE_PROTOCOL]-name 1176 | Incomplete Objective-C Protocols 1177 | [GCC_WARN_ALLOW_INCOMPLETE_PROTOCOL]-value-[NO] 1178 | No 1179 | [GCC_WARN_ALLOW_INCOMPLETE_PROTOCOL]-value-[YES] 1180 | Yes 1181 | [GCC_WARN_CHECK_SWITCH_STATEMENTS]-description 1182 | Warn 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. 1183 | [GCC_WARN_CHECK_SWITCH_STATEMENTS]-name 1184 | Check Switch Statements 1185 | [GCC_WARN_CHECK_SWITCH_STATEMENTS]-value-[NO] 1186 | No 1187 | [GCC_WARN_CHECK_SWITCH_STATEMENTS]-value-[YES] 1188 | Yes 1189 | [GCC_WARN_FOUR_CHARACTER_CONSTANTS]-description 1190 | Warn about four-char literals (for example, macOS-style `OSTypes`: `'APPL'`). 1191 | [GCC_WARN_FOUR_CHARACTER_CONSTANTS]-name 1192 | Four Character Literals 1193 | [GCC_WARN_FOUR_CHARACTER_CONSTANTS]-value-[NO] 1194 | No 1195 | [GCC_WARN_FOUR_CHARACTER_CONSTANTS]-value-[YES] 1196 | Yes 1197 | [GCC_WARN_HIDDEN_VIRTUAL_FUNCTIONS]-description 1198 | Warn when a function declaration hides virtual functions from a base class. 1199 | 1200 | For example, in the following example, the `A` class version of `f()` is hidden in `B`. 1201 | 1202 | struct A { 1203 | virtual void f(); 1204 | }; 1205 | 1206 | struct B: public A { 1207 | void f(int); 1208 | }; 1209 | 1210 | As a result, the following code will fail to compile. 1211 | 1212 | B* b; 1213 | b->f(); 1214 | 1215 | This setting only applies to C++ and Objective-C++ sources. 1216 | [GCC_WARN_HIDDEN_VIRTUAL_FUNCTIONS]-name 1217 | Overloaded Virtual Functions 1218 | [GCC_WARN_HIDDEN_VIRTUAL_FUNCTIONS]-value-[NO] 1219 | No 1220 | [GCC_WARN_HIDDEN_VIRTUAL_FUNCTIONS]-value-[YES] 1221 | Yes 1222 | [GCC_WARN_INHIBIT_ALL_WARNINGS]-description 1223 | Inhibit all warning messages. 1224 | [GCC_WARN_INHIBIT_ALL_WARNINGS]-name 1225 | Inhibit All Warnings 1226 | [GCC_WARN_INHIBIT_ALL_WARNINGS]-value-[NO] 1227 | No 1228 | [GCC_WARN_INHIBIT_ALL_WARNINGS]-value-[YES] 1229 | Yes 1230 | [GCC_WARN_INITIALIZER_NOT_FULLY_BRACKETED]-description 1231 | Warn 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. 1232 | 1233 | int a[2][2] = { 0, 1, 2, 3 }; 1234 | int b[2][2] = { { 0, 1 }, { 2, 3 } }; 1235 | 1236 | [GCC_WARN_INITIALIZER_NOT_FULLY_BRACKETED]-name 1237 | Initializer Not Fully Bracketed 1238 | [GCC_WARN_INITIALIZER_NOT_FULLY_BRACKETED]-value-[NO] 1239 | No 1240 | [GCC_WARN_INITIALIZER_NOT_FULLY_BRACKETED]-value-[YES] 1241 | Yes 1242 | [GCC_WARN_MISSING_PARENTHESES]-description 1243 | Warn 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: 1244 | 1245 | { 1246 | if (a) 1247 | if (b) 1248 | foo (); 1249 | else 1250 | bar (); 1251 | } 1252 | 1253 | In 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: 1254 | 1255 | { 1256 | if (a) 1257 | { 1258 | if (b) 1259 | foo (); 1260 | else 1261 | bar (); 1262 | } 1263 | } 1264 | 1265 | [GCC_WARN_MISSING_PARENTHESES]-name 1266 | Missing Braces and Parentheses 1267 | [GCC_WARN_MISSING_PARENTHESES]-value-[NO] 1268 | No 1269 | [GCC_WARN_MISSING_PARENTHESES]-value-[YES] 1270 | Yes 1271 | [GCC_WARN_NON_VIRTUAL_DESTRUCTOR]-description 1272 | Warn 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. 1273 | [GCC_WARN_NON_VIRTUAL_DESTRUCTOR]-name 1274 | Nonvirtual Destructor 1275 | [GCC_WARN_NON_VIRTUAL_DESTRUCTOR]-value-[NO] 1276 | No 1277 | [GCC_WARN_NON_VIRTUAL_DESTRUCTOR]-value-[YES] 1278 | Yes 1279 | [GCC_WARN_PEDANTIC]-description 1280 | Issue 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. 1281 | [GCC_WARN_PEDANTIC]-name 1282 | Pedantic Warnings 1283 | [GCC_WARN_PEDANTIC]-value-[NO] 1284 | No 1285 | [GCC_WARN_PEDANTIC]-value-[YES] 1286 | Yes 1287 | [GCC_WARN_SHADOW]-description 1288 | Warn whenever a local variable shadows another local variable, parameter or global variable or whenever a builtin function is shadowed. 1289 | [GCC_WARN_SHADOW]-name 1290 | Hidden Local Variables 1291 | [GCC_WARN_SHADOW]-value-[NO] 1292 | No 1293 | [GCC_WARN_SHADOW]-value-[YES] 1294 | Yes 1295 | [GCC_WARN_SIGN_COMPARE]-description 1296 | Warn when a comparison between signed and unsigned values could produce an incorrect result when the signed value is converted to unsigned. 1297 | [GCC_WARN_SIGN_COMPARE]-name 1298 | Sign Comparison 1299 | [GCC_WARN_SIGN_COMPARE]-value-[NO] 1300 | No 1301 | [GCC_WARN_SIGN_COMPARE]-value-[YES] 1302 | Yes 1303 | [GCC_WARN_STRICT_SELECTOR_MATCH]-description 1304 | Warn 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. 1305 | [GCC_WARN_STRICT_SELECTOR_MATCH]-name 1306 | Strict Selector Matching 1307 | [GCC_WARN_TYPECHECK_CALLS_TO_PRINTF]-description 1308 | Check 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. 1309 | [GCC_WARN_TYPECHECK_CALLS_TO_PRINTF]-name 1310 | Typecheck Calls to printf/scanf 1311 | [GCC_WARN_TYPECHECK_CALLS_TO_PRINTF]-value-[NO] 1312 | No 1313 | [GCC_WARN_TYPECHECK_CALLS_TO_PRINTF]-value-[YES] 1314 | Yes 1315 | [GCC_WARN_UNDECLARED_SELECTOR]-description 1316 | Warn 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. 1317 | [GCC_WARN_UNDECLARED_SELECTOR]-name 1318 | Undeclared Selector 1319 | [GCC_WARN_UNINITIALIZED_AUTOS]-description 1320 | Warn if a variable might be clobbered by a `setjmp` call or if an automatic variable is used without prior initialization. 1321 | 1322 | 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. 1323 | [GCC_WARN_UNINITIALIZED_AUTOS]-name 1324 | Uninitialized Variables 1325 | [GCC_WARN_UNINITIALIZED_AUTOS]-value-[NO] 1326 | No 1327 | [GCC_WARN_UNINITIALIZED_AUTOS]-value-[YES] 1328 | Yes 1329 | [GCC_WARN_UNINITIALIZED_AUTOS]-value-[YES_AGGRESSIVE] 1330 | Yes (Aggressive) 1331 | [GCC_WARN_UNKNOWN_PRAGMAS]-description 1332 | Warn 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. 1333 | [GCC_WARN_UNKNOWN_PRAGMAS]-name 1334 | Unknown Pragma 1335 | [GCC_WARN_UNKNOWN_PRAGMAS]-value-[NO] 1336 | No 1337 | [GCC_WARN_UNKNOWN_PRAGMAS]-value-[YES] 1338 | Yes 1339 | [GCC_WARN_UNUSED_FUNCTION]-description 1340 | Warn whenever a static function is declared but not defined or a noninline static function is unused. 1341 | [GCC_WARN_UNUSED_FUNCTION]-name 1342 | Unused Functions 1343 | [GCC_WARN_UNUSED_FUNCTION]-value-[NO] 1344 | No 1345 | [GCC_WARN_UNUSED_FUNCTION]-value-[YES] 1346 | Yes 1347 | [GCC_WARN_UNUSED_LABEL]-description 1348 | Warn whenever a label is declared but not used. 1349 | [GCC_WARN_UNUSED_LABEL]-name 1350 | Unused Labels 1351 | [GCC_WARN_UNUSED_LABEL]-value-[NO] 1352 | No 1353 | [GCC_WARN_UNUSED_LABEL]-value-[YES] 1354 | Yes 1355 | [GCC_WARN_UNUSED_PARAMETER]-description 1356 | Warn whenever a function parameter is unused aside from its declaration. 1357 | [GCC_WARN_UNUSED_PARAMETER]-name 1358 | Unused Parameters 1359 | [GCC_WARN_UNUSED_PARAMETER]-value-[NO] 1360 | No 1361 | [GCC_WARN_UNUSED_PARAMETER]-value-[YES] 1362 | Yes 1363 | [GCC_WARN_UNUSED_VALUE]-description 1364 | Warn whenever a statement computes a result that is explicitly not used. 1365 | [GCC_WARN_UNUSED_VALUE]-name 1366 | Unused Values 1367 | [GCC_WARN_UNUSED_VALUE]-value-[NO] 1368 | No 1369 | [GCC_WARN_UNUSED_VALUE]-value-[YES] 1370 | Yes 1371 | [GCC_WARN_UNUSED_VARIABLE]-description 1372 | Warn whenever a local variable or nonconstant static variable is unused aside from its declaration. 1373 | [GCC_WARN_UNUSED_VARIABLE]-name 1374 | Unused Variables 1375 | [GCC_WARN_UNUSED_VARIABLE]-value-[NO] 1376 | No 1377 | [GCC_WARN_UNUSED_VARIABLE]-value-[YES] 1378 | Yes 1379 | [LLVM_LTO]-description 1380 | Enabling this setting allows optimization across file boundaries during linking. 1381 | 1382 | * *No:* Disabled. Do not use link-time optimization. 1383 | * *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. 1384 | * *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. 1385 | [LLVM_LTO]-name 1386 | Link-Time Optimization 1387 | [LLVM_LTO]-value-[NO] 1388 | No 1389 | [LLVM_LTO]-value-[YES] 1390 | Monolithic 1391 | [LLVM_LTO]-value-[YES_THIN] 1392 | Incremental 1393 | [LanguageCXX]-category 1394 | Language - C++ 1395 | [LanguageModules]-category 1396 | Language - Modules 1397 | [LanguageObjC]-category 1398 | Language - Objective C 1399 | [Language]-category 1400 | Language 1401 | [OTHER_CFLAGS]-description 1402 | Space-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. 1403 | [OTHER_CFLAGS]-name 1404 | Other C Flags 1405 | [OTHER_CPLUSPLUSFLAGS]-description 1406 | Space-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. 1407 | [OTHER_CPLUSPLUSFLAGS]-name 1408 | Other C++ Flags 1409 | [Preprocessing]-category 1410 | Preprocessing 1411 | [RUN_CLANG_STATIC_ANALYZER]-description 1412 | Activating this setting will cause Xcode to run the `Clang` static analysis tool on qualifying source files during every build. 1413 | [RUN_CLANG_STATIC_ANALYZER]-name 1414 | Analyze During 'Build' 1415 | [SAAppleAPICheckers]-category 1416 | Issues - Apple APIs 1417 | [SACheckers]-category 1418 | Generic Issues 1419 | [SAObjCCheckers]-category 1420 | Issues - Objective-C 1421 | [SAPolicy]-category 1422 | Analysis Policy 1423 | [SASecurityCheckers]-category 1424 | Issues - Security 1425 | [UBSANPolicy]-category 1426 | Undefined Behavior Sanitizer 1427 | [WARNING_CFLAGS]-description 1428 | Space-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. 1429 | [WARNING_CFLAGS]-name 1430 | Other Warning Flags 1431 | [WarningsCXX]-category 1432 | Warnings - C++ 1433 | [WarningsObjCARC]-category 1434 | Warnings - Objective C and ARC 1435 | [WarningsObjC]-category 1436 | Warnings - Objective C 1437 | [WarningsPolicy]-category 1438 | Warning Policies 1439 | [Warnings]-category 1440 | Warnings - All languages 1441 | 1442 | 1443 | -------------------------------------------------------------------------------- /Obfuscator.xcplugin/Contents/Resources/Obfuscator.xcspec: -------------------------------------------------------------------------------- 1 | // 2 | // LLVM 9.0 compiler build task 3 | // Copyright (c) 2000-2016 Apple Inc. All rights reserved. 4 | // 5 | ( 6 | { 7 | Identifier = "com.apple.compilers.llvm.obfuscator.4_0"; 8 | Type = Compiler; 9 | Class = "XCCompilerSpecificationClang"; 10 | Name = "Obfuscator 4.0"; 11 | Description = "Obfuscator 4.0 compiler"; 12 | Vendor = HEIG-VD; 13 | Version = "4.0"; 14 | IsAbstract = NO; 15 | ShowInCompilerSelectionPopup = YES; 16 | FileTypes = ( 17 | "sourcecode.c.c", 18 | "sourcecode.c.objc", 19 | "sourcecode.cpp.cpp", 20 | "sourcecode.cpp.objcpp", 21 | "sourcecode.asm", 22 | ); 23 | OptionConditionFlavors = ( 24 | arch, 25 | sdk, 26 | ); 27 | BuiltinJambaseRuleName = ProcessC; 28 | ExecPath = "/Users/obaby/Soft/obfuscator/build/bin/clang"; 29 | ExecDescription = "Compile $(InputFile)"; 30 | ProgressDescription = "Compiling $(CommandProgressByType) source files"; 31 | ExecDescriptionForPrecompile = "Precompile $(InputFile)"; 32 | ProgressDescriptionForPrecompile = "Precompiling $(CommandProgressByType) prefix headers"; 33 | UseCPlusPlusCompilerDriverWhenBundlizing = Yes; 34 | CommandOutputParser = "XCSimpleBufferedCommandOutputParser"; 35 | SupportsHeadermaps = Yes; 36 | DashIFlagAcceptsHeadermaps = Yes; 37 | SupportsIsysroot = Yes; 38 | SupportsPredictiveCompilation = No; 39 | SupportsSeparateUserHeaderPaths = Yes; 40 | SupportsMacOSXDeploymentTarget = Yes; 41 | SupportsMacOSXMinVersionFlag = Yes; 42 | PatternsOfFlagsNotAffectingPrecomps = ( 43 | "-v", 44 | "-###", 45 | "-H", 46 | "-time", 47 | "-save-temps", 48 | "-W*", 49 | "-w", 50 | "-fdiagnostics-show-note-include-stack", 51 | "-fmacro-backtrace-limit*", 52 | "-fmessage-length*", 53 | "-fcolor-diagnostics", 54 | "-fvectorize", 55 | "-flto", 56 | "-fstrict-aliasing", 57 | "-fno-strict-aliasing", 58 | "-fmodules-autolink", 59 | "-fmodules-prune-interval*", 60 | "-fmodules-prune-after*", 61 | "-fbuild-session-timestamp*", 62 | "-fmodules-validate-once-per-build-session", 63 | ); 64 | MessageCategoryInfoOptions = ( "--print-diagnostic-categories" ); 65 | Options = ( 66 | { 67 | Name = arch; 68 | Type = String; 69 | CommandLineArgs = { 70 | "<>" = ( 71 | "-arch", 72 | "$(value)", 73 | ); 74 | }; 75 | }, 76 | { 77 | Name = "diagnostic_message_length"; 78 | Type = String; 79 | DefaultValue = 0; 80 | CommandLinePrefixFlag = "-fmessage-length="; 81 | }, 82 | { 83 | Name = "print_note_include_stack"; 84 | Type = Boolean; 85 | DefaultValue = YES; 86 | CommandLineArgs = { 87 | YES = ("-fdiagnostics-show-note-include-stack"); 88 | NO = (); 89 | }; 90 | }, 91 | { 92 | Name = "CLANG_MACRO_BACKTRACE_LIMIT"; 93 | Type = String; 94 | DefaultValue = 0; 95 | CommandLinePrefixFlag = "-fmacro-backtrace-limit="; 96 | }, 97 | { 98 | // Note: this flag impacts PCH. 99 | Name = "CLANG_RETAIN_COMMENTS_FROM_SYSTEM_HEADERS"; 100 | Type = Boolean; 101 | DefaultValue = NO; 102 | CommandLineArgs = { 103 | YES = ("-fretain-comments-from-system-headers"); 104 | NO = (); 105 | }; 106 | }, 107 | { 108 | // Note: this flag does NOT impact PCH or compilation. 109 | // The build system makes special efforts to ignore 110 | // -fcolor-diagnostics for dependency tracking. 111 | Name = "CLANG_COLOR_DIAGNOSTICS"; 112 | Type = Boolean; 113 | DefaultValue = "$(COLOR_DIAGNOSTICS)"; 114 | CommandLineArgs = { 115 | YES = ("-fcolor-diagnostics"); 116 | NO = (); 117 | }; 118 | }, 119 | { 120 | Name = "GCC_INPUT_FILETYPE"; 121 | Type = Enumeration; 122 | Values = ( 123 | automatic, 124 | "sourcecode.c.c", 125 | "sourcecode.c.objc", 126 | "sourcecode.cpp.cpp", 127 | "sourcecode.cpp.objcpp", 128 | ); 129 | DefaultValue = automatic; 130 | Category = Language; 131 | }, 132 | { 133 | Name = "GCC_OPERATION"; 134 | Type = Enumeration; 135 | Values = ( 136 | compile, 137 | "generate-preprocessed", 138 | "generate-assembler", 139 | precompile, 140 | "separate-symbols", 141 | ); 142 | DefaultValue = compile; 143 | }, 144 | { 145 | Name = "GCC_USE_STANDARD_INCLUDE_SEARCHING"; 146 | Type = Boolean; 147 | DefaultValue = YES; 148 | CommandLineArgs = { 149 | YES = (); 150 | NO = ( 151 | "-nostdinc", 152 | ); 153 | }; 154 | Category = Language; 155 | }, 156 | { 157 | Name = "GCC_C_LANGUAGE_STANDARD"; 158 | Type = Enumeration; 159 | Values = ( 160 | ansi, 161 | c89, 162 | gnu89, 163 | c99, 164 | gnu99, 165 | c11, 166 | gnu11, 167 | "compiler-default", 168 | ); 169 | DefaultValue = "compiler-default"; 170 | CommandLineArgs = { 171 | ansi = ( 172 | "-ansi", 173 | ); 174 | "compiler-default" = (); 175 | "<>" = ( 176 | "-std=$(value)", 177 | ); 178 | }; 179 | FileTypes = ( 180 | "sourcecode.c.c", 181 | "sourcecode.c.objc", 182 | ); 183 | Category = Language; 184 | }, 185 | { 186 | Name = "CLANG_CXX_LANGUAGE_STANDARD"; 187 | Type = Enumeration; 188 | Values = ( 189 | "c++98", 190 | "gnu++98", 191 | "c++0x", 192 | "gnu++0x", 193 | "c++14", 194 | "gnu++14", 195 | "c++17", 196 | "gnu++17", 197 | "compiler-default", 198 | ); 199 | DefaultValue = "compiler-default"; 200 | CommandLineArgs = { 201 | "compiler-default" = (); 202 | // We need these two entries that reference c++0x to 203 | // maintain compatibility of old build settings. 204 | "c++0x" = ( "-std=c++11" ); 205 | "gnu++0x" = ( "-std=gnu++11" ); 206 | // C++17 is not ratified yet. 207 | // Map to current compiler flag. 208 | "c++17" = ( "-std=c++1z" ); 209 | "gnu++17" = ( "-std=gnu++1z" ); 210 | // Default for everything else. 211 | "<>" = ( 212 | "-std=$(value)", 213 | ); 214 | }; 215 | FileTypes = ( 216 | "sourcecode.cpp.cpp", 217 | "sourcecode.cpp.objcpp", 218 | ); 219 | Category = LanguageCXX; 220 | }, 221 | { 222 | Name = "CLANG_CXX_LIBRARY"; 223 | Type = Enumeration; 224 | Values = ( 225 | "libstdc++", 226 | "libc++", 227 | "compiler-default", 228 | ); 229 | DefaultValue = "compiler-default"; 230 | FileTypes = ( 231 | "sourcecode.cpp.cpp", 232 | "sourcecode.cpp.objcpp", 233 | ); 234 | CommandLineArgs = { 235 | "compiler-default" = (); 236 | "<>" = ( "-stdlib=$(value)" ); 237 | }; 238 | AdditionalLinkerArgs = { 239 | "compiler-default" = (); 240 | "<>" = ( "-stdlib=$(value)" ); 241 | }; 242 | AppearsAfter = "CLANG_CXX_LANGUAGE_STANDARD"; 243 | Category = LanguageCXX; 244 | }, 245 | { 246 | Name = "CLANG_ENABLE_OBJC_ARC"; 247 | Type = Boolean; 248 | DefaultValue = NO; 249 | CommandLineArgs = { 250 | YES = ( 251 | "-fobjc-arc", 252 | ); 253 | NO = (); 254 | }; 255 | AdditionalLinkerArgs = { 256 | YES = ( 257 | "-fobjc-arc", 258 | ); 259 | NO = (); 260 | }; 261 | FileTypes = ( 262 | "sourcecode.c.objc", 263 | "sourcecode.cpp.objcpp", 264 | ); 265 | Category = LanguageObjC; 266 | }, 267 | { 268 | Name = "CLANG_ENABLE_OBJC_WEAK"; 269 | Type = Boolean; 270 | DefaultValue = NO; 271 | CommandLineArgs = { 272 | YES = ( 273 | "-fobjc-weak", 274 | ); 275 | NO = (); 276 | }; 277 | FileTypes = ( 278 | "sourcecode.c.objc", 279 | "sourcecode.cpp.objcpp", 280 | ); 281 | Category = LanguageObjC; 282 | }, 283 | { 284 | Name = "CLANG_LINK_OBJC_RUNTIME"; 285 | Type = Boolean; 286 | DefaultValue = YES; 287 | CommandLineArgs = { 288 | YES = (); 289 | NO = (); 290 | }; 291 | // This option is passed for linking to inform the compiler 292 | // that the ObjC runtime must be linked in (with possible 293 | // backwards compatibility libraries linked in). 294 | AdditionalLinkerArgs = { 295 | YES = ( "-fobjc-link-runtime" ); 296 | NO = (); 297 | }; 298 | FileTypes = ( 299 | "sourcecode.c.objc", 300 | "sourcecode.cpp.objcpp", 301 | ); 302 | Category = LanguageObjC; 303 | }, 304 | { 305 | Name = "CLANG_ENABLE_MODULES"; 306 | Type = Boolean; 307 | DefaultValue = NO; 308 | CommandLineArgs = { 309 | YES = ( "-fmodules" ); 310 | NO = (); 311 | }; 312 | Category = LanguageModules; 313 | }, 314 | { 315 | Name = "CLANG_ENABLE_MODULE_DEBUGGING"; 316 | Type = Boolean; 317 | DefaultValue = YES; 318 | Category = LanguageModules; 319 | DisplayName = "Enable Clang Module Debugging"; 320 | Description = "When 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."; 321 | }, 322 | { 323 | Name = "CLANG_DEBUG_MODULES"; 324 | Type = Boolean; 325 | DefaultValue = "$(CLANG_ENABLE_MODULE_DEBUGGING)"; 326 | CommandLineArgs = { 327 | YES = ( "-gmodules" ); 328 | NO = (); 329 | }; 330 | Condition = "$(GCC_GENERATE_DEBUGGING_SYMBOLS) == YES && ( $(CLANG_ENABLE_MODULES) == YES || ( $(GCC_PREFIX_HEADER) != '' && $(GCC_PRECOMPILE_PREFIX_HEADER) == YES ) )"; 331 | SupportedVersionRanges = ( "800.0.0" ); 332 | // Hidden. 333 | }, 334 | { 335 | Name = "CLANG_MODULE_CACHE_PATH"; 336 | Type = String; 337 | DefaultValue = "$(MODULE_CACHE_DIR)"; 338 | CommandLineArgs = { 339 | "" = (); 340 | "<>" = ( "-fmodules-cache-path=$(CLANG_MODULE_CACHE_PATH)" ); 341 | }; 342 | Condition = "$(CLANG_ENABLE_MODULES) == YES"; 343 | // Intentionally hidden. 344 | }, 345 | { 346 | Name = "CLANG_MODULES_AUTOLINK"; 347 | Type = Boolean; 348 | DefaultValue = YES; 349 | CommandLineArgs = { 350 | YES = (); 351 | NO = ("-fno-autolink"); 352 | }; 353 | Condition = "$(CLANG_ENABLE_MODULES) == YES"; 354 | Category = LanguageModules; 355 | }, 356 | { 357 | Name = "CLANG_MODULES_PRUNE_INTERVAL"; 358 | Type = String; 359 | DefaultValue = "86400"; 360 | CommandLineArgs = { 361 | "" = (); 362 | "<>" = ( 363 | "-fmodules-prune-interval=$(value)", 364 | ); 365 | }; 366 | Condition = "$(CLANG_ENABLE_MODULES) == YES"; 367 | // Hidden. 368 | }, 369 | { 370 | Name = "CLANG_MODULES_PRUNE_AFTER"; 371 | Type = String; 372 | DefaultValue = "345600"; 373 | CommandLineArgs = { 374 | "" = (); 375 | "<>" = ( 376 | "-fmodules-prune-after=$(value)", 377 | ); 378 | }; 379 | Condition = "$(CLANG_ENABLE_MODULES) == YES"; 380 | // Hidden. 381 | }, 382 | { 383 | Name = "CLANG_MODULES_IGNORE_MACROS"; 384 | Type = StringList; 385 | DefaultValue = "$(GCC_PREPROCESSOR_DEFINITIONS_NOT_USED_IN_PRECOMPS)"; 386 | CommandLineArgs = ( 387 | "-fmodules-ignore-macro=$(value)", 388 | ); 389 | Condition = "$(CLANG_ENABLE_MODULES) == YES"; 390 | // Intentionally hidden; part of CLANG_ENABLE_MODULES. 391 | }, 392 | { 393 | Name = "CLANG_MODULES_VALIDATE_SYSTEM_HEADERS"; 394 | Type = Boolean; 395 | DefaultValue = NO; 396 | CommandLineArgs = { 397 | YES = ("-fmodules-validate-system-headers",); 398 | NO = (); 399 | }; 400 | Condition = "$(CLANG_ENABLE_MODULES) == YES"; 401 | // Hidden. 402 | }, 403 | { 404 | Name = "CLANG_MODULES_BUILD_SESSION_FILE"; 405 | Type = String; 406 | DefaultValue = ""; 407 | CommandLineArgs = { 408 | "" = (); 409 | "<>" = ( 410 | "-fbuild-session-file=$(value)", 411 | "-fmodules-validate-once-per-build-session", 412 | ); 413 | }; 414 | Condition = "$(CLANG_ENABLE_MODULES) == YES"; 415 | SupportedVersionRanges = ( "602.0.0" ); 416 | }, 417 | { 418 | Name = "CLANG_ALLOW_NON_MODULAR_INCLUDES_IN_FRAMEWORK_MODULES"; 419 | Type = Boolean; 420 | DefaultValue = NO; 421 | CommandLineArgs = { 422 | YES = (); 423 | NO = ("-Wnon-modular-include-in-framework-module", 424 | "-Werror=non-modular-include-in-framework-module"); 425 | }; 426 | Condition = "$(CLANG_ENABLE_MODULES) == YES"; 427 | Category = LanguageModules; 428 | DisplayName = "Allow Non-modular Includes In Framework Modules"; 429 | Description = "Enabling 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."; 430 | }, 431 | { 432 | Name = "CLANG_ENABLE_MODULE_IMPLEMENTATION_OF"; 433 | Type = Boolean; 434 | DefaultValue = YES; 435 | CommandLineArgs = { 436 | NO = (); 437 | YES = ("-fmodule-name=$(PRODUCT_MODULE_NAME)"); 438 | }; 439 | Condition = "$(CLANG_ENABLE_MODULES) == YES && $(DEFINES_MODULE) == YES"; 440 | }, 441 | { 442 | Name = "CLANG_ENABLE_APP_EXTENSION"; 443 | Type = Boolean; 444 | DefaultValue = "$(APPLICATION_EXTENSION_API_ONLY)"; 445 | CommandLineArgs = { 446 | YES = ( "-fapplication-extension" ); 447 | NO = (); 448 | }; 449 | AdditionalLinkerArgs = { 450 | YES = ( "-fapplication-extension" ); 451 | NO = (); 452 | }; 453 | }, 454 | { 455 | Name = "GCC_CHAR_IS_UNSIGNED_CHAR"; 456 | Type = Boolean; 457 | DefaultValue = NO; 458 | CommandLineArgs = { 459 | YES = ( 460 | "-funsigned-char", 461 | ); 462 | NO = (); 463 | }; 464 | Category = Language; 465 | }, 466 | { 467 | Name = "GCC_ENABLE_ASM_KEYWORD"; 468 | Type = Boolean; 469 | DefaultValue = YES; 470 | CommandLineArgs = { 471 | YES = (); 472 | NO = ( 473 | "-fno-asm", 474 | ); 475 | }; 476 | Category = Language; 477 | }, 478 | { 479 | Name = "GCC_ENABLE_BUILTIN_FUNCTIONS"; 480 | Type = Boolean; 481 | DefaultValue = YES; 482 | CommandLineArgs = { 483 | YES = (); 484 | NO = ( 485 | "-fno-builtin", 486 | ); 487 | }; 488 | Category = Language; 489 | }, 490 | { 491 | Name = "GCC_ENABLE_TRIGRAPHS"; 492 | Type = Boolean; 493 | DefaultValue = NO; 494 | CommandLineArgs = { 495 | YES = ( 496 | "-trigraphs", 497 | ); 498 | NO = ( 499 | "-Wno-trigraphs", 500 | ); 501 | }; 502 | Category = Language; 503 | }, 504 | { 505 | Name = "GCC_ENABLE_CPP_EXCEPTIONS"; 506 | Type = Boolean; 507 | DefaultValue = YES; 508 | CommandLineArgs = { 509 | YES = (); 510 | NO = ( 511 | "-fno-exceptions", 512 | ); 513 | }; 514 | FileTypes = ( 515 | "sourcecode.cpp.cpp", 516 | "sourcecode.cpp.objcpp", 517 | ); 518 | Category = LanguageCXX; 519 | }, 520 | { 521 | Name = "GCC_ENABLE_CPP_RTTI"; 522 | Type = Boolean; 523 | DefaultValue = YES; 524 | CommandLineArgs = { 525 | YES = (); 526 | NO = ( 527 | "-fno-rtti", 528 | "-fno-sanitize=vptr", 529 | ); 530 | }; 531 | FileTypes = ( 532 | "sourcecode.cpp.cpp", 533 | "sourcecode.cpp.objcpp", 534 | ); 535 | Category = LanguageCXX; 536 | }, 537 | { 538 | Name = "GCC_ENABLE_PASCAL_STRINGS"; 539 | Type = Boolean; 540 | DefaultValue = YES; 541 | CommandLineArgs = { 542 | YES = ( 543 | "-fpascal-strings", 544 | ); 545 | NO = (); 546 | }; 547 | Category = Language; 548 | }, 549 | { 550 | Name = "GCC_SHORT_ENUMS"; 551 | Type = Boolean; 552 | DefaultValue = NO; 553 | CommandLineArgs = { 554 | YES = ( 555 | "-fshort-enums", 556 | ); 557 | NO = (); 558 | }; 559 | Category = Language; 560 | }, 561 | { 562 | Name = "GCC_LINK_WITH_DYNAMIC_LIBRARIES"; 563 | Type = Boolean; 564 | DefaultValue = YES; 565 | CommandLineArgs = { 566 | YES = (); 567 | NO = ( 568 | "-static", 569 | ); 570 | }; 571 | Category = Language; 572 | }, 573 | { 574 | Name = "GCC_ENABLE_FLOATING_POINT_LIBRARY_CALLS"; 575 | Type = Boolean; 576 | DefaultValue = NO; 577 | CommandLineArgs = { 578 | YES = ( 579 | "-msoft-float", 580 | ); 581 | NO = (); 582 | }; 583 | Category = Language; 584 | }, 585 | { 586 | Name = "GCC_PREFIX_HEADER"; 587 | Type = String; 588 | DefaultValue = ""; 589 | Category = Language; 590 | ConditionFlavors = (); 591 | }, 592 | { 593 | Name = "GCC_PRECOMPILE_PREFIX_HEADER"; 594 | Type = Boolean; 595 | DefaultValue = NO; 596 | Category = Language; 597 | ConditionFlavors = (); 598 | }, 599 | { 600 | Name = "GCC_INCREASE_PRECOMPILED_HEADER_SHARING"; 601 | Type = Boolean; 602 | DefaultValue = NO; 603 | Category = Language; 604 | ConditionFlavors = (); 605 | }, 606 | { 607 | Name = "OTHER_CFLAGS"; 608 | Type = StringList; 609 | FileTypes = ( 610 | "sourcecode.c.c", 611 | "sourcecode.c.objc", 612 | ); 613 | Category = CustomFlags; 614 | }, 615 | { 616 | Name = "OTHER_CPLUSPLUSFLAGS"; 617 | Type = StringList; 618 | FileTypes = ( 619 | "sourcecode.cpp.cpp", 620 | "sourcecode.cpp.objcpp", 621 | ); 622 | Category = CustomFlags; 623 | }, 624 | { 625 | Name = "GCC_GENERATE_DEBUGGING_SYMBOLS"; 626 | Type = Boolean; 627 | DefaultValue = YES; 628 | Category = CodeGeneration; 629 | }, 630 | { 631 | Name = "GCC_OPTIMIZATION_LEVEL"; 632 | Type = Enumeration; 633 | // NOTE: Updating these values requires updating LLVM_OPTIMIZATION_LEVEL_VAL_X. 634 | Values = ( 635 | 0, 636 | 1, 637 | 2, 638 | 3, 639 | s, 640 | fast, 641 | ); 642 | DefaultValue = s; 643 | CommandLineArgs = ( 644 | "-O$(value)", 645 | ); 646 | Category = CodeGeneration; 647 | }, 648 | { 649 | Name = "LLVM_OPTIMIZATION_LEVEL_VAL_0"; 650 | Type = Boolean; 651 | DefaultValue = NO; 652 | // Hidden 653 | }, 654 | { 655 | Name = "LLVM_OPTIMIZATION_LEVEL_VAL_1"; 656 | Type = Boolean; 657 | DefaultValue = NO; 658 | // Hidden 659 | }, 660 | { 661 | Name = "LLVM_OPTIMIZATION_LEVEL_VAL_2"; 662 | Type = Boolean; 663 | DefaultValue = NO; 664 | // Hidden 665 | }, 666 | { 667 | Name = "LLVM_OPTIMIZATION_LEVEL_VAL_3"; 668 | Type = Boolean; 669 | DefaultValue = NO; 670 | // Hidden 671 | }, 672 | { 673 | Name = "LLVM_OPTIMIZATION_LEVEL_VAL_s"; 674 | Type = Boolean; 675 | DefaultValue = NO; 676 | // Hidden 677 | }, 678 | { 679 | Name = "LLVM_OPTIMIZATION_LEVEL_VAL_fast"; 680 | Type = Boolean; 681 | DefaultValue = YES; 682 | // Hidden 683 | }, 684 | { 685 | Name = "LLVM_IMPLICIT_AGGRESSIVE_OPTIMIZATIONS"; 686 | Type = Boolean; 687 | DefaultValue = "$(LLVM_OPTIMIZATION_LEVEL_VAL_$(GCC_OPTIMIZATION_LEVEL))"; 688 | // Hidden 689 | }, 690 | { 691 | Name = "LLVM_LTO"; 692 | Type = Enumeration; 693 | Values = ( 694 | YES, 695 | YES_THIN, 696 | NO, 697 | ); 698 | DefaultValue = NO; 699 | CommandLineArgs = { 700 | YES = ( "-flto" ); 701 | YES_THIN = ( "-flto=thin" ); 702 | NO = (); 703 | }; 704 | AdditionalLinkerArgs = { 705 | YES_THIN = ( "-flto=thin", "-Xlinker", "-cache_path_lto", "-Xlinker", "$(OBJROOT)/LTOCache" ); 706 | NO = (); 707 | }; 708 | Category = CodeGeneration; 709 | }, 710 | { 711 | Name = "GCC_NO_COMMON_BLOCKS"; 712 | Type = Boolean; 713 | DefaultValue = NO; 714 | CommandLineArgs = { 715 | YES = ( 716 | "-fno-common", 717 | ); 718 | NO = (); 719 | }; 720 | Category = CodeGeneration; 721 | }, 722 | { 723 | Name = "GCC_REUSE_STRINGS"; 724 | Type = Boolean; 725 | DefaultValue = YES; 726 | CommandLineArgs = { 727 | YES = (); 728 | NO = ( 729 | "-fwritable-strings", 730 | ); 731 | }; 732 | Category = CodeGeneration; 733 | }, 734 | { 735 | Name = "GCC_DYNAMIC_NO_PIC"; 736 | Type = Boolean; 737 | DefaultValue = NO; 738 | CommandLineArgs = { 739 | YES = ( 740 | "-mdynamic-no-pic", 741 | ); 742 | NO = (); 743 | }; 744 | Category = CodeGeneration; 745 | }, 746 | { 747 | Name = "GCC_ENABLE_KERNEL_DEVELOPMENT"; 748 | Type = Boolean; 749 | DefaultValue = NO; 750 | CommandLineArgs = { 751 | YES = ( 752 | "-mkernel", 753 | ); 754 | NO = (); 755 | }; 756 | Category = CodeGeneration; 757 | }, 758 | { 759 | Name = "GCC_TREAT_WARNINGS_AS_ERRORS"; 760 | Type = Boolean; 761 | DefaultValue = NO; 762 | CommandLineArgs = { 763 | YES = ( 764 | "-Werror", 765 | ); 766 | NO = (); 767 | }; 768 | Category = WarningsPolicy; 769 | }, 770 | { 771 | Name = "GCC_TREAT_IMPLICIT_FUNCTION_DECLARATIONS_AS_ERRORS"; 772 | Type = Boolean; 773 | DefaultValue = NO; 774 | CommandLineArgs = { 775 | YES = ( 776 | "-Werror=implicit-function-declaration", 777 | ); 778 | NO = (); 779 | }; 780 | FileTypes = ( 781 | "sourcecode.c.c", 782 | "sourcecode.c.objc", 783 | ); 784 | Category = Warnings; 785 | AppearsAfter = "GCC_TREAT_WARNINGS_AS_ERRORS"; 786 | }, 787 | { 788 | Name = "GCC_TREAT_INCOMPATIBLE_POINTER_TYPE_WARNINGS_AS_ERRORS"; 789 | Type = Boolean; 790 | DefaultValue = NO; 791 | CommandLineArgs = { 792 | YES = ( 793 | "-Werror=incompatible-pointer-types", 794 | ); 795 | NO = (); 796 | }; 797 | Category = Warnings; 798 | AppearsAfter = "GCC_TREAT_WARNINGS_AS_ERRORS"; 799 | }, 800 | { 801 | Name = "GCC_WARN_ABOUT_MISSING_FIELD_INITIALIZERS"; 802 | Type = Boolean; 803 | DefaultValue = NO; 804 | CommandLineArgs = { 805 | YES = ( 806 | "-Wmissing-field-initializers", 807 | ); 808 | NO = ( 809 | "-Wno-missing-field-initializers", 810 | ); 811 | }; 812 | Category = Warnings; 813 | }, 814 | { 815 | Name = "GCC_WARN_ABOUT_MISSING_PROTOTYPES"; 816 | Type = Boolean; 817 | DefaultValue = NO; 818 | CommandLineArgs = { 819 | YES = ( 820 | "-Wmissing-prototypes", 821 | ); 822 | NO = ( 823 | "-Wno-missing-prototypes", 824 | ); 825 | }; 826 | Category = Warnings; 827 | }, 828 | { 829 | Name = "GCC_WARN_ABOUT_RETURN_TYPE"; 830 | Type = Enumeration; 831 | Values = ( 832 | YES, NO, YES_ERROR 833 | ); 834 | DefaultValue = NO; 835 | CommandLineArgs = { 836 | YES = (); 837 | YES_ERROR = ( "-Werror=return-type" ); 838 | NO = ( "-Wno-return-type" ); 839 | }; 840 | Category = Warnings; 841 | }, 842 | { 843 | Name = "CLANG_WARN_DOCUMENTATION_COMMENTS"; 844 | Type = Boolean; 845 | DefaultValue = NO; 846 | CommandLineArgs = { 847 | YES = ( "-Wdocumentation" ); 848 | NO = (); 849 | }; 850 | Category = Warnings; 851 | }, 852 | { 853 | Name = "CLANG_WARN_UNREACHABLE_CODE"; 854 | Type = Enumeration; 855 | Values = ( 856 | YES, 857 | YES_AGGRESSIVE, 858 | NO, 859 | ); 860 | DefaultValue = NO; 861 | CommandLineArgs = { 862 | YES = ( "-Wunreachable-code" ); 863 | YES_AGGRESSIVE = ( "-Wunreachable-code-aggressive" ); 864 | NO = (); 865 | }; 866 | Category = Warnings; 867 | }, 868 | // Compiler warning for when nullable is converted to nonnull. 869 | // Not visible in build settings. 870 | { 871 | Name = "CLANG_WARN_NULLABLE_TO_NONNULL_CONVERSION"; 872 | Type = Boolean; 873 | DefaultValue = NO; 874 | CommandLineArgs = { 875 | YES = ( "-Wnullable-to-nonnull-conversion" ); 876 | NO = (); 877 | }; 878 | }, 879 | { 880 | Name = "CLANG_WARN_OBJC_IMPLICIT_ATOMIC_PROPERTIES"; 881 | Type = Boolean; 882 | DefaultValue = NO; 883 | CommandLineArgs = { 884 | YES = ( 885 | "-Wimplicit-atomic-properties" 886 | ); 887 | NO = ( 888 | "-Wno-implicit-atomic-properties" 889 | ); 890 | }; 891 | FileTypes = ( 892 | "sourcecode.c.objc", 893 | "sourcecode.cpp.objcpp", 894 | ); 895 | Category = WarningsObjC; 896 | }, 897 | { 898 | Name = "CLANG_WARN_DIRECT_OBJC_ISA_USAGE"; 899 | Type = Enumeration; 900 | Values = ( 901 | YES, NO, YES_ERROR 902 | ); 903 | DefaultValue = YES; 904 | CommandLineArgs = { 905 | YES = (); 906 | YES_ERROR = ( "-Werror=deprecated-objc-isa-usage" ); 907 | NO = ( "-Wno-deprecated-objc-isa-usage"); 908 | }; 909 | Category = WarningsObjC; 910 | }, 911 | { 912 | Name = "CLANG_WARN_OBJC_MISSING_PROPERTY_SYNTHESIS"; 913 | Type = Boolean; 914 | DefaultValue = NO; 915 | CommandLineArgs = { 916 | YES = ( "-Wobjc-missing-property-synthesis" ); 917 | NO = (); 918 | }; 919 | FileTypes = ( 920 | "sourcecode.c.objc", 921 | "sourcecode.cpp.objcpp", 922 | ); 923 | Category = WarningsObjC; 924 | }, 925 | { 926 | Name = "CLANG_WARN_OBJC_ROOT_CLASS"; 927 | Type = Enumeration; 928 | Values = ( 929 | YES, NO, YES_ERROR 930 | ); 931 | DefaultValue = YES; 932 | CommandLineArgs = { 933 | YES = ( /* On by default */ ); 934 | NO = ( "-Wno-objc-root-class" ); 935 | YES_ERROR = ( "-Werror=objc-root-class" ); 936 | }; 937 | Category = WarningsObjC; 938 | }, 939 | { 940 | Name = "CLANG_WARN_OBJC_REPEATED_USE_OF_WEAK"; 941 | Type = Enumeration; 942 | Values = ( YES, NO, YES_AGGRESSIVE ); 943 | DefaultValue = NO; 944 | CommandLineArgs = { 945 | NO = ( "-Wno-arc-repeated-use-of-weak" ); 946 | YES = ( 947 | "-Warc-repeated-use-of-weak", 948 | "-Wno-arc-maybe-repeated-use-of-weak" 949 | ); 950 | YES_AGGRESSIVE = ( 951 | "-Warc-repeated-use-of-weak", 952 | "-Warc-maybe-repeated-use-of-weak" 953 | ); 954 | }; 955 | FileTypes = ( 956 | "sourcecode.c.objc", 957 | "sourcecode.cpp.objcpp", 958 | ); 959 | Category = WarningsObjCARC; 960 | }, 961 | { 962 | Name = "CLANG_WARN_OBJC_EXPLICIT_OWNERSHIP_TYPE"; 963 | Type = Boolean; 964 | DefaultValue = NO; 965 | CommandLineArgs = { 966 | YES = ( "-Wexplicit-ownership-type" ); 967 | NO = (); 968 | }; 969 | FileTypes = ( 970 | "sourcecode.c.objc", 971 | "sourcecode.cpp.objcpp", 972 | ); 973 | Category = WarningsObjCARC; 974 | }, 975 | { 976 | Name = "CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF"; 977 | Type = Boolean; 978 | DefaultValue = NO; 979 | CommandLineArgs = { 980 | YES = ( "-Wimplicit-retain-self" ); 981 | NO = (); 982 | }; 983 | FileTypes = ( 984 | "sourcecode.c.objc", 985 | "sourcecode.cpp.objcpp", 986 | ); 987 | Category = WarningsObjCARC; 988 | }, 989 | { 990 | Name = "GCC_WARN_NON_VIRTUAL_DESTRUCTOR"; 991 | Type = Boolean; 992 | DefaultValue = NO; 993 | CommandLineArgs = { 994 | YES = ( 995 | "-Wnon-virtual-dtor", 996 | ); 997 | NO = ( 998 | "-Wno-non-virtual-dtor", 999 | ); 1000 | }; 1001 | FileTypes = ( 1002 | "sourcecode.cpp.cpp", 1003 | "sourcecode.cpp.objcpp", 1004 | ); 1005 | Category = WarningsCXX; 1006 | }, 1007 | { 1008 | Name = "GCC_WARN_HIDDEN_VIRTUAL_FUNCTIONS"; 1009 | Type = Boolean; 1010 | DefaultValue = NO; 1011 | CommandLineArgs = { 1012 | YES = ( 1013 | "-Woverloaded-virtual", 1014 | ); 1015 | NO = ( 1016 | "-Wno-overloaded-virtual", 1017 | ); 1018 | }; 1019 | FileTypes = ( 1020 | "sourcecode.cpp.cpp", 1021 | "sourcecode.cpp.objcpp", 1022 | ); 1023 | Category = WarningsCXX; 1024 | }, 1025 | { 1026 | // The "__" is intentional. 1027 | Name = "CLANG_WARN__EXIT_TIME_DESTRUCTORS"; 1028 | Type = Boolean; 1029 | DefaultValue = NO; 1030 | CommandLineArgs = { 1031 | YES = ("-Wexit-time-destructors"); 1032 | NO = ("-Wno-exit-time-destructors"); 1033 | }; 1034 | FileTypes = ( 1035 | "sourcecode.cpp.cpp", 1036 | "sourcecode.cpp.objcpp", 1037 | ); 1038 | Category = WarningsCXX; 1039 | }, 1040 | { 1041 | // The "__" is intentional. 1042 | Name = "CLANG_WARN__ARC_BRIDGE_CAST_NONARC"; 1043 | Type = Boolean; 1044 | DefaultValue = YES; 1045 | CommandLineArgs = { 1046 | YES = (); 1047 | NO = ("-Wno-arc-bridge-casts-disallowed-in-nonarc"); 1048 | }; 1049 | FileTypes = ( 1050 | "sourcecode.c.objc", 1051 | "sourcecode.cpp.objcpp", 1052 | ); 1053 | Category = WarningsObjCARC; 1054 | }, 1055 | { 1056 | // The "__" is intentional. 1057 | Name = "CLANG_WARN__DUPLICATE_METHOD_MATCH"; 1058 | Type = Boolean; 1059 | DefaultValue = NO; 1060 | CommandLineArgs = { 1061 | YES = ("-Wduplicate-method-match"); 1062 | NO = (); 1063 | }; 1064 | FileTypes = ( 1065 | "sourcecode.c.objc", 1066 | "sourcecode.cpp.objcpp", 1067 | ); 1068 | Category = WarningsObjC; 1069 | }, 1070 | { 1071 | Name = "GCC_WARN_TYPECHECK_CALLS_TO_PRINTF"; 1072 | Type = Boolean; 1073 | DefaultValue = YES; 1074 | CommandLineArgs = { 1075 | YES = ( /* Enabled by default */ ); 1076 | NO = ( "-Wno-format" ); 1077 | }; 1078 | Category = Warnings; 1079 | }, 1080 | { 1081 | Name = "GCC_WARN_INITIALIZER_NOT_FULLY_BRACKETED"; 1082 | Type = Boolean; 1083 | DefaultValue = NO; 1084 | CommandLineArgs = { 1085 | YES = ( 1086 | "-Wmissing-braces", 1087 | ); 1088 | NO = ( 1089 | "-Wno-missing-braces", 1090 | ); 1091 | }; 1092 | Category = Warnings; 1093 | }, 1094 | { 1095 | Name = "GCC_WARN_MISSING_PARENTHESES"; 1096 | Type = Boolean; 1097 | DefaultValue = YES; 1098 | CommandLineArgs = { 1099 | YES = ( 1100 | "-Wparentheses", 1101 | ); 1102 | NO = ( 1103 | "-Wno-parentheses", 1104 | ); 1105 | }; 1106 | Category = Warnings; 1107 | }, 1108 | { 1109 | Name = "GCC_WARN_CHECK_SWITCH_STATEMENTS"; 1110 | Type = Boolean; 1111 | DefaultValue = YES; 1112 | CommandLineArgs = { 1113 | YES = ( 1114 | "-Wswitch", 1115 | ); 1116 | NO = ( 1117 | "-Wno-switch", 1118 | ); 1119 | }; 1120 | Category = Warnings; 1121 | }, 1122 | { 1123 | Name = "GCC_WARN_UNUSED_FUNCTION"; 1124 | Type = Boolean; 1125 | DefaultValue = NO; 1126 | CommandLineArgs = { 1127 | YES = ( 1128 | "-Wunused-function", 1129 | ); 1130 | NO = ( 1131 | "-Wno-unused-function", 1132 | ); 1133 | }; 1134 | Category = Warnings; 1135 | }, 1136 | { 1137 | Name = "GCC_WARN_UNUSED_LABEL"; 1138 | Type = Boolean; 1139 | DefaultValue = NO; 1140 | CommandLineArgs = { 1141 | YES = ( 1142 | "-Wunused-label", 1143 | ); 1144 | NO = ( 1145 | "-Wno-unused-label", 1146 | ); 1147 | }; 1148 | Category = Warnings; 1149 | }, 1150 | { 1151 | Name = "CLANG_WARN_EMPTY_BODY"; 1152 | Type = Boolean; 1153 | DefaultValue = NO; 1154 | CommandLineArgs = { 1155 | YES = ( "-Wempty-body" ); 1156 | NO = ( "-Wno-empty-body" ); 1157 | }; 1158 | Category = Warnings; 1159 | }, 1160 | { 1161 | Name = "GCC_WARN_UNINITIALIZED_AUTOS"; 1162 | Type = Enumeration; 1163 | Values = ( 1164 | YES, 1165 | YES_AGGRESSIVE, 1166 | NO, 1167 | ); 1168 | DefaultValue = NO; 1169 | CommandLineArgs = { 1170 | YES = ( 1171 | "-Wuninitialized", 1172 | ); 1173 | YES_AGGRESSIVE = ( 1174 | "-Wuninitialized", 1175 | "-Wconditional-uninitialized", 1176 | ); 1177 | NO = ( 1178 | "-Wno-uninitialized", 1179 | ); 1180 | }; 1181 | Category = Warnings; 1182 | }, 1183 | { 1184 | Name = "GCC_WARN_UNKNOWN_PRAGMAS"; 1185 | Type = Boolean; 1186 | DefaultValue = NO; 1187 | CommandLineArgs = { 1188 | YES = ( 1189 | "-Wunknown-pragmas", 1190 | ); 1191 | NO = ( 1192 | "-Wno-unknown-pragmas", 1193 | ); 1194 | }; 1195 | Category = Warnings; 1196 | }, 1197 | { 1198 | Name = "GCC_WARN_INHIBIT_ALL_WARNINGS"; 1199 | Type = Boolean; 1200 | DefaultValue = NO; 1201 | CommandLineArgs = { 1202 | YES = ( 1203 | "-w", 1204 | ); 1205 | NO = (); 1206 | }; 1207 | Category = WarningsPolicy; 1208 | }, 1209 | { 1210 | Name = "GCC_WARN_PEDANTIC"; 1211 | Type = Boolean; 1212 | DefaultValue = NO; 1213 | CommandLineArgs = { 1214 | YES = ( 1215 | "-pedantic", 1216 | ); 1217 | NO = (); 1218 | }; 1219 | Category = WarningsPolicy; 1220 | }, 1221 | { 1222 | Name = "GCC_WARN_SHADOW"; 1223 | Type = Boolean; 1224 | DefaultValue = NO; 1225 | CommandLineArgs = { 1226 | YES = ( 1227 | "-Wshadow", 1228 | ); 1229 | NO = ( 1230 | "-Wno-shadow", 1231 | ); 1232 | }; 1233 | Category = Warnings; 1234 | }, 1235 | { 1236 | Name = "GCC_WARN_FOUR_CHARACTER_CONSTANTS"; 1237 | Type = Boolean; 1238 | DefaultValue = NO; 1239 | CommandLineArgs = { 1240 | YES = ( 1241 | "-Wfour-char-constants", 1242 | ); 1243 | NO = ( 1244 | "-Wno-four-char-constants", 1245 | ); 1246 | }; 1247 | Category = Warnings; 1248 | }, 1249 | // This needs to appear in the xcspec before GCC_WARN_64_TO_32_BIT_CONVERSION. 1250 | // This is because -Wno-conversion would turn that warning off. By having 1251 | // GCC_WARN_64_TO_32_BIT_CONVERSION appear later, it generates a 1252 | // compiler flag later in the command line, and the compiler 1253 | // honors the last flag last. We need explicit -Wno-XXX for 1254 | // each warning to have it work with -Weverything. 1255 | { 1256 | Name = "CLANG_WARN_SUSPICIOUS_IMPLICIT_CONVERSION"; 1257 | Type = Enumeration; 1258 | DefaultValue = NO; 1259 | Values = ( YES, YES_ERROR, NO ); 1260 | CommandLineArgs = { 1261 | YES = ( 1262 | "-Wconversion", 1263 | ); 1264 | YES_ERROR = ( "-Werror=conversion" ); 1265 | NO = ( 1266 | // This cannot be removed until we have a solution 1267 | // for . 1268 | "-Wno-conversion", 1269 | ); 1270 | }; 1271 | CommonOption = NO; 1272 | Category = Warnings; 1273 | }, 1274 | // This must appear after CLANG_WARN_SUSPICIOUS_IMPLICIT_CONVERSION 1275 | { 1276 | Name = "CLANG_WARN_CONSTANT_CONVERSION"; 1277 | Type = Enumeration; 1278 | Values = ( YES, YES_ERROR, NO ); 1279 | DefaultValue = "$(CLANG_WARN_SUSPICIOUS_IMPLICIT_CONVERSION)"; 1280 | CommandLineArgs = { 1281 | YES = ( "-Wconstant-conversion" ); 1282 | YES_ERROR = ( "-Werror=constant-conversion" ); 1283 | NO = ( "-Wno-constant-conversion" ); 1284 | }; 1285 | Category = Warnings; 1286 | }, 1287 | // This must appear after CLANG_WARN_SUSPICIOUS_IMPLICIT_CONVERSION. 1288 | { 1289 | Name = "CLANG_WARN_INT_CONVERSION"; 1290 | Type = Enumeration; 1291 | Values = ( YES, YES_ERROR, NO ); 1292 | DefaultValue = "$(CLANG_WARN_SUSPICIOUS_IMPLICIT_CONVERSION)"; 1293 | CommandLineArgs = { 1294 | YES = ( 1295 | "-Wint-conversion" 1296 | ); 1297 | YES_ERROR = ( "-Werror=int-conversion" ); 1298 | NO = ( 1299 | "-Wno-int-conversion" 1300 | ); 1301 | }; 1302 | Category = Warnings; 1303 | }, 1304 | // This must appear after CLANG_WARN_SUSPICIOUS_IMPLICIT_CONVERSION. 1305 | { 1306 | Name = "CLANG_WARN_BOOL_CONVERSION"; 1307 | Type = Enumeration; 1308 | Values = ( YES, YES_ERROR, NO ); 1309 | DefaultValue = "$(CLANG_WARN_SUSPICIOUS_IMPLICIT_CONVERSION)"; 1310 | CommandLineArgs = { 1311 | YES = ( 1312 | "-Wbool-conversion" 1313 | ); 1314 | YES_ERROR = ( "-Werror=bool-conversion" ); 1315 | NO = ( 1316 | "-Wno-bool-conversion" 1317 | ); 1318 | }; 1319 | Category = Warnings; 1320 | }, 1321 | // This must appear after CLANG_WARN_SUSPICIOUS_IMPLICIT_CONVERSION. 1322 | { 1323 | Name = "CLANG_WARN_ENUM_CONVERSION"; 1324 | Type = Enumeration; 1325 | Values = ( YES, YES_ERROR, NO ); 1326 | DefaultValue = "$(CLANG_WARN_SUSPICIOUS_IMPLICIT_CONVERSION)"; 1327 | CommandLineArgs = { 1328 | YES = ( 1329 | "-Wenum-conversion" 1330 | ); 1331 | YES_ERROR = ( "-Werror=enum-conversion" ); 1332 | NO = ( 1333 | "-Wno-enum-conversion" 1334 | ); 1335 | }; 1336 | Category = Warnings; 1337 | }, 1338 | // This must appear after CLANG_WARN_SUSPICIOUS_IMPLICIT_CONVERSION. 1339 | { 1340 | Name = "CLANG_WARN_FLOAT_CONVERSION"; 1341 | Type = Enumeration; 1342 | Values = ( YES, YES_ERROR, NO ); 1343 | DefaultValue = "$(CLANG_WARN_SUSPICIOUS_IMPLICIT_CONVERSION)"; 1344 | CommandLineArgs = { 1345 | YES = ( "-Wfloat-conversion" ); 1346 | YES_ERROR = ( "-Werror=float-conversion" ); 1347 | NO = ( "-Wno-float-conversion" ); 1348 | }; 1349 | Category = Warnings; 1350 | }, 1351 | // This must appear after CLANG_WARN_SUSPICIOUS_IMPLICIT_CONVERSION. 1352 | { 1353 | Name = "CLANG_WARN_NON_LITERAL_NULL_CONVERSION"; 1354 | Type = Enumeration; 1355 | Values = ( YES, YES_ERROR, NO ); 1356 | DefaultValue = "$(CLANG_WARN_SUSPICIOUS_IMPLICIT_CONVERSION)"; 1357 | CommandLineArgs = { 1358 | YES = ( "-Wnon-literal-null-conversion" ); 1359 | YES_ERROR = ( "-Werror=non-literal-null-conversion" ); 1360 | NO = ( "-Wno-non-literal-null-conversion" ); 1361 | }; 1362 | Category = Warnings; 1363 | }, 1364 | // This must appear after CLANG_WARN_SUSPICIOUS_IMPLICIT_CONVERSION. 1365 | { 1366 | Name = "CLANG_WARN_OBJC_LITERAL_CONVERSION"; 1367 | Type = Enumeration; 1368 | Values = ( YES, YES_ERROR, NO ); 1369 | DefaultValue = "$(CLANG_WARN_SUSPICIOUS_IMPLICIT_CONVERSION)"; 1370 | CommandLineArgs = { 1371 | YES = ( 1372 | "-Wobjc-literal-conversion" 1373 | ); 1374 | YES_ERROR = ( 1375 | "-Werror=objc-literal-conversion" 1376 | ); 1377 | NO = ( 1378 | "-Wno-objc-literal-conversion" 1379 | ); 1380 | }; 1381 | Category = WarningsObjC; 1382 | }, 1383 | { 1384 | Name = "CLANG_WARN_ASSIGN_ENUM"; 1385 | Type = Boolean; 1386 | DefaultValue = "NO"; 1387 | CommandLineArgs = { 1388 | YES = ( "-Wassign-enum" ); 1389 | NO = (); 1390 | }; 1391 | Category = Warnings; 1392 | }, 1393 | { 1394 | Name = "GCC_WARN_SIGN_COMPARE"; 1395 | Type = Boolean; 1396 | DefaultValue = NO; 1397 | CommandLineArgs = { 1398 | YES = ( 1399 | "-Wsign-compare", 1400 | ); 1401 | NO = (); 1402 | }; 1403 | Category = Warnings; 1404 | }, 1405 | { 1406 | Name = "GCC_WARN_MULTIPLE_DEFINITION_TYPES_FOR_SELECTOR"; 1407 | Type = Boolean; 1408 | DefaultValue = NO; 1409 | CommandLineArgs = { 1410 | YES = ( 1411 | "-Wselector", 1412 | ); 1413 | NO = ( 1414 | "-Wno-selector", 1415 | ); 1416 | }; 1417 | FileTypes = ( 1418 | "sourcecode.c.objc", 1419 | "sourcecode.cpp.objcpp", 1420 | ); 1421 | }, 1422 | { 1423 | Name = "GCC_WARN_STRICT_SELECTOR_MATCH"; 1424 | Type = Boolean; 1425 | DefaultValue = NO; 1426 | CommandLineArgs = { 1427 | YES = ( 1428 | "-Wstrict-selector-match", 1429 | ); 1430 | NO = ( 1431 | "-Wno-strict-selector-match", 1432 | ); 1433 | }; 1434 | FileTypes = ( 1435 | "sourcecode.c.objc", 1436 | "sourcecode.cpp.objcpp", 1437 | ); 1438 | Category = WarningsObjC; 1439 | }, 1440 | { 1441 | Name = "GCC_WARN_UNDECLARED_SELECTOR"; 1442 | Type = Boolean; 1443 | DefaultValue = NO; 1444 | CommandLineArgs = { 1445 | YES = ( 1446 | "-Wundeclared-selector", 1447 | ); 1448 | NO = ( 1449 | "-Wno-undeclared-selector", 1450 | ); 1451 | }; 1452 | FileTypes = ( 1453 | "sourcecode.c.objc", 1454 | "sourcecode.cpp.objcpp", 1455 | ); 1456 | Category = WarningsObjC; 1457 | }, 1458 | { 1459 | Name = "CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS"; 1460 | Type = Boolean; 1461 | DefaultValue = NO; 1462 | CommandLineArgs = { 1463 | YES = ( 1464 | "-Wdeprecated-implementations", 1465 | ); 1466 | NO = ( 1467 | "-Wno-deprecated-implementations", 1468 | ); 1469 | }; 1470 | FileTypes = ( 1471 | "sourcecode.c.objc", 1472 | "sourcecode.cpp.objcpp", 1473 | ); 1474 | Category = WarningsObjC; 1475 | }, 1476 | { 1477 | Name = "CLANG_WARN_CXX0X_EXTENSIONS"; 1478 | Type = Boolean; 1479 | DefaultValue = NO; 1480 | CommandLineArgs = { 1481 | YES = ( "-Wc++11-extensions" ); 1482 | // We need to explicitly pass -Wno, since parts of this 1483 | // warning are on by default. 1484 | NO = ( "-Wno-c++11-extensions" ) ; 1485 | }; 1486 | FileTypes = ( 1487 | "sourcecode.cpp.cpp", 1488 | "sourcecode.cpp.objcpp", 1489 | ); 1490 | Category = WarningsCXX; 1491 | }, 1492 | { 1493 | Name = "WARNING_CFLAGS"; 1494 | Type = StringList; 1495 | DefaultValue = ""; 1496 | Category = CustomFlags; 1497 | }, 1498 | { 1499 | Name = "GCC_PREPROCESSOR_DEFINITIONS"; 1500 | Type = StringList; 1501 | DefaultValue = ""; 1502 | CommandLineArgs = ( 1503 | "-D$(value)", 1504 | ); 1505 | Category = Preprocessing; 1506 | }, 1507 | { 1508 | Name = "GCC_PRODUCT_TYPE_PREPROCESSOR_DEFINITIONS"; 1509 | Type = StringList; 1510 | DefaultValue = ""; 1511 | CommandLineArgs = ( 1512 | "-D$(value)", 1513 | ); 1514 | }, 1515 | { 1516 | Name = "GCC_PREPROCESSOR_DEFINITIONS_NOT_USED_IN_PRECOMPS"; 1517 | Type = StringList; 1518 | DefaultValue = ""; 1519 | Category = Preprocessing; 1520 | }, 1521 | { 1522 | Name = "ENABLE_NS_ASSERTIONS"; 1523 | Type = Boolean; 1524 | DefaultValue = YES; 1525 | CommandLineArgs = { 1526 | YES = (); 1527 | NO = ("-DNS_BLOCK_ASSERTIONS=1"); 1528 | }; 1529 | FileTypes = ( 1530 | "sourcecode.c.objc", 1531 | "sourcecode.cpp.objcpp", 1532 | ); 1533 | Category = Preprocessing; 1534 | }, 1535 | { 1536 | Name = "ENABLE_STRICT_OBJC_MSGSEND"; 1537 | Type = Boolean; 1538 | DefaultValue = NO; 1539 | CommandLineArgs = { 1540 | NO = (); 1541 | YES = ("-DOBJC_OLD_DISPATCH_PROTOTYPES=0"); 1542 | }; 1543 | FileTypes = ( 1544 | "sourcecode.c.objc", 1545 | "sourcecode.cpp.objcpp", 1546 | ); 1547 | Category = Preprocessing; 1548 | }, 1549 | { 1550 | Name = "USE_HEADERMAP"; 1551 | Type = Boolean; 1552 | DefaultValue = YES; 1553 | }, 1554 | { 1555 | Name = "HEADERMAP_FILE_FORMAT"; 1556 | Type = Enumeration; 1557 | Values = ( 1558 | traditional, 1559 | ); 1560 | DefaultValue = traditional; 1561 | }, 1562 | { 1563 | Name = "CPP_HEADERMAP_FILE"; 1564 | Type = Path; 1565 | DefaultValue = "$(TEMP_DIR)/$(PRODUCT_NAME).hmap"; 1566 | }, 1567 | { 1568 | Name = "CPP_HEADERMAP_FILE_FOR_GENERATED_FILES"; 1569 | Type = Path; 1570 | DefaultValue = "$(TEMP_DIR)/$(PRODUCT_NAME)-generated-files.hmap"; 1571 | }, 1572 | { 1573 | Name = "CPP_HEADERMAP_FILE_FOR_OWN_TARGET_HEADERS"; 1574 | Type = Path; 1575 | DefaultValue = "$(TEMP_DIR)/$(PRODUCT_NAME)-own-target-headers.hmap"; 1576 | }, 1577 | { 1578 | Name = "CPP_HEADERMAP_FILE_FOR_ALL_TARGET_HEADERS"; 1579 | Type = Path; 1580 | DefaultValue = "$(TEMP_DIR)/$(PRODUCT_NAME)-all-target-headers.hmap"; 1581 | }, 1582 | { 1583 | Name = "CPP_HEADERMAP_FILE_FOR_ALL_NON_FRAMEWORK_TARGET_HEADERS"; 1584 | Type = Path; 1585 | DefaultValue = "$(TEMP_DIR)/$(PRODUCT_NAME)-all-non-framework-target-headers.hmap"; 1586 | }, 1587 | { 1588 | Name = "CPP_HEADERMAP_FILE_FOR_PROJECT_FILES"; 1589 | Type = Path; 1590 | DefaultValue = "$(TEMP_DIR)/$(PRODUCT_NAME)-project-headers.hmap"; 1591 | }, 1592 | { 1593 | Name = "CPP_HEADERMAP_PRODUCT_HEADERS_VFS_FILE"; 1594 | Type = Path; 1595 | DefaultValue = "$(PROJECT_TEMP_DIR)/all-product-headers.yaml"; 1596 | }, 1597 | { 1598 | Name = "USE_HEADER_SYMLINKS"; 1599 | Type = Boolean; 1600 | DefaultValue = NO; 1601 | }, 1602 | { 1603 | Name = "CPP_HEADER_SYMLINKS_DIR"; 1604 | Type = Path; 1605 | DefaultValue = "$(TEMP_DIR)/$(PRODUCT_NAME).hdrs"; 1606 | }, 1607 | { 1608 | Name = SDKROOT; 1609 | Type = Path; 1610 | CommandLineFlag = "-isysroot"; 1611 | }, 1612 | { 1613 | Name = "GCC_USE_GCC3_PFE_SUPPORT"; 1614 | Type = Boolean; 1615 | DefaultValue = YES; 1616 | }, 1617 | { 1618 | Name = "GCC_PFE_FILE_C_DIALECTS"; 1619 | Type = StringList; 1620 | DefaultValue = "c objective-c c++ objective-c++"; 1621 | }, 1622 | { 1623 | Name = "ENABLE_APPLE_KEXT_CODE_GENERATION"; 1624 | Type = Boolean; 1625 | DefaultValue = NO; 1626 | CommandLineArgs = { 1627 | YES = ( 1628 | "-fapple-kext", 1629 | ); 1630 | NO = (); 1631 | }; 1632 | FileTypes = ( 1633 | "sourcecode.cpp.cpp", 1634 | "sourcecode.cpp.objcpp", 1635 | ); 1636 | }, 1637 | { 1638 | Name = "GCC_WARN_UNUSED_PARAMETER"; 1639 | Type = Boolean; 1640 | DefaultValue = NO; 1641 | CommandLineArgs = { 1642 | YES = ( 1643 | "-Wunused-parameter", 1644 | ); 1645 | NO = ( 1646 | "-Wno-unused-parameter", 1647 | ); 1648 | }; 1649 | AppearsAfter = "GCC_WARN_UNUSED_LABEL"; 1650 | Category = Warnings; 1651 | }, 1652 | { 1653 | Name = "GCC_WARN_UNUSED_VARIABLE"; 1654 | Type = Boolean; 1655 | DefaultValue = NO; 1656 | CommandLineArgs = { 1657 | YES = ( 1658 | "-Wunused-variable", 1659 | ); 1660 | NO = ( 1661 | "-Wno-unused-variable", 1662 | ); 1663 | }; 1664 | AppearsAfter = "GCC_WARN_UNUSED_PARAMETER"; 1665 | Category = Warnings; 1666 | }, 1667 | { 1668 | Name = "GCC_WARN_UNUSED_VALUE"; 1669 | Type = Boolean; 1670 | DefaultValue = YES; 1671 | CommandLineArgs = { 1672 | YES = ( 1673 | "-Wunused-value", 1674 | ); 1675 | NO = ( 1676 | "-Wno-unused-value", 1677 | ); 1678 | }; 1679 | AppearsAfter = "GCC_WARN_UNUSED_VARIABLE"; 1680 | Category = Warnings; 1681 | }, 1682 | { 1683 | Name = "GCC_ENABLE_EXCEPTIONS"; 1684 | Type = Boolean; 1685 | DefaultValue = NO; 1686 | CommandLineFlag = "-fexceptions"; 1687 | }, 1688 | { 1689 | Name = "GCC_ENABLE_OBJC_EXCEPTIONS"; 1690 | Type = Boolean; 1691 | DefaultValue = YES; 1692 | CommandLineArgs = { 1693 | YES = (); 1694 | NO = ( 1695 | "-fno-objc-exceptions", 1696 | ); 1697 | }; 1698 | FileTypes = ( 1699 | "sourcecode.c.objc", 1700 | "sourcecode.cpp.objcpp", 1701 | ); 1702 | Category = LanguageObjC; 1703 | }, 1704 | { 1705 | Name = "GCC_CW_ASM_SYNTAX"; 1706 | Type = Boolean; 1707 | DefaultValue = YES; 1708 | CommandLineArgs = { 1709 | YES = ( 1710 | "-fasm-blocks", 1711 | ); 1712 | NO = (); 1713 | }; 1714 | Architectures = (i386, x86_64); 1715 | Category = Language; 1716 | }, 1717 | { 1718 | Name = "GCC_UNROLL_LOOPS"; 1719 | Type = Boolean; 1720 | DefaultValue = NO; 1721 | CommandLineArgs = { 1722 | YES = ( 1723 | "-funroll-loops", 1724 | ); 1725 | NO = (); 1726 | }; 1727 | Category = CodeGeneration; 1728 | }, 1729 | { 1730 | Name = "GCC_FAST_MATH"; 1731 | Type = Boolean; 1732 | DefaultValue = NO; 1733 | CommandLineArgs = { 1734 | YES = ( 1735 | "-ffast-math", 1736 | ); 1737 | NO = (); 1738 | }; 1739 | Condition = "$(LLVM_IMPLICIT_AGGRESSIVE_OPTIMIZATIONS) == NO"; 1740 | Category = CodeGeneration; 1741 | }, 1742 | { 1743 | Name = "GCC_STRICT_ALIASING"; 1744 | Type = Boolean; 1745 | DefaultValue = YES; 1746 | CommandLineArgs = { 1747 | YES = ( "-fstrict-aliasing" ); 1748 | NO = ( "-fno-strict-aliasing" ); 1749 | }; 1750 | Category = CodeGeneration; 1751 | }, 1752 | { 1753 | Name = "GCC_INSTRUMENT_PROGRAM_FLOW_ARCS"; 1754 | Type = Boolean; 1755 | DefaultValue = NO; 1756 | CommandLineArgs = { 1757 | YES = ( 1758 | "-fprofile-arcs", 1759 | ); 1760 | NO = (); 1761 | }; 1762 | AdditionalLinkerArgs = { 1763 | YES = ( 1764 | "-fprofile-arcs", 1765 | ); 1766 | NO = (); 1767 | }; 1768 | Category = CodeGeneration; 1769 | }, 1770 | { 1771 | Name = "GCC_GENERATE_TEST_COVERAGE_FILES"; 1772 | Type = Boolean; 1773 | DefaultValue = NO; 1774 | CommandLineArgs = { 1775 | YES = ( 1776 | "-ftest-coverage", 1777 | ); 1778 | NO = (); 1779 | }; 1780 | AdditionalLinkerArgs = { 1781 | YES = ( 1782 | "-ftest-coverage", 1783 | ); 1784 | NO = (); 1785 | }; 1786 | Category = CodeGeneration; 1787 | }, 1788 | { 1789 | Name = "GCC_WARN_ALLOW_INCOMPLETE_PROTOCOL"; 1790 | Type = Boolean; 1791 | DefaultValue = YES; 1792 | CommandLineArgs = { 1793 | YES = ( 1794 | "-Wprotocol", 1795 | ); 1796 | NO = ( 1797 | "-Wno-protocol", 1798 | ); 1799 | }; 1800 | FileTypes = ( 1801 | "sourcecode.c.objc", 1802 | "sourcecode.cpp.objcpp", 1803 | ); 1804 | Category = WarningsObjC; 1805 | }, 1806 | { 1807 | Name = "GCC_WARN_ABOUT_DEPRECATED_FUNCTIONS"; 1808 | Type = Boolean; 1809 | DefaultValue = YES; 1810 | CommandLineArgs = { 1811 | YES = ( 1812 | "-Wdeprecated-declarations", 1813 | ); 1814 | NO = ( 1815 | "-Wno-deprecated-declarations", 1816 | ); 1817 | }; 1818 | Category = Warnings; 1819 | }, 1820 | { 1821 | Name = "GCC_WARN_ABOUT_INVALID_OFFSETOF_MACRO"; 1822 | Type = Boolean; 1823 | DefaultValue = YES; 1824 | FileTypes = ( 1825 | "sourcecode.cpp.cpp", 1826 | "sourcecode.cpp.objcpp", 1827 | ); 1828 | CommandLineArgs = { 1829 | YES = ( 1830 | "-Winvalid-offsetof", 1831 | ); 1832 | NO = ( 1833 | "-Wno-invalid-offsetof", 1834 | ); 1835 | }; 1836 | Category = WarningsCXX; 1837 | }, 1838 | { 1839 | Name = "GCC_MACOSX_VERSION_MIN"; 1840 | Type = String; 1841 | DefaultValue = "$($(DEPLOYMENT_TARGET_SETTING_NAME))"; 1842 | CommandLineArgs = { 1843 | "" = (); 1844 | "<>" = ( 1845 | "-$(DEPLOYMENT_TARGET_CLANG_FLAG_NAME)=$(value)", 1846 | ); 1847 | }; 1848 | }, 1849 | { 1850 | Name = "GCC_DEBUG_INFORMATION_FORMAT"; 1851 | Type = Enumeration; 1852 | Values = ( 1853 | dwarf, 1854 | "dwarf-with-dsym", 1855 | ); 1856 | CommandLineArgs = { 1857 | dwarf = ( 1858 | "-g", 1859 | ); 1860 | "dwarf-with-dsym" = ( 1861 | "-g", 1862 | ); 1863 | "<>" = (); 1864 | }; 1865 | DefaultValue = "$(DEBUG_INFORMATION_FORMAT)"; 1866 | Condition = "$(GCC_GENERATE_DEBUGGING_SYMBOLS)"; 1867 | CommonOption = NO; 1868 | }, 1869 | { 1870 | Name = "CLANG_DEBUG_INFORMATION_LEVEL"; 1871 | Type = Enumeration; 1872 | Values = ( 1873 | default, 1874 | "line-tables-only", 1875 | ); 1876 | DefaultValue = default; 1877 | CommandLineArgs = { 1878 | default = (); 1879 | "line-tables-only" = ( "-gline-tables-only" ); 1880 | }; 1881 | Condition = "$(GCC_GENERATE_DEBUGGING_SYMBOLS)"; 1882 | CommonOption = NO; 1883 | Category = CodeGeneration; 1884 | }, 1885 | { 1886 | // Old build setting. Kept around for old project compatibility. Forwards to CLANG_X86_VECTOR_INSTRUCTIONS. 1887 | Name = "GCC_ENABLE_SSE3_EXTENSIONS"; 1888 | Type = Boolean; 1889 | DefaultValue = NO; 1890 | CommandLineArgs = { YES = (); NO = (); }; 1891 | Architectures = ( i386, "x86_64", ); 1892 | DisplayName = "Enable SSE3 Extensions"; 1893 | Description = "Specifies whether the binary uses the builtin functions that provide access to the SSE3 extensions to the IA-32 architecture."; 1894 | }, 1895 | { 1896 | // Old build setting. Kept around for old project compatibility. Forwards to CLANG_X86_VECTOR_INSTRUCTIONS. 1897 | Name = "GCC_ENABLE_SUPPLEMENTAL_SSE3_INSTRUCTIONS"; 1898 | Type = Boolean; 1899 | DefaultValue = NO; 1900 | CommandLineArgs = { YES = (); NO = (); }; 1901 | Architectures = ( i386, "x86_64", ); 1902 | }, 1903 | { 1904 | // Old build setting. Kept around for old project compatibility. Forwards to CLANG_X86_VECTOR_INSTRUCTIONS. 1905 | Name = "GCC_ENABLE_SSE41_EXTENSIONS"; 1906 | Type = Boolean; 1907 | DefaultValue = NO; 1908 | CommandLineArgs = { YES = (); NO = (); }; 1909 | Architectures = ( i386, "x86_64", ); 1910 | DisplayName = "Enable SSE4.1 Extensions"; 1911 | Description = "Specifies whether the binary uses the builtin functions that provide access to the SSE4.1 extensions to the IA-32 architecture."; 1912 | }, 1913 | { 1914 | // Old build setting. Kept around for old project compatibility. Forwards to CLANG_X86_VECTOR_INSTRUCTIONS. 1915 | Name = "GCC_ENABLE_SSE42_EXTENSIONS"; 1916 | Type = Boolean; 1917 | DefaultValue = NO; 1918 | CommandLineArgs = { YES = (); NO = (); }; 1919 | Architectures = ( i386, "x86_64", ); 1920 | DisplayName = "Enable SSE4.2 Extensions"; 1921 | Description = "Specifies whether the binary uses the builtin functions that provide access to the SSE4.2 extensions to the IA-32 architecture."; 1922 | }, 1923 | { 1924 | Name = DEFAULT_SSE_LEVEL_3_YES; 1925 | Type = String; 1926 | DefaultValue = "sse3"; 1927 | }, 1928 | { 1929 | Name = DEFAULT_SSE_LEVEL_3_NO; 1930 | Type = String; 1931 | DefaultValue = "default"; 1932 | }, 1933 | { 1934 | Name = DEFAULT_SSE_LEVEL_3_SUPPLEMENTAL_YES; 1935 | Type = String; 1936 | DefaultValue = "ssse3"; 1937 | }, 1938 | { 1939 | Name = DEFAULT_SSE_LEVEL_3_SUPPLEMENTAL_NO; 1940 | Type = String; 1941 | DefaultValue = "$(DEFAULT_SSE_LEVEL_3_$(GCC_ENABLE_SSE3_EXTENSIONS))"; 1942 | }, 1943 | { 1944 | // Forwards old build settings to CLANG_X86_VECTOR_INSTRUCTIONS. 1945 | Name = DEFAULT_SSE_LEVEL_4_1_YES; 1946 | Type = String; 1947 | DefaultValue = "sse4.1"; 1948 | }, 1949 | { 1950 | // Forwards old build settings to CLANG_X86_VECTOR_INSTRUCTIONS. 1951 | Name = DEFAULT_SSE_LEVEL_4_1_NO; 1952 | Type = String; 1953 | DefaultValue = "$(DEFAULT_SSE_LEVEL_3_SUPPLEMENTAL_$(GCC_ENABLE_SUPPLEMENTAL_SSE3_INSTRUCTIONS))"; 1954 | }, 1955 | { 1956 | // Forwards old build settings to CLANG_X86_VECTOR_INSTRUCTIONS. 1957 | Name = DEFAULT_SSE_LEVEL_4_2_YES; 1958 | Type = String; 1959 | DefaultValue = "sse4.2"; 1960 | }, 1961 | { 1962 | // Forwards old build settings to CLANG_X86_VECTOR_INSTRUCTIONS. 1963 | Name = DEFAULT_SSE_LEVEL_4_2_NO; 1964 | Type = String; 1965 | DefaultValue = "$(DEFAULT_SSE_LEVEL_4_1_$(GCC_ENABLE_SSE41_EXTENSIONS))"; 1966 | }, 1967 | { 1968 | Name = "CLANG_X86_VECTOR_INSTRUCTIONS"; 1969 | Type = Enumeration; 1970 | Values = (default, "sse3", "ssse3", "sse4.1", "sse4.2", "avx", "avx2" ); 1971 | AvoidMacroDefinition = YES; 1972 | DisplayName = "Enable Additional Vector Extensions"; 1973 | DefaultValue = "$(DEFAULT_SSE_LEVEL_4_2_$(GCC_ENABLE_SSE42_EXTENSIONS))"; 1974 | CommandLineArgs = { 1975 | default = (); 1976 | "<>" = ( "-m$(value)" ); 1977 | }; 1978 | Architectures = ( 1979 | i386, 1980 | "x86_64", 1981 | ); 1982 | Category = CodeGeneration; 1983 | Description = "Enables the use of extended vector instructions. Only used when targeting Intel architectures."; 1984 | }, 1985 | { 1986 | Name = "GCC_SYMBOLS_PRIVATE_EXTERN"; 1987 | Type = Boolean; 1988 | DefaultValue = NO; 1989 | CommandLineArgs = { 1990 | YES = ( 1991 | "-fvisibility=hidden", 1992 | ); 1993 | NO = (); 1994 | }; 1995 | AppearsAfter = "GCC_FEEDBACK_DIRECTED_OPTIMIZATION"; 1996 | Category = CodeGeneration; 1997 | }, 1998 | { 1999 | Name = "GCC_INLINES_ARE_PRIVATE_EXTERN"; 2000 | Type = Boolean; 2001 | DefaultValue = NO; 2002 | CommandLineArgs = { 2003 | YES = ( 2004 | "-fvisibility-inlines-hidden", 2005 | ); 2006 | NO = (); 2007 | }; 2008 | AppearsAfter = "GCC_SYMBOLS_PRIVATE_EXTERN"; 2009 | Category = CodeGeneration; 2010 | FileTypes = ( 2011 | "sourcecode.cpp.cpp", 2012 | "sourcecode.cpp.objcpp", 2013 | ); 2014 | DisplayName = "Inline Methods Hidden"; 2015 | Description = "When enabled, out-of-line copies of inline methods are declared `private extern`."; 2016 | }, 2017 | { 2018 | Name = "GCC_THREADSAFE_STATICS"; 2019 | Type = Boolean; 2020 | DefaultValue = YES; 2021 | CommandLineArgs = { 2022 | YES = (); 2023 | NO = ( 2024 | "-fno-threadsafe-statics", 2025 | ); 2026 | }; 2027 | AppearsAfter = "GCC_INLINES_ARE_PRIVATE_EXTERN"; 2028 | Category = CodeGeneration; 2029 | FileTypes = ( 2030 | "sourcecode.cpp.cpp", 2031 | "sourcecode.cpp.objcpp", 2032 | ); 2033 | DisplayName = "Statics are Thread-Safe"; 2034 | Description = "Emits 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."; 2035 | }, 2036 | { 2037 | Name = "GCC_WARN_ABOUT_POINTER_SIGNEDNESS"; 2038 | Type = Boolean; 2039 | DefaultValue = YES; 2040 | CommandLineArgs = { 2041 | YES = ( 2042 | "-Wpointer-sign", 2043 | ); 2044 | NO = ( 2045 | "-Wno-pointer-sign", 2046 | ); 2047 | }; 2048 | FileTypes = ( 2049 | "sourcecode.c.c", 2050 | "sourcecode.c.objc", 2051 | ); 2052 | AppearsAfter = "GCC_WARN_SIGN_COMPARE"; 2053 | Category = Warnings; 2054 | CommonOption = YES; 2055 | DisplayName = "Pointer Sign Comparison"; 2056 | Description = "Warn when pointers passed via arguments or assigned to a variable differ in sign."; 2057 | }, 2058 | { 2059 | Name = "GCC_WARN_ABOUT_MISSING_NEWLINE"; 2060 | Type = Boolean; 2061 | DefaultValue = NO; 2062 | CommandLineArgs = { 2063 | YES = ( 2064 | "-Wnewline-eof", 2065 | ); 2066 | NO = ( 2067 | "-Wno-newline-eof", 2068 | ); 2069 | }; 2070 | AppearsAfter = "GCC_WARN_ABOUT_POINTER_SIGNEDNESS"; 2071 | Category = Warnings; 2072 | CommonOption = NO; 2073 | DisplayName = "Missing Newline At End Of File"; 2074 | Description = "Warn when a source file does not end with a newline."; 2075 | }, 2076 | // NOTE: This must appear *after* CLANG_WARN_SUSPICIOUS_IMPLICIT_CONVERSION 2077 | // as -Wsign-conversion is a subgroup of -Wconversion, and users 2078 | // expect to be able to activate one build setting and disable the other 2079 | // and get the expected result. 2080 | { 2081 | Name = "CLANG_WARN_IMPLICIT_SIGN_CONVERSION"; 2082 | Type = Enumeration; 2083 | Values = ( YES, YES_ERROR, NO ); 2084 | DefaultValue = NO; 2085 | CommandLineArgs = { 2086 | YES = ( 2087 | "-Wsign-conversion", 2088 | ); 2089 | YES_ERROR = ( "-Werror=sign-conversion" ); 2090 | NO = ( 2091 | "-Wno-sign-conversion", 2092 | ); 2093 | }; 2094 | CommonOption = NO; 2095 | Category = Warnings; 2096 | }, 2097 | { 2098 | Name = "GCC_WARN_64_TO_32_BIT_CONVERSION"; 2099 | Type = Enumeration; 2100 | Values = ( YES, YES_ERROR, NO ); 2101 | DefaultValue = NO; 2102 | CommandLineArgs = { 2103 | YES = ( 2104 | "-Wshorten-64-to-32", 2105 | ); 2106 | YES_ERROR = ( "-Werror=shorten-64-to-32" ); 2107 | NO = ( 2108 | "-Wno-shorten-64-to-32" 2109 | ); 2110 | }; 2111 | AppearsAfter = "GCC_WARN_SIGN_COMPARE"; 2112 | Category = Warnings; 2113 | CommonOption = NO; 2114 | DisplayName = "Implicit Conversion to 32 Bit Type"; 2115 | }, 2116 | { 2117 | Name = "CLANG_WARN_INFINITE_RECURSION"; 2118 | Type = Boolean; 2119 | DefaultValue = NO; 2120 | CommandLineArgs = { 2121 | YES = ( 2122 | "-Winfinite-recursion", 2123 | ); 2124 | NO = ( 2125 | "-Wno-infinite-recursion", 2126 | ); 2127 | }; 2128 | Category = Warnings; 2129 | CommonOption = NO; 2130 | }, 2131 | { 2132 | Name = "CLANG_WARN_SUSPICIOUS_MOVE"; 2133 | Type = Boolean; 2134 | DefaultValue = NO; 2135 | CommandLineArgs = { 2136 | YES = ( 2137 | "-Wmove", 2138 | ); 2139 | NO = ( 2140 | "-Wno-move", 2141 | ); 2142 | }; 2143 | FileTypes = ( 2144 | "sourcecode.cpp.cpp", 2145 | "sourcecode.cpp.objcpp", 2146 | ); 2147 | Category = WarningsCXX; 2148 | CommonOption = NO; 2149 | }, 2150 | { 2151 | Name = "CLANG_WARN_COMMA"; 2152 | Type = Enumeration; 2153 | Values = ( YES, NO, YES_ERROR ); 2154 | DefaultValue = NO; 2155 | CommandLineArgs = { 2156 | YES_ERROR = ("-Werror=comma"); 2157 | YES = ("-Wcomma"); 2158 | NO = ("-Wno-comma"); 2159 | }; 2160 | Category = Warnings; 2161 | CommonOption = NO; 2162 | SupportedVersionRanges = ( "900.0.0" ); 2163 | }, 2164 | { 2165 | Name = "CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING"; 2166 | Type = Enumeration; 2167 | Values = ( YES, NO, YES_ERROR ); 2168 | DefaultValue = NO; 2169 | CommandLineArgs = { 2170 | YES_ERROR = ("-Werror=block-capture-autoreleasing"); 2171 | YES = ("-Wblock-capture-autoreleasing"); 2172 | NO = ("-Wno-block-capture-autoreleasing"); 2173 | }; 2174 | Category = Warnings; 2175 | CommonOption = NO; 2176 | SupportedVersionRanges = ( "900.0.0" ); 2177 | }, 2178 | { 2179 | Name = "CLANG_WARN_STRICT_PROTOTYPES"; 2180 | Type = Enumeration; 2181 | Values = ( YES, NO, YES_ERROR ); 2182 | DefaultValue = NO; 2183 | CommandLineArgs = { 2184 | YES_ERROR = ("-Werror=strict-prototypes"); 2185 | YES = ("-Wstrict-prototypes"); 2186 | NO = ("-Wno-strict-prototypes"); 2187 | }; 2188 | Category = Warnings; 2189 | CommonOption = NO; 2190 | SupportedVersionRanges = ( "900.0.0" ); 2191 | }, 2192 | { 2193 | Name = "CLANG_WARN_RANGE_LOOP_ANALYSIS"; 2194 | Type = Boolean; 2195 | DefaultValue = NO; 2196 | CommandLineArgs = { 2197 | YES = ( 2198 | "-Wrange-loop-analysis", 2199 | ); 2200 | NO = ( 2201 | "-Wno-range-loop-analysis", 2202 | ); 2203 | }; 2204 | FileTypes = ( 2205 | "sourcecode.cpp.cpp", 2206 | "sourcecode.cpp.objcpp", 2207 | ); 2208 | Category = WarningsCXX; 2209 | CommonOption = NO; 2210 | }, 2211 | { 2212 | Name = "CLANG_WARN_UNGUARDED_AVAILABILITY"; 2213 | Type = Enumeration; 2214 | Values = ( 2215 | YES, 2216 | YES_AGGRESSIVE, 2217 | NO, 2218 | ); 2219 | DefaultValue = YES; 2220 | CommandLineArgs = { 2221 | YES = (); 2222 | YES_AGGRESSIVE = ( 2223 | "-Wunguarded-availability", 2224 | ); 2225 | NO = ( 2226 | "-Wno-unguarded-availability", 2227 | ); 2228 | }; 2229 | Category = Warnings; 2230 | SupportedVersionRanges = ( "900.0.0" ); 2231 | }, 2232 | { 2233 | Name = "GCC_OBJC_ABI_VERSION"; 2234 | Type = Enumeration; 2235 | Values = ( 2236 | 1, 2237 | 2, 2238 | ); 2239 | DefaultValue = "$(OBJC_ABI_VERSION)"; 2240 | CommandLineArgs = { 2241 | "" = (); 2242 | "<>" = ( 2243 | "-fobjc-abi-version=$(value)" 2244 | ); 2245 | }; 2246 | FileTypes = ( 2247 | sourcecode.c.objc, 2248 | sourcecode.cpp.objcpp, 2249 | ); 2250 | // Category is hidden -- used by iPhoneSimulator to match runtime OS setup; 2251 | }, 2252 | { 2253 | Name = "GCC_OBJC_LEGACY_DISPATCH"; 2254 | Type = Boolean; 2255 | DefaultValue = NO; 2256 | CommandLineArgs = { 2257 | YES = ( 2258 | "-fobjc-legacy-dispatch", 2259 | ); 2260 | NO = (); 2261 | }; 2262 | FileTypes = ( 2263 | sourcecode.c.objc, 2264 | sourcecode.cpp.objcpp, 2265 | ); 2266 | // Category is hidden -- used by iPhoneSimulator to match runtime OS setup; 2267 | }, 2268 | 2269 | { 2270 | Name = "CLANG_INSTRUMENT_FOR_OPTIMIZATION_PROFILING"; 2271 | Type = Boolean; 2272 | DefaultValue = NO; 2273 | CommandLineArgs = { 2274 | YES = ( 2275 | "-fprofile-instr-generate", 2276 | ); 2277 | NO = (); 2278 | }; 2279 | AdditionalLinkerArgs = { 2280 | YES = ( 2281 | "-fprofile-instr-generate", 2282 | ); 2283 | NO = (); 2284 | }; 2285 | }, 2286 | { 2287 | Name = "CLANG_OPTIMIZATION_PROFILE_FILE"; 2288 | Type = Path; 2289 | DefaultValue = "$(SRCROOT)/OptimizationProfiles/$(PROJECT_NAME).profdata"; 2290 | Category = CodeGeneration; 2291 | }, 2292 | { 2293 | Name = "CLANG_USE_OPTIMIZATION_PROFILE"; 2294 | Type = Boolean; 2295 | DefaultValue = NO; 2296 | Category = CodeGeneration; 2297 | Condition = "! $(CLANG_INSTRUMENT_FOR_OPTIMIZATION_PROFILING) && ! $(CLANG_COVERAGE_MAPPING)"; 2298 | CommandLineArgs = { 2299 | YES = ( 2300 | "-fprofile-instr-use=$(CLANG_OPTIMIZATION_PROFILE_FILE)", 2301 | ); 2302 | NO = (); 2303 | }; 2304 | }, 2305 | 2306 | // Code coverage settings. 2307 | { 2308 | Name = "CLANG_ENABLE_CODE_COVERAGE"; 2309 | Type = Boolean; 2310 | DefaultValue = YES; 2311 | Category = CodeGeneration; 2312 | DisplayName = "Enable Code Coverage Support"; 2313 | Description = "Enables 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."; 2314 | }, 2315 | { 2316 | Name = "CLANG_COVERAGE_MAPPING"; 2317 | Type = Boolean; 2318 | DefaultValue = NO; 2319 | Condition = "$(CLANG_ENABLE_CODE_COVERAGE)"; 2320 | CommandLineArgs = { 2321 | YES = ( 2322 | "-fprofile-instr-generate", 2323 | "-fcoverage-mapping", 2324 | ); 2325 | NO = (); 2326 | }; 2327 | }, 2328 | // Extend the linker arguments when code coverage is enabled. We use a separate setting here to do this so that the extra linker flags will always be passed when code coverage is enabled, even if this specific target disables code coverage instrumentation via CLANG_ENABLE_COVERAGE_MAPPING. 2329 | { 2330 | Name = "CLANG_COVERAGE_MAPPING_LINKER_ARGS"; 2331 | Type = Boolean; 2332 | DefaultValue = "$(CLANG_COVERAGE_MAPPING)"; 2333 | AdditionalLinkerArgs = { 2334 | NO = (); 2335 | YES = ( 2336 | "-fprofile-instr-generate", 2337 | ); 2338 | }; 2339 | }, 2340 | 2341 | // Generate bitcode options - not visible in the build settings. 2342 | { 2343 | Name = "CLANG_BITCODE_GENERATION_MODE"; 2344 | Type = Enumeration; 2345 | Values = ( 2346 | none, 2347 | marker, 2348 | bitcode, 2349 | ); 2350 | DefaultValue = "$(BITCODE_GENERATION_MODE)"; 2351 | Architectures = ( arm64, armv7, armv7s, armv7k ); 2352 | Condition = "$(ENABLE_BITCODE) == YES"; 2353 | CommandLineArgs = { 2354 | marker = ( 2355 | "-fembed-bitcode-marker", 2356 | ); 2357 | bitcode = ( 2358 | "-fembed-bitcode", 2359 | ); 2360 | }; 2361 | }, 2362 | 2363 | // Address Sanitizer options. 2364 | { 2365 | Name = "CLANG_ADDRESS_SANITIZER"; 2366 | Type = Boolean; 2367 | DefaultValue = "$(ENABLE_ADDRESS_SANITIZER)"; 2368 | CommandLineArgs = { 2369 | YES = ( 2370 | "-fsanitize=address", 2371 | ); 2372 | NO = (); 2373 | }; 2374 | AdditionalLinkerArgs = { 2375 | YES = ( 2376 | "-fsanitize=address", 2377 | ); 2378 | NO = (); 2379 | }; 2380 | // Not visible in the build settings editor 2381 | }, 2382 | { 2383 | Name = "CLANG_ADDRESS_SANITIZER_CONTAINER_OVERFLOW"; 2384 | Type = Boolean; 2385 | Category = ASANPolicy; 2386 | DefaultValue = NO; 2387 | CommandLineArgs = { 2388 | YES = (); 2389 | NO = ( 2390 | "-D_LIBCPP_HAS_NO_ASAN", 2391 | ); 2392 | }; 2393 | Condition = "$(CLANG_ADDRESS_SANITIZER) == YES"; 2394 | }, 2395 | { 2396 | Name = "CLANG_ADDRESS_SANITIZER_USE_AFTER_SCOPE"; 2397 | Type = Boolean; 2398 | DefaultValue = NO; 2399 | CommandLineArgs = { 2400 | YES = ( 2401 | "-fsanitize-address-use-after-scope", 2402 | ); 2403 | NO = (); 2404 | }; 2405 | Condition = "$(CLANG_ADDRESS_SANITIZER) == YES"; 2406 | // Not visible in the build settings editor 2407 | }, 2408 | 2409 | // Undefined Behavior Sanitizer options. 2410 | { 2411 | Name = "CLANG_UNDEFINED_BEHAVIOR_SANITIZER"; 2412 | Type = Boolean; 2413 | DefaultValue = "$(ENABLE_UNDEFINED_BEHAVIOR_SANITIZER)"; 2414 | CommandLineArgs = { 2415 | YES = ( 2416 | "-fsanitize=undefined", 2417 | "-fno-sanitize=enum,return,float-divide-by-zero" 2418 | ); 2419 | NO = (); 2420 | }; 2421 | AdditionalLinkerArgs = { 2422 | YES = ( 2423 | "-fsanitize=undefined", 2424 | ); 2425 | NO = (); 2426 | }; 2427 | // Not visible in the build settings editor 2428 | }, 2429 | { 2430 | Name = "CLANG_UNDEFINED_BEHAVIOR_SANITIZER_INTEGER"; 2431 | Type = Boolean; 2432 | Category = UBSANPolicy; 2433 | DefaultValue = NO; 2434 | CommandLineArgs = { 2435 | YES = ( 2436 | "-fsanitize=integer" 2437 | ); 2438 | NO = (); 2439 | }; 2440 | Condition = "$(CLANG_UNDEFINED_BEHAVIOR_SANITIZER) == YES"; 2441 | }, 2442 | { 2443 | Name = "CLANG_UNDEFINED_BEHAVIOR_SANITIZER_NULLABILITY"; 2444 | Type = Boolean; 2445 | Category = UBSANPolicy; 2446 | DefaultValue = NO; 2447 | CommandLineArgs = { 2448 | YES = ( 2449 | "-fsanitize=nullability" 2450 | ); 2451 | NO = (); 2452 | }; 2453 | Condition = "$(CLANG_UNDEFINED_BEHAVIOR_SANITIZER) == YES"; 2454 | }, 2455 | 2456 | // Index-while-building options, not visible in build settings. 2457 | { 2458 | Name = "CLANG_INDEX_STORE_PATH"; 2459 | Type = Path; 2460 | DefaultValue = "$(INDEX_DATA_STORE_DIR)"; 2461 | }, 2462 | { 2463 | Name = "CLANG_INDEX_STORE_ENABLE"; 2464 | Type = Boolean; 2465 | DefaultValue = "$(INDEX_ENABLE_DATA_STORE)"; 2466 | Condition = "$(COMPILER_INDEX_STORE_ENABLE) == YES || ( $(COMPILER_INDEX_STORE_ENABLE) == Default && $(GCC_OPTIMIZATION_LEVEL) == 0 )"; 2467 | CommandLineArgs = { 2468 | YES = ( 2469 | "-index-store-path", 2470 | "$(CLANG_INDEX_STORE_PATH)", 2471 | ); 2472 | NO = (); 2473 | }; 2474 | }, 2475 | 2476 | // Thread Sanitizer options. 2477 | { 2478 | Name = "CLANG_THREAD_SANITIZER"; 2479 | Type = Boolean; 2480 | DefaultValue = "$(ENABLE_THREAD_SANITIZER)"; 2481 | Architectures = ( 2482 | x86_64, 2483 | arm64, 2484 | ); 2485 | CommandLineArgs = { 2486 | YES = ( 2487 | "-fsanitize=thread", 2488 | ); 2489 | NO = (); 2490 | }; 2491 | // Not visible in the build settings editor 2492 | }, 2493 | 2494 | // These 4 settings are used by Xcode's migration tool. 2495 | // They should not be removed. 2496 | // They do not show up in the user visible build settings. 2497 | { 2498 | Name = "CLANG_ARC_MIGRATE_PRECHECK"; 2499 | Type = Enumeration; 2500 | Values = ( 2501 | donothing, 2502 | precheck, 2503 | ); 2504 | DefaultValue = donothing; 2505 | CommandLineArgs = { 2506 | donothing = (); 2507 | precheck = ( 2508 | "-ccc-arcmt-check", 2509 | ); 2510 | }; 2511 | }, 2512 | { 2513 | Name = "CLANG_ARC_MIGRATE_DIR"; 2514 | Type = Path; 2515 | CommandLineFlag = "-ccc-arcmt-migrate"; 2516 | // Category is hidden. 2517 | }, 2518 | { 2519 | Name = "CLANG_OBJC_MIGRATE_DIR"; 2520 | Type = Path; 2521 | CommandLineFlag = "-ccc-objcmt-migrate"; 2522 | }, 2523 | { 2524 | Name = "CLANG_ARC_MIGRATE_EMIT_ERROR"; 2525 | Type = Boolean; 2526 | DefaultValue = NO; 2527 | CommandLineArgs = { 2528 | YES = ( 2529 | "-arcmt-migrate-emit-errors", 2530 | ); 2531 | NO = (); 2532 | }; 2533 | // Category is hidden. 2534 | }, 2535 | { 2536 | Name = "CLANG_ARC_MIGRATE_REPORT_OUTPUT"; 2537 | Type = Path; 2538 | CommandLineFlag = "-arcmt-migrate-report-output"; 2539 | // Category is hidden. 2540 | }, 2541 | ); 2542 | }, 2543 | { 2544 | Identifier = "com.apple.compilers.llvm.clang.1_0.compiler"; 2545 | Type = Compiler; 2546 | BasedOn = "com.apple.compilers.llvm.clang.1_0"; 2547 | Name = "Apple LLVM 9.0"; 2548 | Description = "Obfuscator 4.0 compiler"; 2549 | IsAbstract = YES; 2550 | ShowInCompilerSelectionPopup = NO; 2551 | Architectures = ( 2552 | i386, 2553 | "x86_64", 2554 | armv6, 2555 | armv7, 2556 | arm64, 2557 | armv7k 2558 | ); 2559 | "OptionConditionFlavors" = ( 2560 | arch, 2561 | sdk, 2562 | ); 2563 | FallbackTools = ( 2564 | "com.apple.compilers.llvmgcc42", 2565 | ); 2566 | ExecCPlusPlusLinkerPath = "clang++"; 2567 | SupportsGeneratePreprocessedFile = YES; 2568 | SupportsGenerateAssemblyFile = YES; 2569 | CommandResultsPostprocessor = "XCClangResultsPostprocessor"; 2570 | DependencyInfoFile = "$(OutputDir)/$(OutputFileBase).d"; 2571 | DependencyInfoArgs = ("-MMD", "-MT", "dependencies", "-MF", "$(DependencyInfoFile)"); 2572 | }, 2573 | { 2574 | Identifier = "com.apple.compilers.llvm.clang.1_0.analyzer"; 2575 | Type = Compiler; 2576 | BasedOn = "com.apple.compilers.llvm.clang.1_0"; 2577 | Name = "Static Analyzer"; 2578 | Description = "Apple Clang Static Analyzer"; 2579 | Architectures = ( 2580 | i386, 2581 | "x86_64", 2582 | armv6, 2583 | armv7, 2584 | arm64, 2585 | armv7k 2586 | ); 2587 | // This is a workaround so that the analyzer ALWAYS uses the clang in the default toolchain. 2588 | ExecPath = "$(CLANG_ANALYZER_EXEC)"; 2589 | RuleName = "Analyze$(CLANG_STATIC_ANALYZER_MODE_ACTION_$(CLANG_STATIC_ANALYZER_MODE)) $(InputFile)"; 2590 | ExecDescription = "Analyze$(StaticAnalyzerModeNameDescription) $(InputFile)"; 2591 | ProgressDescription = "Analyzing$(StaticAnalyzerModeNameDescription) $(CommandProgressByType) source files"; 2592 | OutputDir = "$(CLANG_ANALYZER_OUTPUT_DIR)/StaticAnalyzer/$(PROJECT_NAME)/$(TARGET_NAME)/$(CURRENT_VARIANT)/$(CURRENT_ARCH)"; 2593 | OutputFileExtension = plist; 2594 | OutputsAreProducts = YES; 2595 | IsAbstract = YES; 2596 | ShowInCompilerSelectionPopup = NO; 2597 | ShowOnlySelfDefinedProperties = YES; 2598 | SupportsAnalyzeFile = YES; 2599 | CommandOutputParser = ( 2600 | ("^([^:]*):([0-9]*):[0-9]*: [^:]*error: (.*)$", "emit-analyzer-warning"), 2601 | ("^([^:]*):() [^:]*error: (.*)$", "emit-analyzer-warning"), 2602 | ("^()()error: (.*)$", "emit-analyzer-warning"), 2603 | ); 2604 | CommandResultsPostprocessor = "XCStaticAnalyzerResultsPostprocessor"; 2605 | DependencyInfoFile = "$(OutputDir)/$(OutputFileBase).d"; 2606 | DependencyInfoArgs = ("-MMD", "-MT", "dependencies", "-MF", "$(DependencyInfoFile)"); 2607 | SourceFileOption = "--analyze"; 2608 | FileTypes = ( 2609 | "sourcecode.c.c", 2610 | "sourcecode.c.objc", 2611 | "sourcecode.cpp.cpp", 2612 | "sourcecode.cpp.objcpp", 2613 | ); 2614 | Options = ( 2615 | { 2616 | Name = CLANG_ANALYZER_EXEC; 2617 | Type = Path; 2618 | DefaultValue = "clang"; 2619 | }, 2620 | // Disable the index-while-building flag for the analyzer build. 2621 | { 2622 | Name = "CLANG_INDEX_STORE_ENABLE"; 2623 | Type = Boolean; 2624 | CommandLineArgs = (); 2625 | }, 2626 | { 2627 | Name = CLANG_ANALYZER_DEFINES; 2628 | Type = String; 2629 | DefaultValue = "-D__clang_analyzer__"; 2630 | CommandLineArgs = ("$(value)"); 2631 | // Category is hidden. 2632 | }, 2633 | { 2634 | Name = CLANG_ANALYZER_OUTPUT_DIR; 2635 | Type = Path; 2636 | DefaultValue = "$(TEMP_DIR)"; 2637 | }, 2638 | { 2639 | Name = "CLANG_ANALYZER_OUTPUT"; 2640 | Type = Enumeration; 2641 | Values = ( 2642 | default, 2643 | "plist-multi-file", 2644 | ); 2645 | DefaultValue = "plist-multi-file"; 2646 | CommandLineArgs = { 2647 | default = (); 2648 | "<>" = ( "-Xclang", "-analyzer-output=$(value)", ); 2649 | }; 2650 | // Category is hidden. 2651 | }, 2652 | { 2653 | Name = "CLANG_ANALYZER_ALTERNATE_EDGES"; 2654 | Type = Boolean; 2655 | DefaultValue = YES; 2656 | CommandLineArgs = { 2657 | NO = ( "-Xclang", "-analyzer-config", "-Xclang", "path-diagnostics-alternate=false", ); 2658 | YES = ( "-Xclang", "-analyzer-config", "-Xclang", "path-diagnostics-alternate=true", ); 2659 | }; 2660 | // Category is hidden. 2661 | }, 2662 | { 2663 | Name = "CLANG_ANALYZER_REPORT_MAIN_SOURCE_FILE"; 2664 | Type = Boolean; 2665 | DefaultValue = YES; 2666 | CommandLineArgs = { 2667 | NO = (); 2668 | YES = ( "-Xclang", "-analyzer-config", "-Xclang", "report-in-main-source-file=true", ); 2669 | }; 2670 | // Category is hidden. 2671 | }, 2672 | { Name = RUN_CLANG_STATIC_ANALYZER; 2673 | Type = Boolean; 2674 | DefaultValue = NO; 2675 | Category = "SAPolicy"; 2676 | }, 2677 | // This entry exists for string expansion in 'RuleName'. 2678 | { 2679 | Name = CLANG_STATIC_ANALYZER_MODE_ACTION_shallow; 2680 | Type = String; 2681 | DefaultValue = "Shallow"; 2682 | }, 2683 | // This entry exists for string expansion in 'RuleName'. 2684 | { 2685 | Name = CLANG_STATIC_ANALYZER_MODE_ACTION_deep; 2686 | Type = String; 2687 | DefaultValue = ""; 2688 | }, 2689 | { 2690 | Name = CLANG_STATIC_ANALYZER_MODE; 2691 | Type = Enumeration; 2692 | Values = ( 2693 | shallow, 2694 | deep 2695 | ); 2696 | DefaultValue = shallow; 2697 | CommandLineArgs = { 2698 | shallow = ( 2699 | "-Xclang", 2700 | "-analyzer-config", 2701 | "-Xclang", 2702 | "mode=shallow", 2703 | ); 2704 | deep = (); 2705 | }; 2706 | AppearsAfter = RUN_CLANG_STATIC_ANALYZER; 2707 | Category = SAPolicy; 2708 | }, 2709 | { 2710 | Name = CLANG_STATIC_ANALYZER_MODE_ON_ANALYZE_ACTION; 2711 | Type = Enumeration; 2712 | Values = ( 2713 | shallow, 2714 | deep, 2715 | ); 2716 | DefaultValue = deep; 2717 | AppearsAfter = CLANG_STATIC_ANALYZER_MODE; 2718 | Category = SAPolicy; 2719 | }, 2720 | { 2721 | Name = "CLANG_ANALYZER_DEADCODE_DEADSTORES"; 2722 | Type = Boolean; 2723 | DefaultValue = YES; 2724 | CommandLineArgs = { 2725 | YES = (); 2726 | NO = ( 2727 | "-Xclang", "-analyzer-disable-checker", 2728 | "-Xclang", "deadcode.DeadStores" 2729 | ); 2730 | }; 2731 | Category = SACheckers; 2732 | }, 2733 | { 2734 | Name = "CLANG_ANALYZER_OBJC_COLLECTIONS"; 2735 | Type = Boolean; 2736 | DefaultValue = YES; 2737 | CommandLineArgs = { 2738 | YES = (); 2739 | NO = ( 2740 | "-Xclang", "-analyzer-disable-checker", 2741 | "-Xclang", "osx.coreFoundation.containers.PointerSizedValues", 2742 | "-Xclang", "-analyzer-disable-checker", 2743 | "-Xclang", "osx.cocoa.VariadicMethodTypes", 2744 | "-Xclang", "-analyzer-disable-checker", 2745 | "-Xclang", "osx.cocoa.NilArg", 2746 | ); 2747 | }; 2748 | Category = SAAppleAPICheckers; 2749 | }, 2750 | { 2751 | Name = "CLANG_ANALYZER_OBJC_NSCFERROR"; 2752 | Type = Boolean; 2753 | DefaultValue = YES; 2754 | CommandLineArgs = { 2755 | YES = (); 2756 | NO = ( 2757 | "-Xclang", "-analyzer-disable-checker", 2758 | "-Xclang", "osx.coreFoundation.CFError", 2759 | "-Xclang", "-analyzer-disable-checker", 2760 | "-Xclang", "osx.cocoa.NSError" 2761 | ); 2762 | }; 2763 | Category = SAAppleAPICheckers; 2764 | }, 2765 | { 2766 | Name = "CLANG_ANALYZER_OBJC_INCOMP_METHOD_TYPES"; 2767 | Type = Boolean; 2768 | DefaultValue = YES; 2769 | CommandLineArgs = { 2770 | YES = (); 2771 | NO = ( 2772 | "-Xclang", "-analyzer-disable-checker", 2773 | "-Xclang", "osx.cocoa.IncompatibleMethodTypes" 2774 | ); 2775 | }; 2776 | Category = SAObjCCheckers; 2777 | }, 2778 | { 2779 | Name = "CLANG_ANALYZER_OBJC_UNUSED_IVARS"; 2780 | Type = Boolean; 2781 | DefaultValue = YES; 2782 | CommandLineArgs = { 2783 | YES = (); 2784 | NO = ( 2785 | "-Xclang", "-analyzer-disable-checker", 2786 | "-Xclang", "osx.cocoa.UnusedIvars" 2787 | ); 2788 | }; 2789 | Category = SAObjCCheckers; 2790 | }, 2791 | { 2792 | Name = "CLANG_ANALYZER_OBJC_GENERICS"; 2793 | Type = Boolean; 2794 | DefaultValue = YES; 2795 | CommandLineArgs = { 2796 | YES = (); 2797 | NO = ( 2798 | "-Xclang", "-analyzer-disable-checker", 2799 | "-Xclang", "osx.cocoa.ObjCGenerics" 2800 | ); 2801 | }; 2802 | Category = SAObjCCheckers; 2803 | }, 2804 | { 2805 | Name = "CLANG_ANALYZER_MALLOC"; 2806 | Type = Boolean; 2807 | DefaultValue = YES; 2808 | // Hidden. 2809 | }, 2810 | { 2811 | Name = "CLANG_ANALYZER_MEMORY_MANAGEMENT"; 2812 | Type = Boolean; 2813 | // Inherit CLANG_ANALYZER_MALLOC, which was the old name. 2814 | DefaultValue = "$(CLANG_ANALYZER_MALLOC)"; 2815 | CommandLineArgs = { 2816 | YES = (); 2817 | NO = ( 2818 | "-Xclang", "-analyzer-disable-checker", 2819 | "-Xclang", "unix.Malloc", 2820 | "-Xclang", "-analyzer-disable-checker", 2821 | "-Xclang", "unix.MallocSizeof", 2822 | "-Xclang", "-analyzer-disable-checker", 2823 | "-Xclang", "unix.MismatchedDeallocator", 2824 | "-Xclang", "-analyzer-disable-checker", 2825 | "-Xclang", "cplusplus.NewDelete" 2826 | ); 2827 | }; 2828 | Category = SACheckers; 2829 | }, 2830 | { 2831 | Name = "CLANG_ANALYZER_OBJC_RETAIN_COUNT"; 2832 | Type = Boolean; 2833 | DefaultValue = YES; 2834 | CommandLineArgs = { 2835 | YES = (); 2836 | NO = ( 2837 | "-Xclang", "-analyzer-disable-checker", 2838 | "-Xclang", "osx.cocoa.RetainCount", 2839 | "-Xclang", "-analyzer-disable-checker", 2840 | "-Xclang", "osx.cocoa.ClassRelease" 2841 | ); 2842 | }; 2843 | Category = SAObjCCheckers; 2844 | }, 2845 | { 2846 | Name = "CLANG_ANALYZER_OBJC_ATSYNC"; 2847 | Type = Boolean; 2848 | DefaultValue = YES; 2849 | CommandLineArgs = { 2850 | YES = (); 2851 | NO = ( 2852 | "-Xclang", "-analyzer-disable-checker", 2853 | "-Xclang", "osx.cocoa.AtSync" 2854 | ); 2855 | }; 2856 | Category = SAObjCCheckers; 2857 | }, 2858 | { 2859 | Name = "CLANG_ANALYZER_OBJC_DEALLOC"; 2860 | Type = Boolean; 2861 | DefaultValue = YES; 2862 | CommandLineArgs = { 2863 | YES = (); 2864 | NO = ( 2865 | "-Xclang", "-analyzer-disable-checker", 2866 | "-Xclang", "osx.cocoa.Dealloc" 2867 | ); 2868 | }; 2869 | Category = SAObjCCheckers; 2870 | }, 2871 | { 2872 | Name = "CLANG_ANALYZER_GCD"; 2873 | Type = Boolean; 2874 | DefaultValue = YES; 2875 | CommandLineArgs = { 2876 | YES = (); 2877 | NO = ( 2878 | "-Xclang", "-analyzer-disable-checker", 2879 | "-Xclang", "osx.API" 2880 | ); 2881 | }; 2882 | Category = SAAppleAPICheckers; 2883 | }, 2884 | { 2885 | Name = "CLANG_ANALYZER_NONNULL"; 2886 | Type = Enumeration; 2887 | DefaultValue = YES_NONAGGRESSIVE; 2888 | Values = ( 2889 | YES, 2890 | YES_NONAGGRESSIVE, 2891 | NO 2892 | ); 2893 | CommandLineArgs = { 2894 | YES = (); 2895 | YES_NONAGGRESSIVE = ( 2896 | "-Xclang", "-analyzer-config", 2897 | "-Xclang", "nullability:NoDiagnoseCallsToSystemHeaders=true" 2898 | ); 2899 | NO = ( 2900 | "-Xclang", "-analyzer-disable-checker", 2901 | "-Xclang", "nullability" 2902 | ); 2903 | }; 2904 | Category = SACheckers; 2905 | }, 2906 | { 2907 | Name = "CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION"; 2908 | Type = Enumeration; 2909 | DefaultValue = YES; 2910 | Values = ( 2911 | YES_AGGRESSIVE, 2912 | YES, 2913 | NO 2914 | ); 2915 | CommandLineArgs = { 2916 | YES_AGGRESSIVE = ( 2917 | "-Xclang", "-analyzer-config", 2918 | "-Xclang", "osx.NumberObjectConversion:Pedantic=true" 2919 | ); 2920 | YES = (); 2921 | NO = ( 2922 | "-Xclang", "-analyzer-disable-checker", 2923 | "-Xclang", "osx.NumberObjectConversion" 2924 | ); 2925 | }; 2926 | SupportedVersionRanges = ( "802.0.0" ); 2927 | Category = SAAppleAPICheckers; 2928 | }, 2929 | { 2930 | Name = "CLANG_ANALYZER_LOCALIZABILITY_NONLOCALIZED"; 2931 | Type = Enumeration; 2932 | DefaultValue = NO; 2933 | Values = ( 2934 | YES, 2935 | NO 2936 | ); 2937 | CommandLineArgs = { 2938 | YES = ( 2939 | "-Xclang", "-analyzer-checker", 2940 | "-Xclang", "optin.osx.cocoa.localizability.NonLocalizedStringChecker" 2941 | ); 2942 | NO = (); 2943 | }; 2944 | Category = SAAppleAPICheckers; 2945 | }, 2946 | { 2947 | Name = "CLANG_ANALYZER_LOCALIZABILITY_EMPTY_CONTEXT"; 2948 | Type = Enumeration; 2949 | DefaultValue = NO; 2950 | Values = ( 2951 | YES, 2952 | NO 2953 | ); 2954 | CommandLineArgs = { 2955 | YES = ( 2956 | "-Xclang", "-analyzer-checker", 2957 | "-Xclang", "optin.osx.cocoa.localizability.EmptyLocalizationContextChecker" 2958 | ); 2959 | NO = (); 2960 | }; 2961 | Category = SAAppleAPICheckers; 2962 | }, 2963 | { 2964 | Name = "CLANG_ANALYZER_OBJC_SELF_INIT"; 2965 | Type = Boolean; 2966 | DefaultValue = YES; 2967 | CommandLineArgs = { 2968 | YES = (); 2969 | NO = ( "-Xclang", "-analyzer-disable-checker", 2970 | "-Xclang", "osx.cocoa.SelfInit" ); 2971 | }; 2972 | FileTypes = ( 2973 | "sourcecode.c.objc", 2974 | "sourcecode.cpp.objcpp", 2975 | ); 2976 | Category = SAObjCCheckers; 2977 | }, 2978 | { 2979 | Name = "CLANG_ANALYZER_SECURITY_KEYCHAIN_API"; 2980 | Type = Boolean; 2981 | DefaultValue = YES; 2982 | CommandLineArgs = { 2983 | YES = (); 2984 | NO = ( "-Xclang", "-analyzer-disable-checker", 2985 | "-Xclang", "osx.SecKeychainAPI" ); 2986 | }; 2987 | FileTypes = ( 2988 | "sourcecode.c.objc", 2989 | "sourcecode.cpp.objcpp", 2990 | ); 2991 | Category = SASecurityCheckers; 2992 | }, 2993 | { 2994 | Name = "CLANG_ANALYZER_SECURITY_FLOATLOOPCOUNTER"; 2995 | Type = Boolean; 2996 | DefaultValue = NO; 2997 | CommandLineArgs = { 2998 | YES = ( "-Xclang", "-analyzer-checker", 2999 | "-Xclang", "security.FloatLoopCounter" ); 3000 | NO = (); 3001 | }; 3002 | Category = SASecurityCheckers; 3003 | }, 3004 | { 3005 | Name = "CLANG_ANALYZER_SECURITY_INSECUREAPI_UNCHECKEDRETURN"; 3006 | Type = Boolean; 3007 | DefaultValue = YES; 3008 | CommandLineArgs = { 3009 | YES = ( "-Xclang", "-analyzer-checker", 3010 | "-Xclang", "security.insecureAPI.UncheckedReturn" ); 3011 | NO = ( "-Xclang", "-analyzer-disable-checker", 3012 | "-Xclang", "security.insecureAPI.UncheckedReturn" ); 3013 | }; 3014 | Category = SASecurityCheckers; 3015 | }, 3016 | { 3017 | Name = "CLANG_ANALYZER_SECURITY_INSECUREAPI_GETPW_GETS"; 3018 | Type = Boolean; 3019 | DefaultValue = YES; 3020 | CommandLineArgs = { 3021 | YES = ( "-Xclang", "-analyzer-checker", 3022 | "-Xclang", "security.insecureAPI.getpw", 3023 | "-Xclang", "-analyzer-checker", 3024 | "-Xclang", "security.insecureAPI.gets" ); 3025 | NO = ( "-Xclang", "-analyzer-disable-checker", 3026 | "-Xclang", "security.insecureAPI.getpw", 3027 | "-Xclang", "-analyzer-disable-checker", 3028 | "-Xclang", "security.insecureAPI.gets" ); 3029 | }; 3030 | Category = SASecurityCheckers; 3031 | }, 3032 | { 3033 | Name = "CLANG_ANALYZER_SECURITY_INSECUREAPI_MKSTEMP"; 3034 | Type = Boolean; 3035 | DefaultValue = YES; 3036 | CommandLineArgs = { 3037 | YES = ( "-Xclang", "-analyzer-checker", 3038 | "-Xclang", "security.insecureAPI.mkstemp", 3039 | "-Xclang", "-analyzer-checker", 3040 | "-Xclang", "security.insecureAPI.mktemp" ); 3041 | NO = ( "-Xclang", "-analyzer-disable-checker", 3042 | "-Xclang", "security.insecureAPI.mkstemp", 3043 | "-Xclang", "-analyzer-disable-checker", 3044 | "-Xclang", "security.insecureAPI.mktemp" ); 3045 | }; 3046 | Category = SASecurityCheckers; 3047 | }, 3048 | { 3049 | Name = "CLANG_ANALYZER_SECURITY_INSECUREAPI_RAND"; 3050 | Type = Boolean; 3051 | DefaultValue = NO; 3052 | CommandLineArgs = { 3053 | YES = ( "-Xclang", "-analyzer-checker", 3054 | "-Xclang", "security.insecureAPI.rand" ); 3055 | NO = ( "-Xclang", "-analyzer-disable-checker", 3056 | "-Xclang", "security.insecureAPI.rand" ); 3057 | }; 3058 | Category = SASecurityCheckers; 3059 | }, 3060 | { 3061 | Name = "CLANG_ANALYZER_SECURITY_INSECUREAPI_STRCPY"; 3062 | Type = Boolean; 3063 | DefaultValue = NO; 3064 | CommandLineArgs = { 3065 | YES = ( "-Xclang", "-analyzer-checker", 3066 | "-Xclang", "security.insecureAPI.strcpy" ); 3067 | NO = ( "-Xclang", "-analyzer-disable-checker", 3068 | "-Xclang", "security.insecureAPI.strcpy" ); 3069 | }; 3070 | Category = SASecurityCheckers; 3071 | }, 3072 | { 3073 | Name = "CLANG_ANALYZER_SECURITY_INSECUREAPI_VFORK"; 3074 | Type = Boolean; 3075 | DefaultValue = YES; 3076 | CommandLineArgs = { 3077 | YES = ( "-Xclang", "-analyzer-checker", 3078 | "-Xclang", "security.insecureAPI.vfork" ); 3079 | NO = ( "-Xclang", "-analyzer-disable-checker", 3080 | "-Xclang", "security.insecureAPI.vfork" ); 3081 | }; 3082 | Category = SASecurityCheckers; 3083 | }, 3084 | { 3085 | Name = "CLANG_ANALYZER_SECURITY_BUFFER_OVERFLOW_EXPERIMENTAL"; 3086 | Type = Boolean; 3087 | DefaultValue = NO; 3088 | CommandLineArgs = { 3089 | YES = ( 3090 | "-Xclang", "-analyzer-checker", 3091 | "-Xclang", "core.experimental.Overflow", 3092 | "-Xclang", "-analyzer-checker", 3093 | "-Xclang", "security.experimental.ArrayBoundV2", 3094 | "-Xclang", "-analyzer-max-loop", 3095 | "-Xclang", "100" 3096 | ); 3097 | NO = (); 3098 | }; 3099 | // Category is hidden. 3100 | }, 3101 | // This is intentionally the second to last option so that the build 3102 | // system places its arguments last on the command line. 3103 | { 3104 | Name = "CLANG_ANALYZER_OTHER_CHECKERS"; 3105 | Type = StringList; 3106 | FileTypes = ( 3107 | "sourcecode.c.c", 3108 | "sourcecode.c.objc", 3109 | "sourcecode.cpp.cpp", 3110 | "sourcecode.cpp.objcpp", 3111 | ); 3112 | CommandLineArgs = ( 3113 | "-Xclang", "-analyzer-checker", "-Xclang", "$(value)", 3114 | ); 3115 | }, 3116 | // This is intentionally the last option so that the build 3117 | // system places its arguments last on the command line. 3118 | { 3119 | Name = "CLANG_ANALYZER_OTHER_FLAGS"; 3120 | Type = StringList; 3121 | FileTypes = ( 3122 | "sourcecode.c.c", 3123 | "sourcecode.c.objc", 3124 | "sourcecode.cpp.cpp", 3125 | "sourcecode.cpp.objcpp", 3126 | ); 3127 | CommandLineArgs = ( 3128 | "-Xclang", "$(value)", 3129 | ); 3130 | }, 3131 | ); 3132 | }, 3133 | { 3134 | Identifier = "com.apple.compilers.llvm.clang.1_0.migrator"; 3135 | Type = Compiler; 3136 | BasedOn = "com.apple.compilers.llvm.clang.1_0"; 3137 | Name = "ObjC Migrator"; 3138 | Description = "Apple Clang ObjC Migrator"; 3139 | Architectures = ( 3140 | i386, 3141 | "x86_64", 3142 | armv6, 3143 | armv7, 3144 | ); 3145 | ExecPath = "$(CLANG)"; 3146 | OutputDir = "$(TEMP_DIR)/Migrator"; 3147 | OutputFileExtension = remap; 3148 | OutputsAreProducts = YES; 3149 | IsAbstract = YES; 3150 | CommandResultsPostprocessor = "XCClangResultsPostprocessor"; 3151 | "ShowInCompilerSelectionPopup" = NO; 3152 | "ShowOnlySelfDefinedProperties" = YES; 3153 | SourceFileOption = "--migrate"; 3154 | FileTypes = ( 3155 | "sourcecode.c.objc", 3156 | "sourcecode.cpp.objcpp", 3157 | ); 3158 | Options = ( 3159 | { 3160 | Name = CLANG; 3161 | Type = Path; 3162 | DefaultValue = clang; 3163 | }, 3164 | // Disable the index-while-building flag for the migrator build. 3165 | { 3166 | Name = "CLANG_INDEX_STORE_ENABLE"; 3167 | Type = Boolean; 3168 | CommandLineArgs = (); 3169 | }, 3170 | { 3171 | Name = "CLANG_MIGRATOR_READWRITE_PROPERTY"; 3172 | DisplayName = "Infer readwrite properties"; 3173 | Description = "Infer readwrite properties from a getter and setter method."; 3174 | Type = Boolean; 3175 | DefaultValue = YES; 3176 | CommandLineArgs = { 3177 | YES = ( "-objcmt-migrate-readwrite-property" ); 3178 | NO = (); 3179 | }; 3180 | Category = "Modernizer"; 3181 | }, 3182 | { 3183 | Name = "CLANG_MIGRATOR_READONLY_PROPERTY"; 3184 | DisplayName = "Infer readonly properties"; 3185 | Description = "Infer readonly properties from getter methods."; 3186 | Type = Boolean; 3187 | DefaultValue = YES; 3188 | CommandLineArgs = { 3189 | YES = ( "-objcmt-migrate-readonly-property" ); 3190 | NO = (); 3191 | }; 3192 | Category = "Modernizer"; 3193 | }, 3194 | { 3195 | Name = "CLANG_MIGRATOR_ANNOTATIONS"; 3196 | DisplayName = "Add attribute annotations"; 3197 | Description = "Add attribute annotations to properties and methods."; 3198 | Type = Boolean; 3199 | DefaultValue = YES; 3200 | CommandLineArgs = { 3201 | YES = ( "-objcmt-migrate-annotation" ); 3202 | NO = (); 3203 | }; 3204 | Category = "Modernizer"; 3205 | }, 3206 | { 3207 | Name = "CLANG_MIGRATOR_INSTANCE_TYPE"; 3208 | DisplayName = "Infer instancetype for method result type"; 3209 | Description = "Infer `instancetype` for method result type instead of `id`."; 3210 | Type = Boolean; 3211 | DefaultValue = YES; 3212 | CommandLineArgs = { 3213 | YES = ( "-objcmt-migrate-instancetype" ); 3214 | NO = (); 3215 | }; 3216 | Category = "Modernizer"; 3217 | }, 3218 | { 3219 | Name = "CLANG_MIGRATOR_NSENUM_MACROS"; 3220 | DisplayName = "Use NS_ENUM/NS_OPTIONS macros"; 3221 | Description = "Use `NS_ENUM`/`NS_OPTIONS` macros for enumerators."; 3222 | Type = Boolean; 3223 | DefaultValue = YES; 3224 | CommandLineArgs = { 3225 | YES = ( "-objcmt-migrate-ns-macros" ); 3226 | NO = (); 3227 | }; 3228 | Category = "Modernizer"; 3229 | }, 3230 | { 3231 | Name = "CLANG_MIGRATOR_PROTOCOL_CONFORMANCE"; 3232 | DisplayName = "Infer protocol conformance"; 3233 | Description = "Infer protocol conformance from the interface methods."; 3234 | Type = Boolean; 3235 | DefaultValue = NO; 3236 | CommandLineArgs = { 3237 | YES = ( "-objcmt-migrate-protocol-conformance" ); 3238 | NO = (); 3239 | }; 3240 | Category = "Modernizer"; 3241 | }, 3242 | { 3243 | Name = "CLANG_MIGRATOR_PROPERTY_ATOMICITY"; 3244 | DisplayName = "Atomicity of inferred properties"; 3245 | Description = "Choose the atomicity of the inferred properties."; 3246 | Type = Enumeration; 3247 | Values = ( 3248 | nonatomic, 3249 | atomic, 3250 | NS_NONATOMIC_IOSONLY, 3251 | ); 3252 | DefaultValue = NS_NONATOMIC_IOSONLY; 3253 | CommandLineArgs = { 3254 | nonatomic = (); 3255 | atomic = ( "-objcmt-atomic-property" ); 3256 | NS_NONATOMIC_IOSONLY = ( "-objcmt-ns-nonatomic-iosonly" ); 3257 | }; 3258 | Category = "Modernizer"; 3259 | }, 3260 | { 3261 | Name = "CLANG_MIGRATOR_PUBLIC_HEADERS_ONLY"; 3262 | DisplayName = "Only modify public headers"; 3263 | Description = "Only modify public headers of a target."; 3264 | Type = Boolean; 3265 | DefaultValue = YES; 3266 | CommandLineArgs = { 3267 | YES = ( "-objcmt-white-list-dir-path=$(TARGET_BUILD_DIR)/$(PUBLIC_HEADERS_FOLDER_PATH)" ); 3268 | NO = (); 3269 | }; 3270 | Category = "Modernizer"; 3271 | }, 3272 | { 3273 | Name = "CLANG_MIGRATOR_OBJC_LITERALS"; 3274 | DisplayName = "ObjC literals"; 3275 | Description = "Enable migration to modern ObjC literals syntax."; 3276 | Type = Boolean; 3277 | DefaultValue = YES; 3278 | CommandLineArgs = { 3279 | YES = ( "-objcmt-migrate-literals", "-Qunused-arguments" ); 3280 | NO = (); 3281 | }; 3282 | Category = "Modernizer"; 3283 | }, 3284 | { 3285 | Name = "CLANG_MIGRATOR_PROPERTY_DOT_SYNTAX"; 3286 | DisplayName = "ObjC property-dot syntax"; 3287 | Description = "Enable migration of setter/getter messages to property-dot syntax."; 3288 | Type = Boolean; 3289 | DefaultValue = YES; 3290 | CommandLineArgs = { 3291 | YES = ( "-objcmt-migrate-property-dot-syntax" ); 3292 | NO = (); 3293 | }; 3294 | Category = "Modernizer"; 3295 | }, 3296 | { 3297 | Name = "CLANG_MIGRATOR_OBJC_SUBSCRIPTING"; 3298 | DisplayName = "ObjC subscripting"; 3299 | Description = "Enable migration to modern ObjC subscripting syntax."; 3300 | Type = Boolean; 3301 | DefaultValue = YES; 3302 | CommandLineArgs = { 3303 | YES = ( "-objcmt-migrate-subscripting", "-Qunused-arguments" ); 3304 | NO = (); 3305 | }; 3306 | Category = "Modernizer"; 3307 | }, 3308 | { 3309 | Name = "CLANG_MIGRATOR_OBJC_DESIGNATED_INIT"; 3310 | DisplayName = "Infer designated initializer methods"; 3311 | Description = "Infer `NS_DESIGNATED_INITIALIZER` for designated initializer methods."; 3312 | Type = Boolean; 3313 | DefaultValue = YES; 3314 | CommandLineArgs = { 3315 | YES = ( "-objcmt-migrate-designated-init", "-Qunused-arguments" ); 3316 | NO = (); 3317 | }; 3318 | Category = "Modernizer"; 3319 | }, 3320 | ); 3321 | }, 3322 | { 3323 | Identifier = "com.apple.compilers.llvm.clang.1_0.migrator.xctest"; 3324 | Type = Compiler; 3325 | BasedOn = "com.apple.compilers.llvm.clang.1_0"; 3326 | Name = "XCTest Migrator"; 3327 | Description = "Apple Clang XCTest Migrator"; 3328 | Architectures = ( 3329 | i386, 3330 | "x86_64", 3331 | armv6, 3332 | armv7, 3333 | ); 3334 | ExecPath = "$(CLANG)"; 3335 | OutputDir = "$(TEMP_DIR)/Migrator"; 3336 | OutputFileExtension = remap; 3337 | OutputsAreProducts = YES; 3338 | IsAbstract = YES; 3339 | CommandResultsPostprocessor = "XCClangResultsPostprocessor"; 3340 | "ShowInCompilerSelectionPopup" = NO; 3341 | "ShowOnlySelfDefinedProperties" = YES; 3342 | SourceFileOption = "--migrate-xct"; 3343 | FileTypes = ( 3344 | "sourcecode.c.objc", 3345 | "sourcecode.cpp.objcpp", 3346 | ); 3347 | Options = ( 3348 | { 3349 | Name = CLANG; 3350 | Type = Path; 3351 | DefaultValue = clang; 3352 | }, 3353 | // Disable the index-while-building flag for the migrator build. 3354 | { 3355 | Name = "CLANG_INDEX_STORE_ENABLE"; 3356 | Type = Boolean; 3357 | CommandLineArgs = (); 3358 | }, 3359 | ); 3360 | }, 3361 | { 3362 | Identifier = "com.apple.compilers.llvm.clang.1_0.astbuilder"; 3363 | Type = Compiler; 3364 | BasedOn = "com.apple.compilers.llvm.clang.1_0"; 3365 | Name = "AST Builder"; 3366 | Description = "Apple Clang AST Builder 9.0"; 3367 | FileTypes = ( 3368 | "sourcecode.c.c", 3369 | "sourcecode.c.objc", 3370 | "sourcecode.cpp.cpp", 3371 | "sourcecode.cpp.objcpp", 3372 | ); 3373 | SourceFileOption = "-fsyntax-only"; 3374 | OverridingProperties = { 3375 | "ENABLE_HEADER_DEPENDENCIES" = YES; 3376 | "SHARED_PRECOMPS_DIR" = "$(INDEX_PRECOMPS_DIR)"; 3377 | "CLEAN_PRECOMPS" = NO; 3378 | "CLANG_RETAIN_COMMENTS_FROM_SYSTEM_HEADERS" = YES; 3379 | }; 3380 | RuleName = "Build AST from $(InputFile)"; 3381 | OutputFileExtension = ast; 3382 | IsAbstract = YES; 3383 | ShowInCompilerSelectionPopup = NO; 3384 | PrunePrecompiledHeaderCache = NO; 3385 | }, 3386 | ) 3387 | -------------------------------------------------------------------------------- /Obfuscator.xcplugin/Contents/_CodeSignature/CodeResources: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | files 6 | 7 | Resources/Clang LLVM 1.0.xcspec 8 | 9 | Ces49cxGiffR/GlX8d4BFvRRrgw= 10 | 11 | Resources/Default Compiler.xcspec 12 | 13 | 06q/PFx4DaerpAf3vgDs0+l9S9o= 14 | 15 | Resources/English.lproj/Apple LLVM 9.0.strings 16 | 17 | hash 18 | 19 | wu90IPK7CICqXnxVrmNV6p10hC8= 20 | 21 | optional 22 | 23 | 24 | Resources/English.lproj/Default Compiler.strings 25 | 26 | hash 27 | 28 | aptnqDaY3B1jtclu4RjE+SCM1Ls= 29 | 30 | optional 31 | 32 | 33 | version.plist 34 | 35 | 1viXfyesViVVXN4kBtsBmAk9o4s= 36 | 37 | 38 | files2 39 | 40 | Resources/Clang LLVM 1.0.xcspec 41 | 42 | hash2 43 | 44 | iVywY0+xRLG8/gCaPrNOQ/TX/Gbjfn3J4PYGNB5qgLg= 45 | 46 | 47 | Resources/Default Compiler.xcspec 48 | 49 | hash2 50 | 51 | g8npL2U07qDDvWvvnHr/284MYbSG5GuOdXRSWdCjFjE= 52 | 53 | 54 | Resources/English.lproj/Apple LLVM 9.0.strings 55 | 56 | hash2 57 | 58 | UON5R2fH7s0LaG6NvJroiFfUF0KWS2RwDWSZvoG2/e0= 59 | 60 | optional 61 | 62 | 63 | Resources/English.lproj/Default Compiler.strings 64 | 65 | hash2 66 | 67 | IcN1UKjJ0fmFu7+pFKVLYknPPesJFGn7TwgoBy8Nlhw= 68 | 69 | optional 70 | 71 | 72 | version.plist 73 | 74 | hash2 75 | 76 | 4uM0qUW2rj5NdNYW1Fgaiv5yYDRCchcZmWlzuLbsVk4= 77 | 78 | 79 | 80 | rules 81 | 82 | ^Resources/ 83 | 84 | ^Resources/.*\.lproj/ 85 | 86 | optional 87 | 88 | weight 89 | 1000 90 | 91 | ^Resources/.*\.lproj/locversion.plist$ 92 | 93 | omit 94 | 95 | weight 96 | 1100 97 | 98 | ^Resources/Base\.lproj/ 99 | 100 | weight 101 | 1010 102 | 103 | ^version.plist$ 104 | 105 | 106 | rules2 107 | 108 | .*\.dSYM($|/) 109 | 110 | weight 111 | 11 112 | 113 | ^(.*/)?\.DS_Store$ 114 | 115 | omit 116 | 117 | weight 118 | 2000 119 | 120 | ^(Frameworks|SharedFrameworks|PlugIns|Plug-ins|XPCServices|Helpers|MacOS|Library/(Automator|Spotlight|LoginItems))/ 121 | 122 | nested 123 | 124 | weight 125 | 10 126 | 127 | ^.* 128 | 129 | ^Info\.plist$ 130 | 131 | omit 132 | 133 | weight 134 | 20 135 | 136 | ^PkgInfo$ 137 | 138 | omit 139 | 140 | weight 141 | 20 142 | 143 | ^Resources/ 144 | 145 | weight 146 | 20 147 | 148 | ^Resources/.*\.lproj/ 149 | 150 | optional 151 | 152 | weight 153 | 1000 154 | 155 | ^Resources/.*\.lproj/locversion.plist$ 156 | 157 | omit 158 | 159 | weight 160 | 1100 161 | 162 | ^Resources/Base\.lproj/ 163 | 164 | weight 165 | 1010 166 | 167 | ^[^/]+$ 168 | 169 | nested 170 | 171 | weight 172 | 10 173 | 174 | ^embedded\.provisionprofile$ 175 | 176 | weight 177 | 20 178 | 179 | ^version\.plist$ 180 | 181 | weight 182 | 20 183 | 184 | 185 | 186 | 187 | -------------------------------------------------------------------------------- /Obfuscator.xcplugin/Contents/version.plist: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | BuildAliasOf 6 | IDEXcode3ProjectSupport 7 | BuildVersion 8 | 24 9 | CFBundleShortVersionString 10 | 11.2 11 | CFBundleVersion 12 | 13756 13 | ProjectName 14 | IDEXcode3ProjectSupport 15 | SourceVersion 16 | 13756000000000000 17 | 18 | 19 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | 2 | Xcode obfuscator-llvm plugin 3 | ================== 4 | 5 | 6 | 7 | > Obfuscator-LLVM is a project initiated in June 2010 by the information security group of the University of Applied Sciences and Arts Western Switzerland of Yverdon-les-Bains (HEIG-VD). 8 | 9 | >The aim of this project is to provide an open-source fork of the LLVM compilation suite able to provide increased software security through code obfuscation and tamper-proofing. As we currently mostly work at the Intermediate Representation (IR) level, our tool is compatible with all programming languages (C, C++, Objective-C, Ada and Fortran) and target platforms (x86, x86-64, PowerPC, PowerPC-64, ARM, Thumb, SPARC, Alpha, CellSPU, MIPS, MSP430, SystemZ, and XCore) currently supported by LLVM. 10 | 11 | 12 | Xcode ollvm 插件，安装前请修改下面的clang路径为你自己的ollvm clang路径。 13 | 14 | 15 | BuiltinJambaseRuleName = ProcessC; 16 | ExecPath = "/Users/obaby/Soft/obfuscator/build/bin/clang"; 17 | 18 | 修改完成后将整个Obfuscator.xcplugin 复制到 /Applications/Xcode.app/Contents/PlugIns/Xcode3Core.ideplugin/Contents/SharedSupport/Developer/Library/Xcode/Plug-ins/ 目录下然后重启Xcode即可。 19 | 20 | 如果出现clang-4.0: error: cannot specify -o when generating multiple output files 21 | 22 | 禁用Enable Indexing while building即可 23 | 24 | 已知问题，xcode9.2 无法编译iOS项目。目前还没找到解决方案 25 | 26 | 更多信息： [http://www.h4ck.org.cn/2018/01/xcode-9-2-集成obfuscator-llvm/]( http://www.h4ck.org.cn/2018/01/xcode-9-2-集成obfuscator-llvm/) 27 | --------------------------------------------------------------------------------