ld64-409.12.tar.gz

[apple/ld64.git] / src / ld / Options.h

diff --git a/src/ld/Options.h b/src/ld/Options.h
index 5a8a7e0fa43ef3ecc52829246b3dc233c4fb08fb..62bcddfa0e9111824c3c806a0666f43cdbb1f142 100644 (file)
--- a/src/ld/Options.h
+++ b/src/ld/Options.h
@@ -28,27 +28,35 @@
 
 #include <stdint.h>
 #include <mach/machine.h>
 
 #include <stdint.h>
 #include <mach/machine.h>

+#include <tapi/tapi.h>

 
 #include <vector>
 
 #include <vector>

-#include <ext/hash_set>
-#include <ext/hash_map>
+#include <unordered_set>
+#include <unordered_map>

 
 #include "ld.hpp"
 
 #include "ld.hpp"

+#include "Snapshot.h"
+#include "MachOFileAbstraction.hpp"
+

 
 extern void throwf (const char* format, ...) __attribute__ ((noreturn,format(printf, 1, 2)));
 extern void warning(const char* format, ...) __attribute__((format(printf, 1, 2)));
 
 
 extern void throwf (const char* format, ...) __attribute__ ((noreturn,format(printf, 1, 2)));
 extern void warning(const char* format, ...) __attribute__((format(printf, 1, 2)));
 

+class Snapshot;
+

 class LibraryOptions
 {
 public:
        LibraryOptions() : fWeakImport(false), fReExport(false), fBundleLoader(false), 
 class LibraryOptions
 {
 public:
        LibraryOptions() : fWeakImport(false), fReExport(false), fBundleLoader(false), 

-                                               fLazyLoad(false), fUpward(false), fForceLoad(false) {}
+                                               fLazyLoad(false), fUpward(false), fIndirectDylib(false), 
+                                               fForceLoad(false) {}

        // for dynamic libraries
        bool            fWeakImport;
        bool            fReExport;
        bool            fBundleLoader;
        bool            fLazyLoad;
        bool            fUpward;
        // for dynamic libraries
        bool            fWeakImport;
        bool            fReExport;
        bool            fBundleLoader;
        bool            fLazyLoad;
        bool            fUpward;

+       bool            fIndirectDylib;

        // for static libraries
        bool            fForceLoad;
 };
        // for static libraries
        bool            fForceLoad;
 };


@@ -80,15 +88,126 @@ public:
        enum CommonsMode { kCommonsIgnoreDylibs, kCommonsOverriddenByDylibs, kCommonsConflictsDylibsError };
        enum UUIDMode { kUUIDNone, kUUIDRandom, kUUIDContent };
        enum LocalSymbolHandling { kLocalSymbolsAll, kLocalSymbolsNone, kLocalSymbolsSelectiveInclude, kLocalSymbolsSelectiveExclude };
        enum CommonsMode { kCommonsIgnoreDylibs, kCommonsOverriddenByDylibs, kCommonsConflictsDylibsError };
        enum UUIDMode { kUUIDNone, kUUIDRandom, kUUIDContent };
        enum LocalSymbolHandling { kLocalSymbolsAll, kLocalSymbolsNone, kLocalSymbolsSelectiveInclude, kLocalSymbolsSelectiveExclude };

+       enum BitcodeMode { kBitcodeProcess, kBitcodeAsData, kBitcodeMarker, kBitcodeStrip };

        enum DebugInfoStripping { kDebugInfoNone, kDebugInfoMinimal, kDebugInfoFull };
        enum DebugInfoStripping { kDebugInfoNone, kDebugInfoMinimal, kDebugInfoFull };

+       enum UnalignedPointerTreatment { kUnalignedPointerError, kUnalignedPointerWarning, kUnalignedPointerIgnore };
+
+       static ld::Platform platformForLoadCommand(uint32_t lc, bool useSimulatorVariant) {
+               switch (lc) {
+                       case LC_VERSION_MIN_MACOSX:
+                               return ld::kPlatform_macOS;
+                       case LC_VERSION_MIN_IPHONEOS:
+                               return useSimulatorVariant ? ld::kPlatform_iOSSimulator : ld::kPlatform_iOS;
+                       case LC_VERSION_MIN_WATCHOS:
+                               return useSimulatorVariant ? ld::kPlatform_watchOSSimulator : ld::kPlatform_watchOS;
+                       case LC_VERSION_MIN_TVOS:
+                               return useSimulatorVariant ? ld::kPlatform_tvOSSimulator : ld::kPlatform_tvOS;
+               }
+               assert(!lc && "unknown LC_VERSION_MIN load command");
+               return ld::kPlatform_unknown;
+       }

 
 

-       struct FileInfo {
+       static const char* platformName(ld::Platform platform) {
+               switch (platform) {
+                       case ld::kPlatform_macOS:                               return "OSX";
+                       case ld::kPlatform_iOS:                                 return "iOS";
+                       case ld::kPlatform_iOSSimulator:                return "iOS Simulator";
+                       case ld::kPlatform_iOSMac:                              return "iOSMac";
+                       case ld::kPlatform_watchOS:                     return "watchOS";
+                       case ld::kPlatform_watchOSSimulator:    return "watchOS Simulator";
+                       case ld::kPlatform_tvOS:                                return "tvOS";
+                       case ld::kPlatform_tvOSSimulator:               return "tvOS Simulator";
+                       case ld::kPlatform_bridgeOS:                    return "bridgeOS";
+                       case ld::kPlatform_unknown:                             return "(unknown)";
+               }
+       }
+
+       static void userReadableSwiftVersion(uint8_t value, char versionString[64])
+       {
+               switch (value) {
+                       case 1:
+                               strcpy(versionString, "1.0");
+                               break;
+                       case 2:
+                               strcpy(versionString, "1.1");
+                               break;
+                       case 3:
+                               strcpy(versionString, "2.0");
+                               break;
+                       case 4:
+                               strcpy(versionString, "3.0");
+                               break;
+                       case 5:
+                               strcpy(versionString, "4.0");
+                               break;
+                       default:
+                               sprintf(versionString, "unknown ABI version 0x%02X", value);
+               }
+       }
+
+
+       class FileInfo {
+    public:

                const char*                             path;
                const char*                             path;

-               uint64_t                                fileLen;

                time_t                                  modTime;
                LibraryOptions                  options;
                time_t                                  modTime;
                LibraryOptions                  options;

+               ld::File::Ordinal               ordinal;
+               bool                                    fromFileList;
+               bool                                    isInlined;
+
+               // These are used by the threaded input file parsing engine.
+               mutable int                             inputFileSlot;  // The input file "slot" assigned to this particular file
+               bool                                    readyToParse;
+
+        // The use pattern for FileInfo is to create one on the stack in a leaf function and return
+        // it to the calling frame by copy. Therefore the copy constructor steals the path string from
+        // the source, which dies with the stack frame.
+        FileInfo(FileInfo const &other) : path(other.path), modTime(other.modTime), options(other.options), ordinal(other.ordinal), fromFileList(other.fromFileList), isInlined(other.isInlined), inputFileSlot(-1) { ((FileInfo&)other).path = NULL; };
+
+               FileInfo &operator=(FileInfo other) {
+                       std::swap(path, other.path);
+                       std::swap(modTime, other.modTime);
+                       std::swap(options, other.options);
+                       std::swap(ordinal, other.ordinal);
+                       std::swap(fromFileList, other.fromFileList);
+                       std::swap(isInlined, other.isInlined);
+                       std::swap(inputFileSlot, other.inputFileSlot);
+                       std::swap(readyToParse, other.readyToParse);
+                       return *this;
+               }
+
+        // Create an empty FileInfo. The path can be set implicitly by checkFileExists().
+        FileInfo() : path(NULL), modTime(-1), options(), fromFileList(false), isInlined(false) {};
+        
+        // Create a FileInfo for a specific path, but does not stat the file.
+        FileInfo(const char *_path) : path(strdup(_path)), modTime(-1), options(), fromFileList(false), isInlined(false) {};
+
+        ~FileInfo() { if (path) ::free((void*)path); }
+        
+        // Stat the file and update fileLen and modTime.
+        // If the object already has a path the p must be NULL.
+        // If the object does not have a path then p can be any candidate path, and if the file exists the object permanently remembers the path.
+        // Returns true if the file exists, false if not.
+        bool checkFileExists(const Options& options, const char *p=NULL);
+        
+        // Returns true if a previous call to checkFileExists() succeeded.
+        // Returns false if the file does not exist of checkFileExists() has never been called.
+        bool missing() const { return modTime == -1; }

        };
 
        };
 

