"; snapshotFileArgIndex = 3; parseSectionOrderFile(argv[i+1], argv[i+2], argv[i+3]); i += 3; cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-order_file") == 0 ) { snapshotFileArgIndex = 1; parseOrderFile(argv[++i], false); } else if ( strcmp(arg, "-order_file_statistics") == 0 ) { fPrintOrderFileStatistics = true; cannotBeUsedWithBitcode(arg); } // ??? Deprecate segcreate. // -sectcreate puts whole files into a section in the output. else if ( (strcmp(arg, "-sectcreate") == 0) || (strcmp(arg, "-segcreate") == 0) ) { if ( (argv[i+1]==NULL) || (argv[i+2]==NULL) || (argv[i+3]==NULL) ) throw "-sectcreate missing

"; snapshotFileArgIndex = 3; addSection(argv[i+1], argv[i+2], argv[i+3]); i += 3; } else if ( (strcmp(arg, "-add_empty_section") == 0) ) { if ( (argv[i+1]==NULL) || (argv[i+2]==NULL) ) throw "-add_empty_section missing

"; snapshotFileArgIndex = 2; addSection(argv[i+1], argv[i+2], NULL); i += 2; } // Since we have a full path in binary/library names we need to be able to override it. else if ( (strcmp(arg, "-dylib_install_name") == 0) || (strcmp(arg, "-dylinker_install_name") == 0) || (strcmp(arg, "-install_name") == 0)) { const char* installName = argv[++i]; if ( installName == nullptr ) throw "-install_name missing "; fDylibInstallName = removeDoubleSlash(installName); if ( fDylibInstallName != installName ) warning("double slash removed from -install_name (%s)", installName); } // Sets the base address of the output. else if ( (strcmp(arg, "-seg1addr") == 0) || (strcmp(arg, "-image_base") == 0) ) { const char* address = argv[++i]; if ( address == NULL ) throwf("%s missing