+       class TAPIInterface {
+       public:
+               TAPIInterface(tapi::LinkerInterfaceFile* file, const char* path, const char *installName) :
+                       _file(file), _tbdPath(path), _installName(installName) {}
+               tapi::LinkerInterfaceFile* getInterfaceFile() const { return _file; }
+               std::string getTAPIFilePath() const { return _tbdPath; }
+               const std::string &getInstallName() const { return _installName; }
+       private:
+               tapi::LinkerInterfaceFile* _file;
+               std::string _tbdPath;
+               std::string _installName;
+       };
+       

        struct ExtraSection {
                const char*                             segmentName;
                const char*                             sectionName;
        struct ExtraSection {
                const char*                             segmentName;
                const char*                             sectionName;


@@ -105,6 +224,11 @@ public:
                uint8_t                                 alignment;
        };
 
                uint8_t                                 alignment;
        };
 

+       struct SectionOrderList {
+               const char*                                     segmentName;
+               std::vector<const char*>        sectionOrder;
+       };
+

        struct OrderedSymbol {
                const char*                             symbolName;
                const char*                             objectFileName;
        struct OrderedSymbol {
                const char*                             symbolName;
                const char*                             objectFileName;


@@ -137,6 +261,25 @@ public:
                const char*                     alias;
        };
 
                const char*                     alias;
        };
 

+       struct SectionRename {
+               const char*                     fromSegment;
+               const char*                     fromSection;
+               const char*                     toSegment;
+               const char*                     toSection;
+       };
+
+       struct SegmentRename {
+               const char*                     fromSegment;
+               const char*                     toSegment;
+       };
+
+       enum { depLinkerVersion=0x00, depObjectFile=0x10, depDirectDylib=0x10, depIndirectDylib=0x10, 
+                 depUpwardDirectDylib=0x10, depUpwardIndirectDylib=0x10, depArchive=0x10,
+                 depFileList=0x10, depSection=0x10, depBundleLoader=0x10, depMisc=0x10, depNotFound=0x11,
+                 depOutputFile = 0x40 };
+       
+       void                                            addDependency(uint8_t, const char* path) const;
+       

        typedef const char* const*      UndefinesIterator;
 
 //     const ObjectFile::ReaderOptions&        readerOptions();
        typedef const char* const*      UndefinesIterator;
 
 //     const ObjectFile::ReaderOptions&        readerOptions();


@@ -146,13 +289,16 @@ public:
        cpu_type_t                                      architecture() const { return fArchitecture; }
        bool                                            preferSubArchitecture() const { return fHasPreferredSubType; }
        cpu_subtype_t                           subArchitecture() const { return fSubArchitecture; }
        cpu_type_t                                      architecture() const { return fArchitecture; }
        bool                                            preferSubArchitecture() const { return fHasPreferredSubType; }
        cpu_subtype_t                           subArchitecture() const { return fSubArchitecture; }

+       cpu_type_t                  fallbackArchitecture() const { return fFallbackArchitecture; }
+       cpu_subtype_t                           fallbackSubArchitecture() const { return fFallbackSubArchitecture; }

        bool                                            allowSubArchitectureMismatches() const { return fAllowCpuSubtypeMismatches; }
        bool                                            allowSubArchitectureMismatches() const { return fAllowCpuSubtypeMismatches; }

+       bool                                            enforceDylibSubtypesMatch() const { return fEnforceDylibSubtypesMatch; }
+       bool                                            warnOnSwiftABIVersionMismatches() const { return fWarnOnSwiftABIVersionMismatches; }

        bool                                            forceCpuSubtypeAll() const { return fForceSubtypeAll; }
        const char*                                     architectureName() const { return fArchitectureName; }
        bool                                            forceCpuSubtypeAll() const { return fForceSubtypeAll; }
        const char*                                     architectureName() const { return fArchitectureName; }

-       void                                            setArchitecture(cpu_type_t, cpu_subtype_t subtype);
+       void                                            setArchitecture(cpu_type_t, cpu_subtype_t subtype, ld::Platform platform, uint32_t minOsVers);

        bool                                            archSupportsThumb2() const { return fArchSupportsThumb2; }
        OutputKind                                      outputKind() const { return fOutputKind; }
        bool                                            archSupportsThumb2() const { return fArchSupportsThumb2; }
        OutputKind                                      outputKind() const { return fOutputKind; }

-       bool                                            prebind() const { return fPrebind; }

        bool                                            bindAtLoad() const { return fBindAtLoad; }
        NameSpace                                       nameSpace() const { return fNameSpace; }
        const char*                                     installPath() const;                    // only for kDynamicLibrary
        bool                                            bindAtLoad() const { return fBindAtLoad; }
        NameSpace                                       nameSpace() const { return fNameSpace; }
        const char*                                     installPath() const;                    // only for kDynamicLibrary


@@ -164,7 +310,6 @@ public:
        uint64_t                                        baseAddress() const { return fBaseAddress; }
        uint64_t                                        maxAddress() const { return fMaxAddress; }
        bool                                            keepPrivateExterns() const { return fKeepPrivateExterns; }              // only for kObjectFile
        uint64_t                                        baseAddress() const { return fBaseAddress; }
        uint64_t                                        maxAddress() const { return fMaxAddress; }
        bool                                            keepPrivateExterns() const { return fKeepPrivateExterns; }              // only for kObjectFile

-       bool                                            needsModuleTable() const { return fNeedsModuleTable; }                  // only for kDynamicLibrary

        bool                                            interposable(const char* name) const;
        bool                                            hasExportRestrictList() const { return (fExportMode != kExportDefault); }       // -exported_symbol or -unexported_symbol
        bool                                            hasExportMaskList() const { return (fExportMode == kExportSome); }              // just -exported_symbol
        bool                                            interposable(const char* name) const;
        bool                                            hasExportRestrictList() const { return (fExportMode != kExportDefault); }       // -exported_symbol or -unexported_symbol
        bool                                            hasExportMaskList() const { return (fExportMode == kExportSome); }              // just -exported_symbol


@@ -174,14 +319,14 @@ public:
        bool                                            allGlobalsAreDeadStripRoots() const;
        bool                                            shouldExport(const char*) const;
        bool                                            shouldReExport(const char*) const;
        bool                                            allGlobalsAreDeadStripRoots() const;
        bool                                            shouldExport(const char*) const;
        bool                                            shouldReExport(const char*) const;

+       std::vector<const char*>        exportsData() const;

        bool                                            ignoreOtherArchInputFiles() const { return fIgnoreOtherArchFiles; }
        bool                                            traceDylibs() const     { return fTraceDylibs; }
        bool                                            traceArchives() const { return fTraceArchives; }
        bool                                            ignoreOtherArchInputFiles() const { return fIgnoreOtherArchFiles; }
        bool                                            traceDylibs() const     { return fTraceDylibs; }
        bool                                            traceArchives() const { return fTraceArchives; }

+       bool                                            traceEmitJSON() const { return fTraceEmitJSON; }

        bool                                            deadCodeStrip() const   { return fDeadStrip; }
        UndefinedTreatment                      undefinedTreatment() const { return fUndefinedTreatment; }
        bool                                            deadCodeStrip() const   { return fDeadStrip; }
        UndefinedTreatment                      undefinedTreatment() const { return fUndefinedTreatment; }

-       ld::MacVersionMin                       macosxVersionMin() const { return fMacVersionMin; }
-       ld::IOSVersionMin                       iOSVersionMin() const { return fIOSVersionMin; }
-       bool                                            minOS(ld::MacVersionMin mac, ld::IOSVersionMin iPhoneOS);
+       uint32_t                                        minOSversion(const ld::Platform& platform) const;

        bool                                            messagesPrefixedWithArchitecture();
        Treatment                                       picTreatment();
        WeakReferenceMismatchTreatment  weakReferenceMismatchTreatment() const { return fWeakReferenceMismatchTreatment; }
        bool                                            messagesPrefixedWithArchitecture();
        Treatment                                       picTreatment();
        WeakReferenceMismatchTreatment  weakReferenceMismatchTreatment() const { return fWeakReferenceMismatchTreatment; }


@@ -198,6 +343,7 @@ public:
        bool                                            hasNonExecutableHeap() const { return fNonExecutableHeap; }
        UndefinesIterator                       initialUndefinesBegin() const { return &fInitialUndefines[0]; }
        UndefinesIterator                       initialUndefinesEnd() const { return &fInitialUndefines[fInitialUndefines.size()]; }
        bool                                            hasNonExecutableHeap() const { return fNonExecutableHeap; }
        UndefinesIterator                       initialUndefinesBegin() const { return &fInitialUndefines[0]; }
        UndefinesIterator                       initialUndefinesEnd() const { return &fInitialUndefines[fInitialUndefines.size()]; }

+       const std::vector<const char*>& initialUndefines() const { return fInitialUndefines; }

        bool                                            printWhyLive(const char* name) const;
        uint32_t                                        minimumHeaderPad() const { return fMinimumHeaderPad; }
        bool                                            maxMminimumHeaderPad() const { return fMaxMinimumHeaderPad; }
        bool                                            printWhyLive(const char* name) const;
        uint32_t                                        minimumHeaderPad() const { return fMinimumHeaderPad; }
        bool                                            maxMminimumHeaderPad() const { return fMaxMinimumHeaderPad; }


@@ -206,7 +352,10 @@ public:
        CommonsMode                                     commonsMode() const { return fCommonsMode; }
        bool                                            warnCommons() const { return fWarnCommons; }
        bool                                            keepRelocations();
        CommonsMode                                     commonsMode() const { return fCommonsMode; }
        bool                                            warnCommons() const { return fWarnCommons; }
        bool                                            keepRelocations();

-       FileInfo                                        findFile(const char* path) const;
+       FileInfo                                        findFile(const std::string &path, const ld::dylib::File* fromDylib=nullptr) const;
+       bool                                            findFile(const std::string &path, const std::vector<std::string> &tbdExtensions, FileInfo& result) const;
+       bool                                            hasInlinedTAPIFile(const std::string &path) const;
+       tapi::LinkerInterfaceFile*      findTAPIFile(const std::string &path) const;

        UUIDMode                                        UUIDMode() const { return fUUIDMode; }
        bool                                            warnStabs();
        bool                                            pauseAtEnd() { return fPause; }
        UUIDMode                                        UUIDMode() const { return fUUIDMode; }
        bool                                            warnStabs();
        bool                                            pauseAtEnd() { return fPause; }


@@ -220,7 +369,6 @@ public:
        unsigned long                           orderedSymbolsCount() const { return fOrderedSymbols.size(); }
        OrderedSymbolsIterator          orderedSymbolsBegin() const { return &fOrderedSymbols[0]; }
        OrderedSymbolsIterator          orderedSymbolsEnd() const { return &fOrderedSymbols[fOrderedSymbols.size()]; }
        unsigned long                           orderedSymbolsCount() const { return fOrderedSymbols.size(); }
        OrderedSymbolsIterator          orderedSymbolsBegin() const { return &fOrderedSymbols[0]; }
        OrderedSymbolsIterator          orderedSymbolsEnd() const { return &fOrderedSymbols[fOrderedSymbols.size()]; }

-       bool                                            splitSeg() const { return fSplitSegs; }

        uint64_t                                        baseWritableAddress() { return fBaseWritableAddress; }
        uint64_t                                        segmentAlignment() const { return fSegmentAlignment; }
        uint64_t                                        segPageSize(const char* segName) const;
        uint64_t                                        baseWritableAddress() { return fBaseWritableAddress; }
        uint64_t                                        segmentAlignment() const { return fSegmentAlignment; }
        uint64_t                                        segPageSize(const char* segName) const;


@@ -236,7 +384,7 @@ public:
        const std::vector<DylibOverride>&       dylibOverrides() const { return fDylibOverrides; }
        const char*                                     generatedMapPath() const { return fMapPath; }
        bool                                            positionIndependentExecutable() const { return fPositionIndependentExecutable; }
        const std::vector<DylibOverride>&       dylibOverrides() const { return fDylibOverrides; }
        const char*                                     generatedMapPath() const { return fMapPath; }
        bool                                            positionIndependentExecutable() const { return fPositionIndependentExecutable; }