", arg); fBaseAddress = parseAddress(address); uint64_t temp = ((fBaseAddress+fSegmentAlignment-1) & (-fSegmentAlignment)); if ( fBaseAddress != temp ) { warning("-seg1addr not %lld byte aligned, rounding up", fSegmentAlignment); fBaseAddress = temp; } cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-e") == 0 ) { fEntryName = argv[++i]; } // Same as -@ from the FSF linker. else if ( strcmp(arg, "-filelist") == 0 ) { snapshotArgCount = 0; const char* path = argv[++i]; if ( (path == NULL) || (path[0] == '-') ) throw "-filelist missing "; ld::File::Ordinal baseOrdinal = ld::File::Ordinal::makeArgOrdinal((uint16_t)i); loadFileList(path, baseOrdinal); } else if ( strcmp(arg, "-keep_private_externs") == 0 ) { cannotBeUsedWithBitcode(arg); fKeepPrivateExterns = true; } else if ( strcmp(arg, "-final_output") == 0 ) { const char* name = argv[++i]; if ( name == NULL ) throw "-final_output missing "; // some projects end up with double slash in -final_output path fFinalName = removeDoubleSlash(name); } // Ensure that all calls to exported symbols go through lazy pointers. Multi-module // just ensures that this happens for cross object file boundaries. else if ( (strcmp(arg, "-interposable") == 0) || (strcmp(arg, "-multi_module") == 0)) { switch ( fInterposeMode ) { case kInterposeNone: case kInterposeAllExternal: fInterposeMode = kInterposeAllExternal; break; case kInterposeSome: // do nothing, -interposable_list overrides -interposable" break; } cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-interposable_list") == 0 ) { snapshotFileArgIndex = 1; fInterposeMode = kInterposeSome; loadExportFile(argv[++i], "-interposable_list", fInterposeList, kAllowWildcards); cannotBeUsedWithBitcode(arg); } // Default for -interposable/-multi_module/-single_module. else if ( strcmp(arg, "-single_module") == 0 ) { fInterposeMode = kInterposeNone; } else if ( strcmp(arg, "-exported_symbols_list") == 0 ) { snapshotFileArgIndex = 1; if ( fExportMode == kDontExportSome ) throw "can't use -exported_symbols_list and -unexported_symbols_list"; fExportMode = kExportSome; loadExportFile(argv[++i], "-exported_symbols_list", fExportSymbols, kAllowWildcards); } else if ( strcmp(arg, "-unexported_symbols_list") == 0 ) { snapshotFileArgIndex = 1; if ( fExportMode == kExportSome ) throw "can't use -unexported_symbols_list and -exported_symbols_list"; fExportMode = kDontExportSome; loadExportFile(argv[++i], "-unexported_symbols_list", fDontExportSymbols, kAllowWildcards); } else if ( strcmp(arg, "-exported_symbol") == 0 ) { if ( fExportMode == kDontExportSome ) throw "can't use -exported_symbol and -unexported_symbols"; fExportMode = kExportSome; const char* symbol = checkForNullArgument(arg, argv[++i]); fExportSymbols.insert(symbol, kAllowWildcards); } else if ( strcmp(arg, "-unexported_symbol") == 0 ) { if ( fExportMode == kExportSome ) throw "can't use -unexported_symbol and -exported_symbol"; fExportMode = kDontExportSome; const char* symbol = checkForNullArgument(arg, argv[++i]); fDontExportSymbols.insert(symbol, kAllowWildcards); } else if ( strcmp(arg, "-no_exported_symbols") == 0 ) { if ( fExportMode != kExportDefault ) throw "can't use -no_exported_symbols and -[un]exported_symbol[s_list]"; fExportMode = kExportSome; } else if ( strcmp(arg, "-non_global_symbols_no_strip_list") == 0 ) { snapshotFileArgIndex = 1; if ( fLocalSymbolHandling == kLocalSymbolsSelectiveExclude ) throw "can't use -non_global_symbols_no_strip_list and -non_global_symbols_strip_list"; fLocalSymbolHandling = kLocalSymbolsSelectiveInclude; loadExportFile(argv[++i], "-non_global_symbols_no_strip_list", fLocalSymbolsIncluded, kAllowWildcards); cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-non_global_symbols_strip_list") == 0 ) { snapshotFileArgIndex = 1; if ( fLocalSymbolHandling == kLocalSymbolsSelectiveInclude ) throw "can't use -non_global_symbols_no_strip_list and -non_global_symbols_strip_list"; fLocalSymbolHandling = kLocalSymbolsSelectiveExclude; loadExportFile(argv[++i], "-non_global_symbols_strip_list", fLocalSymbolsExcluded, kAllowWildcards); cannotBeUsedWithBitcode(arg); } // ??? Deprecate else if ( strcmp(arg, "-no_arch_warnings") == 0 ) { fIgnoreOtherArchFiles = true; } else if ( strcmp(arg, "-force_cpusubtype_ALL") == 0 ) { fForceSubtypeAll = true; fAllowCpuSubtypeMismatches = true; cannotBeUsedWithBitcode(arg); } // Similar to -weak-l but uses the absolute path name to the library. else if ( strcmp(arg, "-weak_library") == 0 ) { const char* path = checkForNullArgument(arg, argv[++i]); FileInfo info = findFile(path); info.options.fWeakImport = true; info.ordinal = ld::File::Ordinal::makeArgOrdinal((uint16_t)i); addLibrary(info); cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-lazy_library") == 0 ) { const char* path = checkForNullArgument(arg, argv[++i]); FileInfo info = findFile(path); info.ordinal = ld::File::Ordinal::makeArgOrdinal((uint16_t)i); addLibrary(info); cannotBeUsedWithBitcode(arg); warning("-lazy_library is deprecated, changing to regular link"); } else if ( strcmp(arg, "-needed_library") == 0 ) { snapshotArgCount = 0; const char* path = checkForNullArgument(arg, argv[++i]); FileInfo info = findFile(path); info.options.fNeeded = true; info.ordinal = ld::File::Ordinal::makeArgOrdinal((uint16_t)i); addLibrary(info); } else if ( strcmp(arg, "-search_in_sparse_frameworks") == 0 ) { fSearchInSparseFrameworks = true; } else if ( strcmp(arg, "-image_suffix") == 0 ) { fImageSuffixes.push_back(checkForNullArgument(arg, argv[++i])); } else if ( strcmp(arg, "-framework") == 0 ) { FileInfo info = findFramework(argv[++i]); info.ordinal = ld::File::Ordinal::makeArgOrdinal((uint16_t)i); addLibrary(info); } else if ( strcmp(arg, "-weak_framework") == 0 ) { FileInfo info = findFramework(argv[++i]); info.options.fWeakImport = true; info.ordinal = ld::File::Ordinal::makeArgOrdinal((uint16_t)i); addLibrary(info); } else if ( strcmp(arg, "-lazy_framework") == 0 ) { FileInfo info = findFramework(argv[++i]); info.ordinal = ld::File::Ordinal::makeArgOrdinal((uint16_t)i); addLibrary(info); cannotBeUsedWithBitcode(arg); warning("-lazy_framework is deprecated, changing to regular link"); } else if ( strcmp(arg, "-needed_framework") == 0 ) { FileInfo info = findFramework(argv[++i]); info.options.fNeeded = true; info.ordinal = ld::File::Ordinal::makeArgOrdinal((uint16_t)i); addLibrary(info); } else if ( strcmp(arg, "-search_paths_first") == 0 ) { // previously handled by buildSearchPaths() } else if ( strcmp(arg, "-search_dylibs_first") == 0 ) { // previously handled by buildSearchPaths() } else if ( strcmp(arg, "-undefined") == 0 ) { setUndefinedTreatment(argv[++i]); cannotBeUsedWithBitcode(arg); } // Debugging output flag. else if ( strcmp(arg, "-arch_multiple") == 0 ) { fMessagesPrefixedWithArchitecture = true; } // Specify what to do with relocations in read only // sections like .text. Could be errors, warnings, // or suppressed. Currently we do nothing with the // flag. else if ( strcmp(arg, "-read_only_relocs") == 0 ) { switch ( parseTreatment(argv[++i]) ) { case kNULL: case kInvalid: throw "-read_only_relocs missing [ warning | error | suppress ]"; case kWarning: fWarnTextRelocs = true; fAllowTextRelocs = true; cannotBeUsedWithBitcode(arg); break; case kSuppress: fWarnTextRelocs = false; fAllowTextRelocs = true; cannotBeUsedWithBitcode(arg); break; case kError: fWarnTextRelocs = false; fAllowTextRelocs = false; break; } } else if ( strcmp(arg, "-unaligned_pointers") == 0 ) { switch ( parseTreatment(argv[++i]) ) { case kNULL: case kInvalid: throw "-unaligned_pointers missing [ warning | error | suppress ]"; case kWarning: fUnalignedPointerTreatment = Options::kUnalignedPointerWarning; cannotBeUsedWithBitcode(arg); break; case kSuppress: fUnalignedPointerTreatment = Options::kUnalignedPointerIgnore; cannotBeUsedWithBitcode(arg); break; case kError: fUnalignedPointerTreatment = Options::kUnalignedPointerError; break; } } else if ( strcmp(arg, "-sect_diff_relocs") == 0 ) { warnObsolete(arg); ++i; } // Warn, error or make strong a mismatch between weak // and non-weak references. else if ( strcmp(arg, "-weak_reference_mismatches") == 0 ) { setWeakReferenceMismatchTreatment(argv[++i]); } // For a deployment target of 10.3 and earlier ld64 will // prebind an executable with 0s in all addresses that // are prebound. This can then be fixed up by update_prebinding // later. Prebinding is less useful on 10.4 and greater. else if ( strcmp(arg, "-prebind") == 0 ) { warnObsolete(arg); cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-noprebind") == 0 ) { warnObsolete(arg); } else if ( strcmp(arg, "-prebind_allow_overlap") == 0 ) { warnObsolete(arg); } else if ( strcmp(arg, "-prebind_all_twolevel_modules") == 0 ) { warnObsolete(arg); } else if ( strcmp(arg, "-noprebind_all_twolevel_modules") == 0 ) { warnObsolete(arg); } else if ( strcmp(arg, "-nofixprebinding") == 0 ) { warnObsolete(arg); } // This should probably be deprecated when we respect -L and -F // when searching for libraries. else if ( strcmp(arg, "-dylib_file") == 0 ) { // ignore for snapshot because a stub dylib will be created in the snapshot snapshotArgCount = 0; addDylibOverride(argv[++i]); cannotBeUsedWithBitcode(arg); } // What to expand @executable_path to if found in dependent dylibs else if ( strcmp(arg, "-executable_path") == 0 ) { fExecutablePath = argv[++i]; if ( (fExecutablePath == NULL) || (fExecutablePath[0] == '-') ) throw "-executable_path missing "; // if a directory was passed, add / to end // ld64 can't find @executable _path relative dylibs from our umbrella frameworks struct stat statBuffer; if ( stat(fExecutablePath, &statBuffer) == 0 ) { if ( (statBuffer.st_mode & S_IFMT) == S_IFDIR ) { char* pathWithSlash = new char[strlen(fExecutablePath)+2]; strcpy(pathWithSlash, fExecutablePath); strcat(pathWithSlash, "/"); fExecutablePath = pathWithSlash; } } } // Aligns all segments to the power of 2 boundary specified. else if ( strcmp(arg, "-segalign") == 0 ) { const char* size = argv[++i]; if ( size == NULL ) throw "-segalign missing "; fSegmentAlignment = parseAddress(size); uint8_t alignment = (uint8_t)__builtin_ctz(fSegmentAlignment); uint32_t p2aligned = (1 << alignment); if ( p2aligned != fSegmentAlignment ) { warning("alignment for -segalign %s is not a power of two, using 0x%X", size, p2aligned); fSegmentAlignment = p2aligned; } fForceAlignment = true; cannotBeUsedWithBitcode(arg); } // Puts a specified segment at a particular address that must // be a multiple of the segment alignment. else if ( strcmp(arg, "-segaddr") == 0 ) { SegmentStart seg; seg.name = argv[++i]; if ( (seg.name == NULL) || (argv[i+1] == NULL) ) throw "-segaddr missing segName Adddress"; seg.address = parseAddress(argv[++i]); uint64_t temp = ((seg.address+fSegmentAlignment-1) & (-fSegmentAlignment)); if ( seg.address != temp ) warning("-segaddr %s not %lld byte aligned", seg.name, fSegmentAlignment); fCustomSegmentAddresses.push_back(seg); cannotBeUsedWithBitcode(arg); } // ??? Deprecate when we deprecate split-seg. else if ( strcmp(arg, "-segs_read_only_addr") == 0 ) { warnObsolete(arg); ++i; cannotBeUsedWithBitcode(arg); } // ??? Deprecate when we deprecate split-seg. else if ( strcmp(arg, "-segs_read_write_addr") == 0 ) { warnObsolete(arg); ++i; cannotBeUsedWithBitcode(arg); } // ??? Deprecate when we get rid of basing at build time. else if ( strcmp(arg, "-seg_addr_table") == 0 ) { warnObsolete(arg); snapshotFileArgIndex = 1; const char* name = argv[++i]; if ( name == NULL ) throw "-seg_addr_table missing argument"; cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-seg_addr_table_filename") == 0 ) { warnObsolete(arg); ++i; } else if ( strcmp(arg, "-segprot") == 0 ) { SegmentProtect seg; seg.name = argv[++i]; if ( (seg.name == NULL) || (argv[i+1] == NULL) || (argv[i+2] == NULL) ) throw "-segprot missing segName max-prot init-prot"; seg.max = parseProtection(argv[++i]); seg.init = parseProtection(argv[++i]); if ( strcmp(seg.name, "__LINKEDIT") == 0 ) warning("-segprot cannot be used to modify __LINKEDIT protections"); else fCustomSegmentProtections.push_back(seg); cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-pagezero_size") == 0 ) { const char* size = argv[++i]; if ( size == NULL ) throw "-pagezero_size missing "; fZeroPageSize = parseAddress(size); uint64_t temp = fZeroPageSize & (-4096); // page align if ( (fZeroPageSize != temp) ) warning("-pagezero_size not page aligned, rounding down"); fZeroPageSize = temp; cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-implicit_pagezero") == 0 ) { fImplicitPageZero = true; fZeroPageSize = ULLONG_MAX; } else if ( strcmp(arg, "-stack_addr") == 0 ) { const char* address = argv[++i]; if ( address == NULL ) throw "-stack_addr missing