-       Options::FileInfo                       findFileUsingPaths(const char* path) const;
+       Options::FileInfo                       findIndirectDylib(const std::string& installName, const ld::dylib::File* fromDylib) const;

        bool                                            deadStripDylibs() const { return fDeadStripDylibs; }
        bool                                            allowedUndefined(const char* name) const { return ( fAllowedUndefined.find(name) != fAllowedUndefined.end() ); }
        bool                                            someAllowedUndefines() const { return (fAllowedUndefined.size() != 0); }
        bool                                            deadStripDylibs() const { return fDeadStripDylibs; }
        bool                                            allowedUndefined(const char* name) const { return ( fAllowedUndefined.find(name) != fAllowedUndefined.end() ); }
        bool                                            someAllowedUndefines() const { return (fAllowedUndefined.size() != 0); }


@@ -244,13 +392,19 @@ public:
        bool                                            keepLocalSymbol(const char* symbolName) const;
        bool                                            allowTextRelocs() const { return fAllowTextRelocs; }
        bool                                            warnAboutTextRelocs() const { return fWarnTextRelocs; }
        bool                                            keepLocalSymbol(const char* symbolName) const;
        bool                                            allowTextRelocs() const { return fAllowTextRelocs; }
        bool                                            warnAboutTextRelocs() const { return fWarnTextRelocs; }

+       bool                                            kextsUseStubs() const { return fKextsUseStubs; }

        bool                                            usingLazyDylibLinking() const { return fUsingLazyDylibLinking; }
        bool                                            verbose() const { return fVerbose; }
        bool                                            makeEncryptable() const { return fEncryptable; }
        bool                                            needsUnwindInfoSection() const { return fAddCompactUnwindEncoding; }
        const std::vector<const char*>& llvmOptions() const{ return fLLVMOptions; }
        bool                                            usingLazyDylibLinking() const { return fUsingLazyDylibLinking; }
        bool                                            verbose() const { return fVerbose; }
        bool                                            makeEncryptable() const { return fEncryptable; }
        bool                                            needsUnwindInfoSection() const { return fAddCompactUnwindEncoding; }
        const std::vector<const char*>& llvmOptions() const{ return fLLVMOptions; }

+       const std::vector<const char*>& segmentOrder() const{ return fSegmentOrder; }
+       bool                                            segmentOrderAfterFixedAddressSegment(const char* segName) const;
+       const std::vector<const char*>* sectionOrder(const char* segName) const;

        const std::vector<const char*>& dyldEnvironExtras() const{ return fDyldEnvironExtras; }
        const std::vector<const char*>& dyldEnvironExtras() const{ return fDyldEnvironExtras; }

+       const std::vector<const char*>& astFilePaths() const{ return fASTFilePaths; }

        bool                                            makeCompressedDyldInfo() const { return fMakeCompressedDyldInfo; }
        bool                                            makeCompressedDyldInfo() const { return fMakeCompressedDyldInfo; }

+       bool                                            makeThreadedStartsSection() const { return fMakeThreadedStartsSection; }

        bool                                            hasExportedSymbolOrder();
        bool                                            exportedSymbolOrder(const char* sym, unsigned int* order) const;
        bool                                            orderData() { return fOrderData; }
        bool                                            hasExportedSymbolOrder();
        bool                                            exportedSymbolOrder(const char* sym, unsigned int* order) const;
        bool                                            orderData() { return fOrderData; }


@@ -278,32 +432,112 @@ public:
        bool                                            makeTentativeDefinitionsReal() const { return fMakeTentativeDefinitionsReal; }
        const char*                                     dyldInstallPath() const { return fDyldInstallPath; }
        bool                                            warnWeakExports() const { return fWarnWeakExports; }
        bool                                            makeTentativeDefinitionsReal() const { return fMakeTentativeDefinitionsReal; }
        const char*                                     dyldInstallPath() const { return fDyldInstallPath; }
        bool                                            warnWeakExports() const { return fWarnWeakExports; }

+       bool                                            noWeakExports() const { return fNoWeakExports; }

        bool                                            objcGcCompaction() const { return fObjcGcCompaction; }
        bool                                            objcGc() const { return fObjCGc; }
        bool                                            objcGcOnly() const { return fObjCGcOnly; }
        bool                                            canUseThreadLocalVariables() const { return fTLVSupport; }
        bool                                            objcGcCompaction() const { return fObjcGcCompaction; }
        bool                                            objcGc() const { return fObjCGc; }
        bool                                            objcGcOnly() const { return fObjCGcOnly; }
        bool                                            canUseThreadLocalVariables() const { return fTLVSupport; }

-       bool                                            demangleSymbols() const { return fDemangle; }
-       bool                                            addVersionLoadCommand() const { return fVersionLoadCommand; }
+       bool                                            addVersionLoadCommand() const { return fVersionLoadCommand && (platforms().count() != 0); }

        bool                                            addFunctionStarts() const { return fFunctionStartsLoadCommand; }
        bool                                            addFunctionStarts() const { return fFunctionStartsLoadCommand; }

+       bool                                            addDataInCodeInfo() const { return fDataInCodeInfoLoadCommand; }

        bool                                            canReExportSymbols() const { return fCanReExportSymbols; }
        bool                                            canReExportSymbols() const { return fCanReExportSymbols; }

+       const char*                                     ltoCachePath() const { return fLtoCachePath; }
+       bool                                            ltoPruneIntervalOverwrite() const { return fLtoPruneIntervalOverwrite; }
+       int                                                     ltoPruneInterval() const { return fLtoPruneInterval; }
+       int                                                     ltoPruneAfter() const { return fLtoPruneAfter; }
+       unsigned                                        ltoMaxCacheSize() const { return fLtoMaxCacheSize; }

        const char*                                     tempLtoObjectPath() const { return fTempLtoObjectPath; }
        const char*                                     tempLtoObjectPath() const { return fTempLtoObjectPath; }

+       const char*                                     overridePathlibLTO() const { return fOverridePathlibLTO; }
+       const char*                                     mcpuLTO() const { return fLtoCpu; }
+       const char*                                     kextObjectsPath() const { return fKextObjectsDirPath; }
+       int                                                     kextObjectsEnable() const { return fKextObjectsEnable; }
+       const char*                                     toolchainPath() const { return fToolchainPath; }

        bool                                            objcCategoryMerging() const { return fObjcCategoryMerging; }
        bool                                            pageAlignDataAtoms() const { return fPageAlignDataAtoms; }
        bool                                            objcCategoryMerging() const { return fObjcCategoryMerging; }
        bool                                            pageAlignDataAtoms() const { return fPageAlignDataAtoms; }

+       bool                                            keepDwarfUnwind() const { return fKeepDwarfUnwind; }
+       bool                                            verboseOptimizationHints() const { return fVerboseOptimizationHints; }
+       bool                                            ignoreOptimizationHints() const { return fIgnoreOptimizationHints; }
+       bool                                            generateDtraceDOF() const { return fGenerateDtraceDOF; }
+       bool                                            allowBranchIslands() const { return fAllowBranchIslands; }
+       bool                                            traceSymbolLayout() const { return fTraceSymbolLayout; }
+       bool                                            markAppExtensionSafe() const { return fMarkAppExtensionSafe; }
+       bool                                            checkDylibsAreAppExtensionSafe() const { return fCheckAppExtensionSafe; }
+       bool                                            forceLoadSwiftLibs() const { return fForceLoadSwiftLibs; }
+       bool                                            bundleBitcode() const { return fBundleBitcode; }
+       bool                                            hideSymbols() const { return fHideSymbols; }
+       bool                                            verifyBitcode() const { return fVerifyBitcode; }
+       bool                                            renameReverseSymbolMap() const { return fReverseMapUUIDRename; }
+       bool                                            deduplicateFunctions() const { return fDeDupe; }
+       bool                                            verboseDeduplicate() const { return fVerboseDeDupe; }
+       bool                                            useLinkedListBinding() const { return fUseLinkedListBinding; }
+#if SUPPORT_ARCH_arm64e
+       bool                                            useAuthenticatedStubs() const { return fUseAuthenticatedStubs; }
+       bool                                            supportsAuthenticatedPointers() const { return fSupportsAuthenticatedPointers; }
+#endif
+       bool                                            noLazyBinding() const { return fNoLazyBinding; }
+       bool                                            debugVariant() const { return fDebugVariant; }
+       const char*                                     reverseSymbolMapPath() const { return fReverseMapPath; }
+       std::string                                     reverseMapTempPath() const { return fReverseMapTempPath; }
+       bool                                            ltoCodegenOnly() const { return fLTOCodegenOnly; }
+       bool                                            ignoreAutoLink() const { return fIgnoreAutoLink; }
+       bool                                            allowDeadDuplicates() const { return fAllowDeadDups; }
+       bool                                            allowWeakImports() const { return fAllowWeakImports; }
+       Treatment                                       initializersTreatment() const { return fInitializersTreatment; }
+       BitcodeMode                                     bitcodeKind() const { return fBitcodeKind; }
+       bool                                            sharedRegionEncodingV2() const { return fSharedRegionEncodingV2; }
+       bool                                            useDataConstSegment() const { return fUseDataConstSegment; }
+       bool                                            useTextExecSegment() const { return fUseTextExecSegment; }

        bool                                            hasWeakBitTweaks() const;
        bool                                            forceWeak(const char* symbolName) const;
        bool                                            forceNotWeak(const char* symbolName) const;
        bool                                            forceWeakNonWildCard(const char* symbolName) const;
        bool                                            forceNotWeakNonWildcard(const char* symbolName) const;
        bool                                            hasWeakBitTweaks() const;
        bool                                            forceWeak(const char* symbolName) const;
        bool                                            forceNotWeak(const char* symbolName) const;
        bool                                            forceWeakNonWildCard(const char* symbolName) const;
        bool                                            forceNotWeakNonWildcard(const char* symbolName) const;

+       bool                                            forceCoalesce(const char* symbolName) const;
+    Snapshot&                   snapshot() const { return fLinkSnapshot; }

        bool                                            errorBecauseOfWarnings() const;
        bool                                            errorBecauseOfWarnings() const;

+       bool                                            needsThreadLoadCommand() const { return fNeedsThreadLoadCommand; }
+       bool                                            needsEntryPointLoadCommand() const { return fEntryPointLoadCommand; }
+       bool                                            needsSourceVersionLoadCommand() const { return fSourceVersionLoadCommand; }
+       bool                                            canUseAbsoluteSymbols() const { return fAbsoluteSymbols; }
+       bool                                            allowSimulatorToLinkWithMacOSX() const { return fAllowSimulatorToLinkWithMacOSX; }
+       uint64_t                                        sourceVersion() const { return fSourceVersion; }
+       uint32_t                                        sdkVersion() const { return fSDKVersion; }
+       const char*                                     demangleSymbol(const char* sym) const;
+    bool                                               pipelineEnabled() const { return fPipelineFifo != NULL; }
+    const char*                                        pipelineFifo() const { return fPipelineFifo; }
+       bool                                            dumpDependencyInfo() const { return (fDependencyInfoPath != NULL); }
+       const char*                                     dependencyInfoPath() const { return fDependencyInfoPath; }
+       bool                                            targetIOSSimulator() const { return platforms().contains(ld::simulatorPlatforms); }
+       ld::relocatable::File::LinkerOptionsList&
+                                                               linkerOptions() const { return fLinkerOptions; }
+       FileInfo                                        findFramework(const char* frameworkName) const;
+       FileInfo                                        findLibrary(const char* rootName, bool dylibsOnly=false) const;
+       bool                                            armUsesZeroCostExceptions() const;
+       const std::vector<SectionRename>& sectionRenames() const { return fSectionRenames; }
+       const std::vector<SegmentRename>& segmentRenames() const { return fSegmentRenames; }
+       bool                                            moveRoSymbol(const char* symName, const char* filePath, const char*& seg, bool& wildCardMatch) const;
+       bool                                            moveRwSymbol(const char* symName, const char* filePath, const char*& seg, bool& wildCardMatch) const;
+       bool                                            moveAXMethodList(const char* className) const;
+       const ld::VersionSet&           platforms() const { return fPlatforms; }
+       const std::vector<const char*>& sdkPaths() const { return fSDKPaths; }
+       std::vector<std::string>        writeBitcodeLinkOptions() const;
+       std::string                                     getSDKVersionStr() const;
+       uint8_t                                         maxDefaultCommonAlign() const { return fMaxDefaultCommonAlign; }
+       bool                                            hasDataSymbolMoves() const { return !fSymbolsMovesData.empty(); }
+       bool                                            hasCodeSymbolMoves() const { return !fSymbolsMovesCode.empty(); }
+       void                                            writeToTraceFile(const char* buffer, size_t len) const;
+       UnalignedPointerTreatment       unalignedPointerTreatment() const { return fUnalignedPointerTreatment; }
+       bool                                            zeroModTimeInDebugMap() const { return fZeroModTimeInDebugMap; }
+       void                                            writeDependencyInfo() const;
+       std::vector<TAPIInterface>      &TAPIFiles() { return fTAPIFiles; }
+       void                                            addTAPIInterface(tapi::LinkerInterfaceFile* interface, const char *path) const;
+       const char*                                     buildContextName() const { return fBuildContextName; }
+
+       static uint32_t                         parseVersionNumber32(const char*);

 
 private:
 
 private:

-       class CStringEquals
-       {
-       public:
-               bool operator()(const char* left, const char* right) const { return (strcmp(left, right) == 0); }
-       };
-       typedef __gnu_cxx::hash_map<const char*, unsigned int, __gnu_cxx::hash<const char*>, CStringEquals> NameToOrder;
-       typedef __gnu_cxx::hash_set<const char*, __gnu_cxx::hash<const char*>, CStringEquals>  NameSet;
+       typedef std::unordered_map<const char*, unsigned int, ld::CStringHash, ld::CStringEquals> NameToOrder;
+       typedef std::unordered_set<const char*, ld::CStringHash, ld::CStringEquals>  NameSet;

        enum ExportMode { kExportDefault, kExportSome, kDontExportSome };
        enum LibrarySearchMode { kSearchDylibAndArchiveInEachDir, kSearchAllDirsForDylibsThenAllDirsForArchives };
        enum InterposeMode { kInterposeNone, kInterposeAllExternal, kInterposeSome };
        enum ExportMode { kExportDefault, kExportSome, kDontExportSome };
        enum LibrarySearchMode { kSearchDylibAndArchiveInEachDir, kSearchAllDirsForDylibsThenAllDirsForArchives };
        enum InterposeMode { kInterposeNone, kInterposeAllExternal, kInterposeSome };