"; fStackAddr = parseAddress(address); cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-stack_size") == 0 ) { const char* size = argv[++i]; if ( size == NULL ) throw "-stack_size missing

"; fStackSize = parseAddress(size); } else if ( strcmp(arg, "-allow_stack_execute") == 0 ) { fExecutableStack = true; // Only Intel hardware supports executable stacks. bool supportsExecutableStacks = ((fArchitecture == CPU_TYPE_I386) || (fArchitecture == CPU_TYPE_X86_64)); if (!supportsExecutableStacks) throw "the target architecture doesn't support executable stacks"; cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-allow_heap_execute") == 0 ) { fDisableNonExecutableHeap = true; cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-sectalign") == 0 ) { if ( (argv[i+1]==NULL) || (argv[i+2]==NULL) || (argv[i+3]==NULL) ) throw "-sectalign missing

"; addSectionAlignment(argv[i+1], argv[i+2], argv[i+3]); i += 3; } else if ( strcmp(arg, "-sectorder_detail") == 0 ) { warnObsolete(arg); } else if ( strcmp(arg, "-sectobjectsymbols") == 0 ) { warnObsolete(arg); i += 2; } else if ( strcmp(arg, "-bundle_loader") == 0 ) { snapshotFileArgIndex = 1; fBundleLoader = argv[++i]; if ( (fBundleLoader == NULL) || (fBundleLoader[0] == '-') ) throw "-bundle_loader missing "; FileInfo info = findFile(fBundleLoader); info.ordinal = ld::File::Ordinal::makeArgOrdinal((uint16_t)i); info.options.fBundleLoader = true; fInputFiles.push_back(info); } else if ( strcmp(arg, "-private_bundle") == 0 ) { warnObsolete(arg); } else if ( strcmp(arg, "-twolevel_namespace_hints") == 0 ) { warnObsolete(arg); } else if ( strcmp(arg, "-platform_version") == 0 ) { const char* platformStr = argv[++i]; if (platformStr == nullptr) { throwf("platform and versions must be specified"); } ld::Platform plat = ld::platformFromName(platformStr); if ( plat == ld::Platform::unknown ) throwf("%s passed unknown platform name '%s'", arg, platformStr); const char* versStr = checkForNullVersionArgument(arg, argv[++i]); if ( versStr == NULL ) throwf("%s missing min version argument", arg); uint32_t minVersValue; if ( !parsePackedVersion32(versStr, minVersValue) ) { throwf("%s min version malformed: '%s'", arg, versStr); } const char* SDKVersStr = checkForNullVersionArgument(arg, argv[++i]); if ( SDKVersStr == NULL ) throwf("%s missing sdk version argument", arg); uint32_t SDKValue; if ( !parsePackedVersion32(SDKVersStr, SDKValue) ) { throwf("%s sdk version malformed: '%s'", arg, SDKVersStr); } if ( fPlatforms.contains(plat) ) { std::string existingVersionStr = getVersionString32(fPlatforms.minOS(plat)); warning("passed two min versions (%s, %s) for platform %s. Using %s.", existingVersionStr.c_str(), versStr, nameFromPlatform(plat), versStr); fPlatforms.updateMinVersion(plat, minVersValue); fPlatforms.updateSDKVersion(plat, SDKValue); } else { // free-standing always overrides anything the compiler may have added if ( plat == ld::Platform::freestanding ) fPlatforms.clear(); fPlatforms.insert(ld::PlatformVersion(plat, minVersValue, SDKValue)); } fPlatfromVersionCmdFound = true; } else if ( const ld::PlatformInfo* info = isPlatformOption(arg) ) { const char* versStr = checkForNullVersionArgument(arg, argv[++i]); if ( versStr == NULL ) throwf("%s missing version argument", arg); uint32_t value; if ( !parsePackedVersion32(versStr, value) ) { throwf("%s value malformed: '%s'", arg, versStr); } if ( value < info->minimumOsVersion ) { if ( info->platform == ld::Platform::iOSMac ) { value = info->minimumOsVersion; warning("changing %s minOS version from %s to %s", info->printName, versStr, getVersionString32(info->minimumOsVersion).c_str()); } else { warning("building for %s %s is deprecated", info->printName, versStr); } } if (fPlatforms.contains(info->platform)) { std::string existingVersionStr = getVersionString32(fPlatforms.minOS(info->platform)); warning("passed two min versions (%s, %s) for platform %s. Using %s.", existingVersionStr.c_str(), versStr, info->printName, versStr); fPlatforms.updateMinVersion(info->platform, value); } else { fPlatforms.insert(ld::PlatformVersion(info->platform, value)); } } else if ( strcmp(arg, "-multiply_defined") == 0 ) { //warnObsolete(arg); ++i; } else if ( strcmp(arg, "-multiply_defined_unused") == 0 ) { warnObsolete(arg); ++i; } else if ( strcmp(arg, "-nomultidefs") == 0 ) { warnObsolete(arg); } // Display each file in which the argument symbol appears and whether // the file defines or references it. This option takes an argument // as -y note that there is no space. else if ( strncmp(arg, "-y", 2) == 0 ) { warnObsolete("-y"); } // Same output as -y, but output number of undefined symbols only. else if ( strcmp(arg, "-Y") == 0 ) { //warnObsolete(arg); ++i; } // This option affects all objects linked into the final result. else if ( strcmp(arg, "-m") == 0 ) { warnObsolete(arg); } else if ( (strcmp(arg, "-why_load") == 0) || (strcmp(arg, "-whyload") == 0) ) { fWhyLoad = true; } else if ( strcmp(arg, "-why_live") == 0 ) { const char* name = argv[++i]; if ( name == NULL ) throw "-why_live missing symbol name argument"; fWhyLive.insert(name, kAllowWildcards); } else if ( strcmp(arg, "-u") == 0 ) { const char* name = argv[++i]; if ( name == NULL ) throw "-u missing argument"; fInitialUndefines.push_back(name); } else if ( strcmp(arg, "-U") == 0 ) { const char* name = argv[++i]; if ( name == NULL ) throw "-U missing argument"; fAllowedUndefined.insert(name); cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-s") == 0 ) { warnObsolete(arg); fLocalSymbolHandling = kLocalSymbolsNone; fDebugInfoStripping = Options::kDebugInfoNone; } else if ( strcmp(arg, "-x") == 0 ) { fLocalSymbolHandling = kLocalSymbolsNone; } else if ( strcmp(arg, "-S") == 0 ) { fDebugInfoStripping = Options::kDebugInfoNone; } else if ( strcmp(arg, "-X") == 0 ) { warnObsolete(arg); } else if ( strcmp(arg, "-Si") == 0 ) { warnObsolete(arg); fDebugInfoStripping = Options::kDebugInfoFull; } else if ( strcmp(arg, "-b") == 0 ) { warnObsolete(arg); } else if ( strcmp(arg, "-Sn") == 0 ) { warnObsolete(arg); fDebugInfoStripping = Options::kDebugInfoFull; } else if ( strcmp(arg, "-Sp") == 0 ) { warnObsolete(arg); } else if ( strcmp(arg, "-dead_strip") == 0 ) { fDeadStrip = true; } else if ( strcmp(arg, "-remove_swift_reflection_metadata_sections") == 0 ) { fRemoveSwiftReflectionMetadataSections = true; } else if ( strcmp(arg, "-no_dead_strip_inits_and_terms") == 0 ) { warnObsolete(arg); fDeadStrip = true; } else if ( strcmp(arg, "-w") == 0 ) { // previously handled by buildSearchPaths() } else if ( strcmp(arg, "-fatal_warnings") == 0 ) { // previously handled by buildSearchPaths() } else if ( strcmp(arg, "-arch_errors_fatal") == 0 ) { fErrorOnOtherArchFiles = true; } else if ( strcmp(arg, "-M") == 0 ) { // FIX FIX } else if ( strcmp(arg, "-headerpad") == 0 ) { const char* size = argv[++i]; if ( size == NULL ) throw "-headerpad missing argument"; fMinimumHeaderPad = parseAddress(size); cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-headerpad_max_install_names") == 0 ) { // ignore -headerpad_max_install_names when compiling with bitcode // rdar://problem/20748962 if ( fBundleBitcode ) warning("-headerpad_max_install_names is ignored when used with -bitcode_bundle (Xcode setting ENABLE_BITCODE=YES)"); else fMaxMinimumHeaderPad = true; } else if ( strcmp(arg, "-t") == 0 ) { fLogAllFiles = true; } else if ( strcmp(arg, "-A") == 0 ) { warnObsolete(arg); ++i; } else if ( strcmp(arg, "-umbrella") == 0 ) { const char* name = argv[++i]; if ( name == NULL ) throw "-umbrella missing argument"; fUmbrellaName = name; cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-allowable_client") == 0 ) { const char* name = argv[++i]; if ( name == NULL ) throw "-allowable_client missing argument"; fAllowableClients.push_back(name); cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-client_name") == 0 ) { const char* name = argv[++i]; if ( name == NULL ) throw "-client_name missing argument"; fClientName = name; cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-sub_umbrella") == 0 ) { const char* name = argv[++i]; if ( name == NULL ) throw "-sub_umbrella missing argument"; fSubUmbellas.push_back(name); cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-sub_library") == 0 ) { const char* name = argv[++i]; if ( name == NULL ) throw "-sub_library missing argument"; fSubLibraries.push_back(name); cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-init") == 0 ) { const char* name = argv[++i]; if ( name == NULL ) throw "-init missing argument"; fInitFunctionName = name; cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-dot") == 0 ) { const char* name = argv[++i]; if ( name == NULL ) throw "-dot missing argument"; fDotOutputFile = name; cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-warn_commons") == 0 ) { fWarnCommons = true; } else if ( strcmp(arg, "-commons") == 0 ) { fCommonsMode = parseCommonsTreatment(argv[++i]); } else if ( strcmp(arg, "-keep_relocs") == 0 ) { fKeepRelocations = true; } else if ( strcmp(arg, "-warn_stabs") == 0 ) { fWarnStabs = true; } else if ( strcmp(arg, "-pause") == 0 ) { fPause = true; } else if ( strcmp(arg, "-print_statistics") == 0 ) { fStatistics = true; } else if ( strcmp(arg, "-d") == 0 ) { fMakeTentativeDefinitionsReal = true; } else if ( strcmp(arg, "-v") == 0 ) { // previously handled by buildSearchPaths() } else if ( strcmp(arg, "-Z") == 0 ) { // previously handled by buildSearchPaths() } else if ( strcmp(arg, "-syslibroot") == 0 ) { snapshotArgCount = 0; ++i; // previously handled by buildSearchPaths() } else if ( strcmp(arg, "-bitcode_bundle") == 0 ) { snapshotArgCount = 0; // previously handled by buildSearchPaths() } else if ( strcmp(arg, "-no_uuid") == 0 ) { fUUIDMode = kUUIDNone; cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-random_uuid") == 0 ) { fUUIDMode = kUUIDRandom; cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-dtrace") == 0 ) { snapshotFileArgIndex = 1; const char* name = argv[++i]; if ( name == NULL ) throw "-dtrace missing argument"; fDtraceScriptName = name; cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-root_safe") == 0 ) { fRootSafe = true; } else if ( strcmp(arg, "-setuid_safe") == 0 ) { fSetuidSafe = true; } else if ( strcmp(arg, "-alias") == 0 ) { Options::AliasPair pair; pair.realName = checkForNullArgument(arg, argv[++i]); pair.alias = checkForNullArgument(arg, argv[++i]); fAliases.push_back(pair); cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-alias_list") == 0 ) { snapshotFileArgIndex = 1; parseAliasFile(argv[++i]); cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-save-temps") == 0 ) { fSaveTempFiles = true; } else if ( strcmp(arg, "-bitcode_hide_symbols") == 0 ) { fHideSymbols = true; } else if ( strcmp(arg, "-bitcode_verify") == 0 ) { fVerifyBitcode = true; } else if ( strcmp(arg, "-bitcode_symbol_map") == 0) { fReverseMapPath = checkForNullArgument(arg, argv[++i]); struct stat statbuf; int ret = ::stat(fReverseMapPath, &statbuf); if ( ret == 0 && S_ISDIR(statbuf.st_mode)) { char tempPath[PATH_MAX]; sprintf(tempPath, "%s/XXXXXX", fReverseMapPath); int tempFile = ::mkstemp(tempPath); if (tempFile == -1) throwf("could not write file to symbol map directory: %s", fReverseMapPath); ::close(tempFile); fReverseMapTempPath = std::string(tempPath); fReverseMapUUIDRename = true; } else fReverseMapTempPath = std::string(fReverseMapPath); } else if ( strcmp(arg, "-flto-codegen-only") == 0) { fLTOCodegenOnly = true; } else if ( strcmp(arg, "-ignore_auto_link") == 0) { fIgnoreAutoLink = true; } else if ( strcmp(arg, "-allow_dead_duplicates") == 0) { fAllowDeadDups = true; } else if ( strcmp(arg, "-bitcode_process_mode") == 0 ) { const char* bitcode_type = checkForNullArgument(arg, argv[++i]); if ( strcmp(bitcode_type, "strip") == 0 ) fBitcodeKind = kBitcodeStrip; else if ( strcmp(bitcode_type, "marker") == 0 ) fBitcodeKind = kBitcodeMarker; else if ( strcmp(bitcode_type, "data") == 0 ) fBitcodeKind = kBitcodeAsData; else if ( strcmp(bitcode_type, "bitcode") == 0 ) fBitcodeKind = kBitcodeProcess; else throw "unknown argument to -bitcode_process_mode {strip,marker,data,bitcode}"; } else if ( strcmp(arg, "-rpath") == 0 ) { const char* path = checkForNullArgument(arg, argv[++i]); fRPaths.push_back(path); } else if ( strcmp(arg, "-read_only_stubs") == 0 ) { fReadOnlyx86Stubs = true; } else if ( strcmp(arg, "-slow_stubs") == 0 ) { warnObsolete(arg); } else if ( strcmp(arg, "-map") == 0 ) { fMapPath = checkForNullArgument(arg, argv[++i]); } else if ( strcmp(arg, "-pie") == 0 ) { fPositionIndependentExecutable = true; fPIEOnCommandLine = true; } else if ( strcmp(arg, "-no_pie") == 0 ) { fDisablePositionIndependentExecutable = true; cannotBeUsedWithBitcode(arg); } else if ( strncmp(arg, "-reexport-l", 11) == 0 ) { FileInfo info = findLibrary(&arg[11], true); info.options.fReExport = true; info.ordinal = ld::File::Ordinal::makeArgOrdinal((uint16_t)i); addLibrary(info); cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-reexport_library") == 0 ) { const char* path = checkForNullArgument(arg, argv[++i]); FileInfo info = findFile(path); info.options.fReExport = true; info.ordinal = ld::File::Ordinal::makeArgOrdinal((uint16_t)i); addLibrary(info); cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-reexport_framework") == 0 ) { // SNAPSHOT FIXME: what should we do for link snapshots? (ignore for now) snapshotArgCount = 0; FileInfo info = findFramework(argv[++i]); info.options.fReExport = true; info.ordinal = ld::File::Ordinal::makeArgOrdinal((uint16_t)i); addLibrary(info); cannotBeUsedWithBitcode(arg); } else if ( strncmp(arg, "-upward-l", 9) == 0 ) { FileInfo info = findLibrary(&arg[9], true); info.options.fUpward = true; info.ordinal = ld::File::Ordinal::makeArgOrdinal((uint16_t)i); addLibrary(info); cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-upward_library") == 0 ) { const char* path = checkForNullArgument(arg, argv[++i]); FileInfo info = findFile(path); info.options.fUpward = true; info.ordinal = ld::File::Ordinal::makeArgOrdinal((uint16_t)i); addLibrary(info); cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-upward_framework") == 0 ) { FileInfo info = findFramework(argv[++i]); info.options.fUpward = true; info.ordinal = ld::File::Ordinal::makeArgOrdinal((uint16_t)i); addLibrary(info); cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-dead_strip_dylibs") == 0 ) { fDeadStripDylibs = true; cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-no_implicit_dylibs") == 0 ) { fImplicitlyLinkPublicDylibs = false; } else if ( strcmp(arg, "-new_linker") == 0 ) { // ignore } else if ( strcmp(arg, "-no_encryption") == 0 ) { fEncryptableForceOff = true; cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-encryptable") == 0 ) { fEncryptableForceOn = true; cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-no_compact_unwind") == 0 ) { fAddCompactUnwindEncoding = false; cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-no_dwarf_unwind") == 0 ) { fRemoveDwarfUnwindSections = true; cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-mllvm") == 0 ) { const char* opts = checkForNullArgument(arg, argv[++i], true); fLLVMOptions.push_back(opts); cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-mcpu") == 0 ) { const char* cpu = checkForNullArgument(arg, argv[++i]); fLtoCpu = cpu; cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-no_order_inits") == 0 ) { fAutoOrderInitializers = false; cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-seg_page_size") == 0 ) { SegmentSize seg; seg.name = argv[++i]; if ( (seg.name == NULL) || (argv[i+1] == NULL) ) throw "-seg_page_size missing segName Adddress"; seg.size = parseAddress(argv[++i]); uint64_t temp = seg.size & (-4096); // page align if ( (seg.size != temp) ) warning("-seg_page_size %s not 4K aligned, rounding down", seg.name); fCustomSegmentSizes.push_back(seg); cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-mark_dead_strippable_dylib") == 0 ) { fMarkDeadStrippableDylib = true; cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-exported_symbols_order") == 0 ) { warnObsolete("-exported_symbols_order"); ++i; cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-no_compact_linkedit") == 0 ) { warnObsolete("-no_compact_linkedit"); } else if ( strcmp(arg, "-no_eh_labels") == 0 ) { fNoEHLabels = true; cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-warn_compact_unwind") == 0 ) { fWarnCompactUnwind = true; } else if ( strcmp(arg, "-allow_sub_type_mismatches") == 0 ) { fAllowCpuSubtypeMismatchesForceOn = true; cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-no_zero_fill_sections") == 0 ) { fOptimizeZeroFill = false; cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-merge_zero_fill_sections") == 0 ) { fMergeZeroFill = true; cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-objc_abi_version") == 0 ) { const char* version = checkForNullVersionArgument(arg, argv[++i]); if ( strcmp(version, "2") == 0 ) { fObjCABIVersion1Override = false; fObjCABIVersion2Override = true; } else if ( strcmp(version, "1") == 0 ) { fObjCABIVersion1Override = true; fObjCABIVersion2Override = false; } else warning("ignoring unrecognized argument (%s) to -objc_abi_version", version); } else if ( strcmp(arg, "-warn_unused_dylibs") == 0 ) { fWarnUnusedDylibsForceOn = true; } else if ( strcmp(arg, "-no_warn_unused_dylibs") == 0 ) { fWarnUnusedDylibsForceOff = true; } else if ( strcmp(arg, "-objc_relative_method_lists") == 0 ) { fForceObjCRelativeMethodListsOn = true; } else if ( strcmp(arg, "-no_objc_relative_method_lists") == 0 ) { fForceObjCRelativeMethodListsOff = true; } else if ( strcmp(arg, "-warn_weak_exports") == 0 ) { fWarnWeakExports = true; } else if ( strcmp(arg, "-no_weak_exports") == 0 ) { fNoWeakExports = true; } else if ( strcmp(arg, "-objc_gc_compaction") == 0 ) { warnObsolete(arg); } else if ( strcmp(arg, "-objc_gc") == 0 ) { warnObsolete(arg); } else if ( strcmp(arg, "-objc_gc_only") == 0 ) { warnObsolete(arg); } else if ( strcmp(arg, "-objc_stubs_small") == 0 ) { fObjcSmallStubs = true; } else if ( strcmp(arg, "-objc_stubs_fast") == 0 ) { fObjcSmallStubs = false; } else if ( strcmp(arg, "-no_huge") == 0 ) { // rdar://113231351 (ld64: add -no_huge option to disable the x86 huge pass) fRunHugePass = false; } else if ( strcmp(arg, "-demangle") == 0 ) { fDemangle = true; } else if ( strcmp(arg, "-version_load_command") == 0 ) { fVersionLoadCommandForcedOn = true; fVersionLoadCommandForcedOff = false; } else if ( strcmp(arg, "-function_starts") == 0 ) { fFunctionStartsForcedOn = true; fFunctionStartsForcedOff = false; } else if ( strcmp(arg, "-no_function_starts") == 0 ) { fFunctionStartsForcedOff = true; fFunctionStartsForcedOn = false; cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-no_data_in_code_info") == 0 ) { fDataInCodeInfoLoadCommandForcedOff = true; fDataInCodeInfoLoadCommandForcedOn = false; cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-data_in_code_info") == 0 ) { fDataInCodeInfoLoadCommandForcedOn = true; fDataInCodeInfoLoadCommandForcedOff = false; } else if ( strcmp(arg, "-object_path_lto") == 0 ) { fTempLtoObjectPath = checkForNullArgument(arg, argv[++i]); } else if ( strcmp(arg, "-no_objc_category_merging") == 0 ) { fObjcCategoryMerging = false; } else if ( strcmp(arg, "-force_symbols_weak_list") == 0 ) { snapshotFileArgIndex = 1; loadExportFile(argv[++i], "-force_symbols_weak_list", fForceWeakSymbols, kAllowWildcards); cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-force_symbols_not_weak_list") == 0 ) { snapshotFileArgIndex = 1; loadExportFile(argv[++i], "-force_symbols_not_weak_list", fForceNotWeakSymbols, kAllowWildcards); cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-force_symbol_weak") == 0 ) { const char* symbol = argv[++i]; if ( symbol == NULL ) throw "-force_symbol_weak missing "; fForceWeakSymbols.insert(symbol, kAllowWildcards); cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-force_symbol_not_weak") == 0 ) { const char* symbol = argv[++i]; if ( symbol == NULL ) throw "-force_symbol_not_weak missing "; fForceNotWeakSymbols.insert(symbol, kAllowWildcards); cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-reexported_symbols_list") == 0 ) { snapshotFileArgIndex = 1; if ( fExportMode == kExportSome ) throw "can't use -exported_symbols_list and -reexported_symbols_list"; loadExportFile(argv[++i], "-reexported_symbols_list", fReExportSymbols, kAllowWildcards); } else if ( strcmp(arg, "-dyld_env") == 0 ) { const char* envarg = argv[++i]; if ( envarg == NULL ) throw "-dyld_env missing ENV=VALUE"; if ( strchr(envarg, '=') == NULL ) throw "-dyld_env missing ENV=VALUE"; fDyldEnvironExtras.push_back(envarg); cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-page_align_data_atoms") == 0 ) { fPageAlignDataAtoms = true; cannotBeUsedWithBitcode(arg); } else if (strcmp(arg, "-debug_snapshot") == 0) { fLinkSnapshot.setSnapshotMode(Snapshot::SNAPSHOT_DEBUG); fSnapshotRequested = true; cannotBeUsedWithBitcode(arg); } else if (strcmp(arg, "-snapshot_dir") == 0) { const char* path = argv[++i]; if ( path == NULL ) throw "-snapshot_dir missing path"; fLinkSnapshot.setSnapshotMode(Snapshot::SNAPSHOT_DEBUG); fLinkSnapshot.setSnapshotPath(path); fSnapshotRequested = true; cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-source_version") == 0 ) { const char* vers = argv[++i]; if ( vers == NULL ) throw "-source_version missing "; fSourceVersion = parseVersionNumber64(vers); } else if ( strcmp(arg, "-add_source_version") == 0 ) { fSourceVersionLoadCommandForceOn = true; } else if ( strcmp(arg, "-no_source_version") == 0 ) { fSourceVersionLoadCommandForceOff = true; cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-sdk_version") == 0 ) { const char* vers = argv[++i]; if ( vers == NULL ) throw "-sdk_version missing "; fSDKVersion = parseVersionNumber32(vers); } else if ( strcmp(arg, "-dependent_dr_info") == 0 ) { warnObsolete(arg); } else if ( strcmp(arg, "-no_dependent_dr_info") == 0 ) { warnObsolete(arg); } else if ( strcmp(arg, "-kexts_use_stubs") == 0 ) { fKextsUseStubs = true; cannotBeUsedWithBitcode(arg); } else if ( strcmp(arg, "-dependency_info") == 0 ) { snapshotArgCount = 0; ++i; // previously handled by buildSearchPaths() } else if ( strcmp(arg, "-export_dynamic") == 0 ) { fExportDynamic = true; } else if ( strcmp(arg, "-force_symbols_coalesce_list") == 0 ) { snapshotFileArgIndex = 1; loadExportFile(argv[++i], "-force_symbols_coalesce_list", fForceCoalesceSymbols, kAllowWildcards); } else if ( strcmp(arg, "-add_linker_option") == 0 ) { // ex: -add_linker_option '-framework Foundation' const char* optString = argv[++i]; if ( optString == NULL ) throw "-add_linker_option missing