@@ -311,13 +545,15 @@ private:
        class SetWithWildcards {
        public:
                void                                    insert(const char*);
        class SetWithWildcards {
        public:
                void                                    insert(const char*);

-               bool                                    contains(const char*) const;
+               bool                                    contains(const char*, bool* wildCardMatch=NULL) const;
+               bool                                    containsWithPrefix(const char* symbol, const char* file, bool& wildCardMatch) const;

                bool                                    containsNonWildcard(const char*) const;
                bool                                    empty() const                   { return fRegular.empty() && fWildCard.empty(); }
                bool                                    hasWildCards() const    { return !fWildCard.empty(); }
                NameSet::iterator               regularBegin() const    { return fRegular.begin(); }
                NameSet::iterator               regularEnd() const              { return fRegular.end(); }
                void                                    remove(const NameSet&); 
                bool                                    containsNonWildcard(const char*) const;
                bool                                    empty() const                   { return fRegular.empty() && fWildCard.empty(); }
                bool                                    hasWildCards() const    { return !fWildCard.empty(); }
                NameSet::iterator               regularBegin() const    { return fRegular.begin(); }
                NameSet::iterator               regularEnd() const              { return fRegular.end(); }
                void                                    remove(const NameSet&); 

+               std::vector<const char*>                data() const;

        private:
                static bool                             hasWildCards(const char*);
                bool                                    wildCardMatch(const char* pattern, const char* candidate) const;
        private:
                static bool                             hasWildCards(const char*);
                bool                                    wildCardMatch(const char* pattern, const char* candidate) const;


@@ -327,31 +563,42 @@ private:
                std::vector<const char*>                fWildCard;
        };
 
                std::vector<const char*>                fWildCard;
        };
 

+       struct SymbolsMove {
+               const char*                     toSegment;
+               SetWithWildcards        symbols;
+       };
+
+       struct DependencyEntry {
+               uint8_t                         opcode;
+               std::string                     path;
+       };

 
 

+       const char*                                     checkForNullArgument(const char* argument_name, const char* arg) const;
+       const char*                                     checkForNullVersionArgument(const char* argument_name, const char* arg) const;

        void                                            parse(int argc, const char* argv[]);
        void                                            checkIllegalOptionCombinations();
        void                                            buildSearchPaths(int argc, const char* argv[]);
        void                                            parseArch(const char* architecture);
        void                                            parse(int argc, const char* argv[]);
        void                                            checkIllegalOptionCombinations();
        void                                            buildSearchPaths(int argc, const char* argv[]);
        void                                            parseArch(const char* architecture);

-       FileInfo                                        findLibrary(const char* rootName, bool dylibsOnly=false);
-       FileInfo                                        findFramework(const char* frameworkName);
-       FileInfo                                        findFramework(const char* rootName, const char* suffix);
+       void                                            selectFallbackArch(const char *architecture);
+       FileInfo                                        findFramework(const char* rootName, const char* suffix) const;

        bool                                            checkForFile(const char* format, const char* dir, const char* rootName,
                                                                                         FileInfo& result) const;
        uint64_t                                        parseVersionNumber64(const char*);
        bool                                            checkForFile(const char* format, const char* dir, const char* rootName,
                                                                                         FileInfo& result) const;
        uint64_t                                        parseVersionNumber64(const char*);

-       uint32_t                                        parseVersionNumber32(const char*);
+       std::string                                     getVersionString32(uint32_t ver) const;
+       std::string                                     getVersionString64(uint64_t ver) const;
+       bool                                            parsePackedVersion32(const std::string& versionStr, uint32_t &result);

        void                                            parseSectionOrderFile(const char* segment, const char* section, const char* path);
        void                                            parseOrderFile(const char* path, bool cstring);
        void                                            addSection(const char* segment, const char* section, const char* path);
        void                                            addSubLibrary(const char* name);
        void                                            parseSectionOrderFile(const char* segment, const char* section, const char* path);
        void                                            parseOrderFile(const char* path, bool cstring);
        void                                            addSection(const char* segment, const char* section, const char* path);
        void                                            addSubLibrary(const char* name);

-       void                                            loadFileList(const char* fileOfPaths);
+       void                                            loadFileList(const char* fileOfPaths, ld::File::Ordinal baseOrdinal);

        uint64_t                                        parseAddress(const char* addr);
        void                                            loadExportFile(const char* fileOfExports, const char* option, SetWithWildcards& set);
        void                                            parseAliasFile(const char* fileOfAliases);
        void                                            parsePreCommandLineEnvironmentSettings();
        void                                            parsePostCommandLineEnvironmentSettings();
        void                                            setUndefinedTreatment(const char* treatment);
        uint64_t                                        parseAddress(const char* addr);
        void                                            loadExportFile(const char* fileOfExports, const char* option, SetWithWildcards& set);
        void                                            parseAliasFile(const char* fileOfAliases);
        void                                            parsePreCommandLineEnvironmentSettings();
        void                                            parsePostCommandLineEnvironmentSettings();
        void                                            setUndefinedTreatment(const char* treatment);

-       void                                            setMacOSXVersionMin(const char* version);
-       void                                            setIOSVersionMin(const char* version);
+       void                                            setVersionMin(const ld::Platform& platform, const char *version);

        void                                            setWeakReferenceMismatchTreatment(const char* treatment);
        void                                            addDylibOverride(const char* paths);
        void                                            addSectionAlignment(const char* segment, const char* section, const char* alignment);
        void                                            setWeakReferenceMismatchTreatment(const char* treatment);
        void                                            addDylibOverride(const char* paths);
        void                                            addSectionAlignment(const char* segment, const char* section, const char* alignment);


@@ -364,7 +611,10 @@ private:
        void                                            warnObsolete(const char* arg);
        uint32_t                                        parseProtection(const char* prot);
        void                                            loadSymbolOrderFile(const char* fileOfExports, NameToOrder& orderMapping);
        void                                            warnObsolete(const char* arg);
        uint32_t                                        parseProtection(const char* prot);
        void                                            loadSymbolOrderFile(const char* fileOfExports, NameToOrder& orderMapping);

-
+       void                                            addSectionRename(const char* srcSegment, const char* srcSection, const char* dstSegment, const char* dstSection);
+       void                                            addSegmentRename(const char* srcSegment, const char* dstSegment);
+       void                                            addSymbolMove(const char* dstSegment, const char* symbolList, std::vector<SymbolsMove>& list, const char* optionName);
+       void                                            cannotBeUsedWithBitcode(const char* arg);

 
 
 //     ObjectFile::ReaderOptions                       fReaderOptions;
 
 
 //     ObjectFile::ReaderOptions                       fReaderOptions;


@@ -372,14 +622,14 @@ private:
        std::vector<Options::FileInfo>          fInputFiles;
        cpu_type_t                                                      fArchitecture;
        cpu_subtype_t                                           fSubArchitecture;
        std::vector<Options::FileInfo>          fInputFiles;
        cpu_type_t                                                      fArchitecture;
        cpu_subtype_t                                           fSubArchitecture;

+       cpu_type_t                                                      fFallbackArchitecture;
+       cpu_subtype_t                                           fFallbackSubArchitecture;

        const char*                                                     fArchitectureName;
        OutputKind                                                      fOutputKind;
        bool                                                            fHasPreferredSubType;
        bool                                                            fArchSupportsThumb2;
        const char*                                                     fArchitectureName;
        OutputKind                                                      fOutputKind;
        bool                                                            fHasPreferredSubType;
        bool                                                            fArchSupportsThumb2;

-       bool                                                            fPrebind;

        bool                                                            fBindAtLoad;
        bool                                                            fKeepPrivateExterns;
        bool                                                            fBindAtLoad;
        bool                                                            fKeepPrivateExterns;

-       bool                                                            fNeedsModuleTable;

        bool                                                            fIgnoreOtherArchFiles;
        bool                                                            fErrorOnOtherArchFiles;
        bool                                                            fForceSubtypeAll;
        bool                                                            fIgnoreOtherArchFiles;
        bool                                                            fErrorOnOtherArchFiles;
        bool                                                            fForceSubtypeAll;


@@ -394,13 +644,13 @@ private:
        uint64_t                                                        fBaseAddress;
        uint64_t                                                        fMaxAddress;
        uint64_t                                                        fBaseWritableAddress;
        uint64_t                                                        fBaseAddress;
        uint64_t                                                        fMaxAddress;
        uint64_t                                                        fBaseWritableAddress;

-       bool                                                            fSplitSegs;

        SetWithWildcards                                        fExportSymbols;
        SetWithWildcards                                        fDontExportSymbols;
        SetWithWildcards                                        fInterposeList;
        SetWithWildcards                                        fForceWeakSymbols;
        SetWithWildcards                                        fForceNotWeakSymbols;
        SetWithWildcards                                        fReExportSymbols;
        SetWithWildcards                                        fExportSymbols;
        SetWithWildcards                                        fDontExportSymbols;
        SetWithWildcards                                        fInterposeList;
        SetWithWildcards                                        fForceWeakSymbols;
        SetWithWildcards                                        fForceNotWeakSymbols;
        SetWithWildcards                                        fReExportSymbols;

+       SetWithWildcards                                        fForceCoalesceSymbols;

        NameSet                                                         fRemovedExports;
        NameToOrder                                                     fExportSymbolsOrder;
        ExportMode                                                      fExportMode;
        NameSet                                                         fRemovedExports;
        NameToOrder                                                     fExportSymbolsOrder;
        ExportMode                                                      fExportMode;


@@ -419,13 +669,24 @@ private:
        const char*                                                     fExecutablePath;
        const char*                                                     fBundleLoader;
        const char*                                                     fDtraceScriptName;
        const char*                                                     fExecutablePath;
        const char*                                                     fBundleLoader;
        const char*                                                     fDtraceScriptName;

-       const char*                                                     fSegAddrTablePath;

        const char*                                                     fMapPath;
        const char*                                                     fDyldInstallPath;
        const char*                                                     fMapPath;
        const char*                                                     fDyldInstallPath;

+       const char*                                                     fLtoCachePath;
+       bool                                                            fLtoPruneIntervalOverwrite;
+       int                                                                     fLtoPruneInterval;
+       int                                                                     fLtoPruneAfter;
+       unsigned                                                        fLtoMaxCacheSize;

        const char*                                                     fTempLtoObjectPath;
        const char*                                                     fTempLtoObjectPath;

+       const char*                                                     fOverridePathlibLTO;
+       const char*                                                     fLtoCpu;
+       int                                                             fKextObjectsEnable;
+       const char*                                                     fKextObjectsDirPath;
+       const char*                                                     fToolchainPath;

        uint64_t                                                        fZeroPageSize;
        uint64_t                                                        fStackSize;
        uint64_t                                                        fStackAddr;
        uint64_t                                                        fZeroPageSize;
        uint64_t                                                        fStackSize;
        uint64_t                                                        fStackAddr;

+       uint64_t                                                        fSourceVersion;
+       uint32_t                                                        fSDKVersion;

        bool                                                            fExecutableStack;
        bool                                                            fNonExecutableHeap;
        bool                                                            fDisableNonExecutableHeap;
        bool                                                            fExecutableStack;
        bool                                                            fNonExecutableHeap;
        bool                                                            fDisableNonExecutableHeap;


@@ -445,6 +706,7 @@ private:
        bool                                                            fStatistics;
        bool                                                            fPrintOptions;
        bool                                                            fSharedRegionEligible;
        bool                                                            fStatistics;
        bool                                                            fPrintOptions;
        bool                                                            fSharedRegionEligible;

+       bool                                                            fSharedRegionEligibleForceOff;

        bool                                                            fPrintOrderFileStatistics;
        bool                                                            fReadOnlyx86Stubs;
        bool                                                            fPositionIndependentExecutable;
        bool                                                            fPrintOrderFileStatistics;
        bool                                                            fReadOnlyx86Stubs;
        bool                                                            fPositionIndependentExecutable;


@@ -454,14 +716,20 @@ private:
        bool                                                            fDeadStripDylibs;
        bool                                                            fAllowTextRelocs;
        bool                                                            fWarnTextRelocs;
        bool                                                            fDeadStripDylibs;
        bool                                                            fAllowTextRelocs;
        bool                                                            fWarnTextRelocs;

+       bool                                                            fKextsUseStubs;

        bool                                                            fUsingLazyDylibLinking;
        bool                                                            fEncryptable;
        bool                                                            fUsingLazyDylibLinking;
        bool                                                            fEncryptable;

+       bool                                                            fEncryptableForceOn;
+       bool                                                            fEncryptableForceOff;

        bool                                                            fOrderData;
        bool                                                            fMarkDeadStrippableDylib;
        bool                                                            fMakeCompressedDyldInfo;
        bool                                                            fMakeCompressedDyldInfoForceOff;
        bool                                                            fOrderData;
        bool                                                            fMarkDeadStrippableDylib;
        bool                                                            fMakeCompressedDyldInfo;
        bool                                                            fMakeCompressedDyldInfoForceOff;

+       bool                                                            fMakeThreadedStartsSection;

        bool                                                            fNoEHLabels;
        bool                                                            fAllowCpuSubtypeMismatches;
        bool                                                            fNoEHLabels;
        bool                                                            fAllowCpuSubtypeMismatches;

+       bool                                                            fEnforceDylibSubtypesMatch;
+       bool                                                            fWarnOnSwiftABIVersionMismatches;

        bool                                                            fUseSimplifiedDylibReExports;
        bool                                                            fObjCABIVersion2Override;
        bool                                                            fObjCABIVersion1Override;
        bool                                                            fUseSimplifiedDylibReExports;
        bool                                                            fObjCABIVersion2Override;
        bool                                                            fObjCABIVersion1Override;


@@ -489,8 +757,10 @@ private:
        bool                                                            fTraceDylibs;
        bool                                                            fTraceIndirectDylibs;
        bool                                                            fTraceArchives;
        bool                                                            fTraceDylibs;
        bool                                                            fTraceIndirectDylibs;
        bool                                                            fTraceArchives;

+       bool                                                            fTraceEmitJSON;

        bool                                                            fOutputSlidable;
        bool                                                            fWarnWeakExports;
        bool                                                            fOutputSlidable;
        bool                                                            fWarnWeakExports;

+       bool                                                            fNoWeakExports;

        bool                                                            fObjcGcCompaction;
        bool                                                            fObjCGc;
        bool                                                            fObjCGcOnly;
        bool                                                            fObjcGcCompaction;
        bool                                                            fObjCGc;
        bool                                                            fObjCGcOnly;


@@ -502,17 +772,65 @@ private:
        bool                                                            fFunctionStartsLoadCommand;
        bool                                                            fFunctionStartsForcedOn;
        bool                                                            fFunctionStartsForcedOff;
        bool                                                            fFunctionStartsLoadCommand;
        bool                                                            fFunctionStartsForcedOn;
        bool                                                            fFunctionStartsForcedOff;

+       bool                                                            fDataInCodeInfoLoadCommand;
+       bool                                                            fDataInCodeInfoLoadCommandForcedOn;
+       bool                                                            fDataInCodeInfoLoadCommandForcedOff;

        bool                                                            fCanReExportSymbols;
        bool                                                            fObjcCategoryMerging;
        bool                                                            fPageAlignDataAtoms;
        bool                                                            fCanReExportSymbols;
        bool                                                            fObjcCategoryMerging;
        bool                                                            fPageAlignDataAtoms;

+       bool                                                            fNeedsThreadLoadCommand;
+       bool                                                            fEntryPointLoadCommand;
+       bool                                                            fSourceVersionLoadCommand;
+       bool                                                            fSourceVersionLoadCommandForceOn;
+       bool                                                            fSourceVersionLoadCommandForceOff;      
+       bool                                                            fExportDynamic;
+       bool                                                            fAbsoluteSymbols;
+       bool                                                            fAllowSimulatorToLinkWithMacOSX;
+       bool                                                            fKeepDwarfUnwind;
+       bool                                                            fKeepDwarfUnwindForcedOn;
+       bool                                                            fKeepDwarfUnwindForcedOff;
+       bool                                                            fVerboseOptimizationHints;
+       bool                                                            fIgnoreOptimizationHints;
+       bool                                                            fGenerateDtraceDOF;
+       bool                                                            fAllowBranchIslands;
+       bool                                                            fTraceSymbolLayout;
+       bool                                                            fMarkAppExtensionSafe;
+       bool                                                            fCheckAppExtensionSafe;
+       bool                                                            fForceLoadSwiftLibs;
+       bool                                                            fSharedRegionEncodingV2;
+       bool                                                            fUseDataConstSegment;
+       bool                                                            fUseDataConstSegmentForceOn;
+       bool                                                            fUseDataConstSegmentForceOff;
+       bool                                                            fUseTextExecSegment;
+       bool                                                            fBundleBitcode;
+       bool                                                            fHideSymbols;
+       bool                                                            fVerifyBitcode;
+       bool                                                            fReverseMapUUIDRename;
+       bool                                                            fDeDupe;
+       bool                                                            fVerboseDeDupe;
+       bool                                                            fUseLinkedListBinding;
+#if SUPPORT_ARCH_arm64e
+       bool                                                            fUseAuthenticatedStubs = false;
+       bool                                                            fSupportsAuthenticatedPointers = false;
+#endif
+       bool                                                            fNoLazyBinding;
+       bool                                                            fDebugVariant;
+       const char*                                                     fReverseMapPath;
+       std::string                                                     fReverseMapTempPath;
+       bool                                                            fLTOCodegenOnly;
+       bool                                                            fIgnoreAutoLink;
+       bool                                                            fAllowDeadDups;
+       bool                                                            fAllowWeakImports;
+       Treatment                                                       fInitializersTreatment;
+       bool                                                            fZeroModTimeInDebugMap;
+       BitcodeMode                                                     fBitcodeKind;

        DebugInfoStripping                                      fDebugInfoStripping;
        const char*                                                     fTraceOutputFile;
        DebugInfoStripping                                      fDebugInfoStripping;
        const char*                                                     fTraceOutputFile;

-       ld::MacVersionMin                                       fMacVersionMin;
-       ld::IOSVersionMin                                       fIOSVersionMin;
+       ld::VersionSet                                          fPlatforms;

        std::vector<AliasPair>                          fAliases;
        std::vector<const char*>                        fInitialUndefines;
        NameSet                                                         fAllowedUndefined;
        std::vector<AliasPair>                          fAliases;
        std::vector<const char*>                        fInitialUndefines;
        NameSet                                                         fAllowedUndefined;

-       NameSet                                                         fWhyLive;
+       SetWithWildcards                                        fWhyLive;

        std::vector<ExtraSection>                       fExtraSections;
        std::vector<SectionAlignment>           fSectionAlignments;
        std::vector<OrderedSymbol>                      fOrderedSymbols;
        std::vector<ExtraSection>                       fExtraSections;
        std::vector<SectionAlignment>           fSectionAlignments;
        std::vector<OrderedSymbol>                      fOrderedSymbols;


@@ -525,7 +843,27 @@ private:
        std::vector<const char*>                        fFrameworkSearchPaths;
        std::vector<const char*>                        fSDKPaths;
        std::vector<const char*>                        fDyldEnvironExtras;
        std::vector<const char*>                        fFrameworkSearchPaths;
        std::vector<const char*>                        fSDKPaths;
        std::vector<const char*>                        fDyldEnvironExtras;

+       std::vector<const char*>                        fSegmentOrder;
+       std::vector<const char*>                        fASTFilePaths;
+       std::vector<SectionOrderList>           fSectionOrder;
+       std::vector< std::vector<const char*> > fLinkerOptions;
+       std::vector<SectionRename>                      fSectionRenames;
+       std::vector<SegmentRename>                      fSegmentRenames;
+       std::vector<SymbolsMove>                        fSymbolsMovesData;
+       std::vector<SymbolsMove>                        fSymbolsMovesCode;
+       std::vector<SymbolsMove>                        fSymbolsMovesAXMethodLists;

        bool                                                            fSaveTempFiles;
        bool                                                            fSaveTempFiles;

+    mutable Snapshot                                   fLinkSnapshot;
+    bool                                                               fSnapshotRequested;
+    const char*                                                        fPipelineFifo;
+       const char*                                                     fDependencyInfoPath;
+       const char*                                                     fBuildContextName;
+       mutable int                                                     fTraceFileDescriptor;
+       uint8_t                                                         fMaxDefaultCommonAlign;
+       UnalignedPointerTreatment                       fUnalignedPointerTreatment;
+       mutable std::vector<DependencyEntry> fDependencies;
+       mutable std::vector<Options::TAPIInterface> fTAPIFiles;
+

 };
 
 
 };