dyld-519.2.2.tar.gz

[apple/dyld.git] / dyld3 / shared-cache / ImageProxy.cpp

/*
 * Copyright (c) 2017 Apple Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 *
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 *
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 *
 * @APPLE_LICENSE_HEADER_END@
 */


#include <string.h>
#include <stdint.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include <limits.h>
#include <sys/errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/param.h>
#include <sys/mman.h>
#include <mach/mach_vm.h>
#include <mach-o/dyld.h>
#include <mach-o/dyld_priv.h>
#include <uuid/uuid.h>
#include <os/log.h>

#include <string>
#include <vector>
#include <array>

#include "ImageProxy.h"
#include "FileUtils.h"
#include "StringUtils.h"
#include "MachOParser.h"
#include "LaunchCacheFormat.h"
#include "LaunchCacheWriter.h"
#include "PathOverrides.h"
#include "libdyldEntryVector.h"

namespace dyld3 {

typedef launch_cache::TargetSymbolValue   TargetSymbolValue;



///////////////////////////  ImageProxy  ///////////////////////////

ImageProxy::ImageProxy(const mach_header* mh, const BinaryImageData* imageData, uint32_t indexInGroup, bool dyldCacheIsRaw)
 : _mh(mh), _sliceFileOffset(0), _modTime(0), _inode(0), _imageBinaryData(imageData), _runtimePath(launch_cache::Image(imageData).path()),
   _groupNum(0), _indexInGroup(indexInGroup), _isSetUID(false), _dyldCacheIsRaw(dyldCacheIsRaw), _platformBinary(false), _overrideOf(ImageRef::weakImportMissing()),
   _directDependentsSet(false), _deepDependentsSet(false), _initBeforesArraySet(false), _initBeforesComputed(false),
   _invalid(launch_cache::Image(imageData).isInvalid()), _staticallyReferenced(false), _cwdMustBeThisDir(false)
{
}

ImageProxy::ImageProxy(const DyldSharedCache::MappedMachO& mapping, uint32_t groupNum, uint32_t indexInGroup, bool dyldCacheIsRaw)
 : _mh(mapping.mh), _sliceFileOffset(mapping.sliceFileOffset), _modTime(mapping.modTime), _inode(mapping.inode), _imageBinaryData(nullptr), _runtimePath(mapping.runtimePath),
   _groupNum(groupNum), _indexInGroup(indexInGroup), _isSetUID(mapping.isSetUID), _dyldCacheIsRaw(dyldCacheIsRaw), _platformBinary(mapping.protectedBySIP),
   _overrideOf(ImageRef::weakImportMissing()), _directDependentsSet(false), _deepDependentsSet(false), _initBeforesArraySet(false), _initBeforesComputed(false),
   _invalid(false), _staticallyReferenced(false), _cwdMustBeThisDir(false)
{
}


void ImageProxy::processRPaths(ImageProxyGroup& owningGroup)
{
    // parse LC_RPATH
    __block std::unordered_set<std::string> rawRpaths;
    MachOParser parser(_mh, _dyldCacheIsRaw);
    parser.forEachRPath(^(const char* rpath, bool& stop) {
        if ( rawRpaths.count(rpath) ) {
            _diag.warning("duplicate LC_RPATH (%s) in %s", rpath, _runtimePath.c_str());
            return;
        }
        rawRpaths.insert(rpath);
        std::string thisRPath = rpath;
        if ( startsWith(thisRPath, "@executable_path/") ) {
            std::string mainPath = owningGroup.mainProgRuntimePath();
            if ( mainPath.empty() && parser.isDynamicExecutable() ) {
                mainPath = _runtimePath;
            }
            if ( !mainPath.empty() ) {
                std::string newPath = mainPath.substr(0, mainPath.rfind('/')+1) + thisRPath.substr(17);
                std::string normalizedPath = owningGroup.normalizedPath(newPath);
                if ( fileExists(normalizedPath) )
                    _rpaths.push_back(normalizedPath);
                else
                    _diag.warning("LC_RPATH to nowhere (%s) in %s", rpath, _runtimePath.c_str());
                char resolvedMainPath[PATH_MAX];
                if ( (realpath(mainPath.c_str(), resolvedMainPath) != nullptr) && (mainPath.c_str() != resolvedMainPath) ) {
                    std::string realMainPath = resolvedMainPath;
                    size_t lastSlashPos = realMainPath.rfind('/');
                    std::string newRealPath = realMainPath.substr(0, lastSlashPos+1) + thisRPath.substr(17);
                    if ( realMainPath != mainPath ) {
                        for (const std::string& pre : owningGroup._buildTimePrefixes) {
                            std::string aPath = owningGroup.normalizedPath(pre + newRealPath);
                            if ( fileExists(aPath) ) {
                                _rpaths.push_back(owningGroup.normalizedPath(newRealPath));
                            }
                        }
                    }
                }
            }
            else {
                _diag.warning("LC_RPATH uses @executable_path in %s", _runtimePath.c_str());
            }
        }
        else if ( thisRPath == "@executable_path" ) {
            std::string mainPath = owningGroup.mainProgRuntimePath();
            if ( mainPath.empty() && parser.isDynamicExecutable() ) {
                mainPath = _runtimePath;
            }
            if ( !mainPath.empty() ) {
                std::string newPath = mainPath.substr(0, mainPath.rfind('/')+1);
                std::string normalizedPath = owningGroup.normalizedPath(newPath);
                _rpaths.push_back(normalizedPath);
            }
            else {
                _diag.warning("LC_RPATH uses @executable_path in %s", _runtimePath.c_str());
            }
        }
        else if ( startsWith(thisRPath, "@loader_path/") ) {
            size_t lastSlashPos = _runtimePath.rfind('/');
            std::string newPath = _runtimePath.substr(0, lastSlashPos+1) + thisRPath.substr(13);
            bool found = false;
            for (const std::string& pre : owningGroup._buildTimePrefixes) {
                std::string aPath = owningGroup.normalizedPath(pre + newPath);
                if ( fileExists(aPath) ) {
                    _rpaths.push_back(owningGroup.normalizedPath(newPath));
                    found = true;
                    break;
                }
            }
            char resolvedPath[PATH_MAX];
            if ( (realpath(_runtimePath.c_str(), resolvedPath) != nullptr) && (_runtimePath.c_str() != resolvedPath) ) {
                std::string realRunPath = resolvedPath;
                lastSlashPos = realRunPath.rfind('/');
                std::string newRealPath = realRunPath.substr(0, lastSlashPos+1) + thisRPath.substr(13);
                if ( newRealPath != newPath ) {
                    for (const std::string& pre : owningGroup._buildTimePrefixes) {
                        std::string aPath = owningGroup.normalizedPath(pre + newRealPath);
                        if ( fileExists(aPath) ) {
                            _rpaths.push_back(owningGroup.normalizedPath(newRealPath));
                            found = true;
                            break;
                        }
                    }
                }
            }
            if ( !found ) {
                // even though this path does not exist, we need to add it to must-be-missing paths
                // in case it shows up at launch time
                _rpaths.push_back(owningGroup.normalizedPath(newPath));
                _diag.warning("LC_RPATH to nowhere (%s) in %s", rpath, _runtimePath.c_str());
            }
        }
        else if ( thisRPath == "@loader_path" ) {
            size_t lastSlashPos = _runtimePath.rfind('/');
            std::string newPath = _runtimePath.substr(0, lastSlashPos+1);
            std::string normalizedPath = owningGroup.normalizedPath(newPath);
            _rpaths.push_back(normalizedPath);
        }
        else if ( rpath[0] == '@' ) {
            _diag.warning("LC_RPATH with unknown @ variable (%s) in %s", rpath, _runtimePath.c_str());
        }
        else {
            if ( rpath[0] == '/' )
                _diag.warning("LC_RPATH is absolute path (%s) in %s", rpath, _runtimePath.c_str());
            _rpaths.push_back(rpath);
        }
    });
    //if ( !_rpaths.empty() ) {
    //    fprintf(stderr, "for %s\n", _runtimePath.c_str());
    //    for (const std::string& p : _rpaths)
    //        fprintf(stderr, "   %s\n", p.c_str());
    //}
}

void ImageProxy::addDependentsDeep(ImageProxyGroup& owningGroup, RPathChain* prev, bool staticallyReferenced)
{
    // mark binaries that are statically referenced and thus will never be unloaded
    if ( staticallyReferenced )
        _staticallyReferenced = true;

    if ( _deepDependentsSet )
        return;

    // find all immediate dependents
    addDependentsShallow(owningGroup, prev);
    if ( _diag.hasError() ) {
        _invalid = true;
        return;
    }

    // recurse though each dependent
    RPathChain rchain = { this, prev, _rpaths };
    for (ImageProxy* proxy : _dependents) {
        if ( proxy == nullptr )
            continue; // skip over weak missing dependents
        if ( !proxy->_directDependentsSet )
            proxy->addDependentsDeep(owningGroup, &rchain, staticallyReferenced);
        if ( proxy->invalid() )
            _invalid = true;
    }

    _deepDependentsSet = true;
}

void ImageProxy::addDependentsShallow(ImageProxyGroup& owningGroup, RPathChain* prev)
{
    if ( _directDependentsSet )
        return;

    MachOParser thisParser(mh(), _dyldCacheIsRaw);
    dyld3::Platform thisPlatform = thisParser.platform();

    processRPaths(owningGroup);
    __block RPathChain rchain = { this, prev, _rpaths };

    thisParser.forEachDependentDylib(^(const char* loadPath, bool isWeak, bool isReExport, bool isUpward, uint32_t compatVersion, uint32_t curVersion, bool &stop) {
        if ( (loadPath[0] != '/') && (loadPath[0] != '@') ) {
            _diag.warning("load path is file system relative (%s) in %s", loadPath, runtimePath().c_str());
        }
        Diagnostics depDiag;
        ImageProxy* dep = owningGroup.findImage(depDiag, loadPath, isWeak, &rchain);
        if ( (dep == nullptr) || dep->invalid() ) {
            if (isWeak) {
                // weak link against a broken dylib, pretend dylib is not there
                dep = nullptr;
            } else {
                if ( depDiag.warnings().empty() ) {
                    if ( thisParser.header()->filetype == MH_EXECUTE )
                        _diag.error("required dylib '%s' not found", loadPath);
                    else
                        _diag.error("required dylib '%s' not found, needed by '%s'", loadPath, runtimePath().c_str());
                }
                else {
                    std::string allTries;
                    for (const std::string& warn : depDiag.warnings()) {
                        if ( allTries.empty() )
                            allTries = warn;
                        else
                            allTries = allTries + ", " + warn;
                    }
                    _diag.error("required dylib '%s' not found, needed by '%s'.  Did try: %s", loadPath, runtimePath().c_str(), allTries.c_str());
                }
            }
        }
        else {
            MachOParser depParser(dep->mh(), _dyldCacheIsRaw);
            if ( _diag.noError() ) {
                // verify found image has compatible version and matching platform
                dyld3::Platform depPlatform = depParser.platform();
                if ( depPlatform != thisPlatform ) {
                    // simulator allows a few macOS libSystem dylibs
                    if ( !inLibSystem() || !dep->inLibSystem() ) {
                        _diag.error("found '%s' but it was built for different platform '%s' than required '%s'.  Needed by '%s'", dep->runtimePath().c_str(),
                                    MachOParser::platformName(depPlatform).c_str(), MachOParser::platformName(thisPlatform).c_str(), runtimePath().c_str());
                    }
                }
            }
            if ( _diag.noError() ) {
                // verify compat version
                const char* installName;
                uint32_t    foundCompatVers;
                uint32_t    foundCurrentVers;
                if ( depParser.header()->filetype != MH_DYLIB ) {
                    _diag.error("found '%s' which is not a dylib.  Needed by '%s'", dep->runtimePath().c_str(), runtimePath().c_str());
                }
                else {
                    depParser.getDylibInstallName(&installName, &foundCompatVers, &foundCurrentVers);
                    if ( foundCompatVers < compatVersion ) {
                        _diag.error("found '%s' which has compat version (%s) which is less than required (%s).  Needed by '%s'", dep->runtimePath().c_str(),
                                    MachOParser::versionString(foundCompatVers).c_str(), MachOParser::versionString(compatVersion).c_str(), runtimePath().c_str());
                    }
                }
            }
        }
        if ( _diag.hasError() ) {
            stop = true;
            _invalid = true;
        }
        _dependents.push_back(dep);
        if ( isWeak )
            _dependentsKind.push_back(launch_cache::Image::LinkKind::weak);
        else if ( isReExport )
            _dependentsKind.push_back(launch_cache::Image::LinkKind::reExport);
        else if ( isUpward )
            _dependentsKind.push_back(launch_cache::Image::LinkKind::upward);
        else
            _dependentsKind.push_back(launch_cache::Image::LinkKind::regular);
    });
    _directDependentsSet = true;
}

bool ImageProxy::inLibSystem() const
{
    return startsWith(runtimePath(), "/usr/lib/system/") || startsWith(runtimePath(), "/usr/lib/libSystem.");
}

void ImageProxy::forEachDependent(void (^handler)(ImageProxy* dep, LinkKind)) const
{
    for (int i=0; i < _dependents.size(); ++i) {
        handler(_dependents[i], _dependentsKind[i]);
    }
}


bool ImageProxy::findExportedSymbol(Diagnostics& diag, const char* symbolName, MachOParser::FoundSymbol& foundInfo) const
{
    MachOParser parser(_mh, _dyldCacheIsRaw);
    return parser.findExportedSymbol(diag, symbolName, (void*)this, foundInfo, ^(uint32_t depIndex, const char* depLoadPath, void* extra, const mach_header** foundMH, void** foundExtra) {
        ImageProxy* proxy    = (ImageProxy*)extra;
        if ( depIndex < proxy->_dependents.size() ) {
            ImageProxy* depProxy = proxy->_dependents[depIndex];
            *foundMH    = depProxy->_mh;
            *foundExtra = (void*)depProxy;
            return true;
        }
        return false;
    });
}

bool ImageProxy::InitOrderInfo::beforeHas(ImageRef ref)
{
    ImageRef clearRef = ref;
    clearRef.clearKind();
    return ( std::find(initBefore.begin(), initBefore.end(), clearRef) != initBefore.end() );
}

bool ImageProxy::InitOrderInfo::upwardHas(ImageProxy* proxy)
{
    return ( std::find(danglingUpward.begin(), danglingUpward.end(), proxy) != danglingUpward.end() );
}

void ImageProxy::InitOrderInfo::removeRedundantUpwards()
{
    danglingUpward.erase(std::remove_if(danglingUpward.begin(), danglingUpward.end(),
                                        [&](ImageProxy* proxy) {
                                            ImageRef ref(0, proxy->_groupNum, proxy->_indexInGroup);
                                            return beforeHas(ref);
                                        }), danglingUpward.end());
}


//
// Every image has a list of "init-before" which means if that image was dlopen()ed
// here is the exact list of images to initialize in the exact order.  This makes
// the runtime easy.  It just walks the init-before list in order and runs each
// initializer if it has not already been run.
//
// The init-before list for each image is calculated based on the init-before list
// of each of its dependents.  It simply starts with the list of its first dependent,
// then appends the list of the next, removing entries already in the list, etc.
// Lastly if the current image has an initializer, it is appended to its init-before list.
//
// To handle cycles, when recursing to get a dependent's init-before list, any image
// whose list is still being calculated (cycle), just returns its list so far.
//
// Explicit upward links are handled in two parts.  First, in the algorithm described above,
// all upward links are ignored, which works fine as long as anything upward linked is
// downward linked at some point.  If not, it is called a "dangling upward link". Since
// nothing depends on those, they are added to the end of the final init-before list.
//

void ImageProxy::recursiveBuildInitBeforeInfo(ImageProxyGroup& owningGroup)
{
    if ( _initBeforesComputed )
        return;
    _initBeforesComputed = true; // break cycles

    if ( _imageBinaryData != nullptr ) {
        assert(_groupNum == 0);
        // if this is proxy for something in dyld cache, get its list from cache
        // and parse list into befores and upwards
        launch_cache::Image image(_imageBinaryData);
        image.forEachInitBefore(^(launch_cache::binary_format::ImageRef ref) {
            if ( (LinkKind)ref.kind() == LinkKind::upward ) {
                ImageProxyGroup* groupP = &owningGroup;
                while (groupP->_groupNum != 0)
                    groupP = groupP->_nextSearchGroup;
                launch_cache::ImageGroup dyldCacheGroup(groupP->_basedOn);
                launch_cache::Image      dyldCacheImage = dyldCacheGroup.image(ref.indexInGroup());
                Diagnostics diag;
                ImageProxy* p = groupP->findAbsoluteImage(diag, dyldCacheImage.path(), false, false);
                if ( diag.noError() )
                    _initBeforesInfo.danglingUpward.push_back(p);
            }
            else {
                _initBeforesInfo.initBefore.push_back(ref);
            }
        });
    }
    else {
        // calculate init-before list for this image by merging init-before's of all its dependent dylibs
        unsigned depIndex = 0;
        for (ImageProxy* depProxy : _dependents) {
            if ( depProxy == nullptr ) {
                assert(_dependentsKind[depIndex] == LinkKind::weak);
            }
            else {
                if ( _dependentsKind[depIndex] == LinkKind::upward ) {
                    // if this upward link is already in the list, we ignore it.  Otherwise add to front of list
                    if ( _initBeforesInfo.upwardHas(depProxy) ) {
                        // already in upward list, do nothing
                    }
                    else {
                        ImageRef ref(0, depProxy->_groupNum, depProxy->_indexInGroup);
                        if ( _initBeforesInfo.beforeHas(ref) ) {
                            // already in before list, do nothing
                        }
                        else {
                            // add to upward list
                            _initBeforesInfo.danglingUpward.push_back(depProxy);
                        }
                    }
                }
                else {
                    // compute init-befores of downward dependents
                    depProxy->recursiveBuildInitBeforeInfo(owningGroup);
                    // merge befores from this downward link into current befores list
                    for (ImageRef depInit : depProxy->_initBeforesInfo.initBefore) {
                        if ( !_initBeforesInfo.beforeHas(depInit) )
                            _initBeforesInfo.initBefore.push_back(depInit);
                    }
                    // merge upwards from this downward link into current befores list
                    for (ImageProxy* upProxy : depProxy->_initBeforesInfo.danglingUpward) {
                        ImageRef ref(0, upProxy->_groupNum, upProxy->_indexInGroup);
                        if ( _initBeforesInfo.beforeHas(ref) ) {
                            // already in current initBefore list, so ignore this upward
                        }
                        else if ( _initBeforesInfo.upwardHas(upProxy) ) {
                            // already in current danglingUpward list, so ignore this upward
                        }
                        else {
                            // append to current danglingUpward list
                            _initBeforesInfo.danglingUpward.push_back(upProxy);
                        }
                    }
                }
            }
            ++depIndex;
        }
        // eliminate any upward links added to befores list by some other dependent
        _initBeforesInfo.removeRedundantUpwards();

        // if this images has initializer(s) (or +load), add it to list
        MachOParser parser(_mh, _dyldCacheIsRaw);
        Diagnostics diag;
        if ( parser.hasInitializer(diag) || parser.hasPlusLoadMethod(diag) ) {
            launch_cache::binary_format::ImageRef ref(0, _groupNum, _indexInGroup);
            _initBeforesInfo.initBefore.push_back(ref);
        }

        //fprintf(stderr, "info for (%d, %d) %s\n",  _group, _index, _runtimePath.c_str());
        //for (ImageRef ref : _initBeforesInfo.initBefore)
        //     fprintf(stderr, "   ref = {%d, %d, %d}\n", ref.kind(), ref.group(), ref.index());
        //for (ImageProxy* p : _initBeforesInfo.danglingUpward)
        //     fprintf(stderr, "   up = %s\n", p->runtimePath().c_str());
    }
}

void ImageProxy::convertInitBeforeInfoToArray(ImageProxyGroup& owningGroup)
{
    if ( _initBeforesInfo.danglingUpward.empty() ) {
        _initBeforesArray = _initBeforesInfo.initBefore;
    }
    else {
        for (ImageRef ref : _initBeforesInfo.initBefore)
            _initBeforesArray.push_back(ref);
        bool inLibSys = inLibSystem();
        for (ImageProxy* proxy : _initBeforesInfo.danglingUpward) {
            // ignore upward dependendencies between stuff within libSystem.dylib
            if ( inLibSys && proxy->inLibSystem() )
                continue;
            proxy->getInitBeforeList(owningGroup);
            for (ImageRef depInit : proxy->_initBeforesInfo.initBefore) {
                if ( std::find(_initBeforesArray.begin(), _initBeforesArray.end(), depInit) == _initBeforesArray.end() )
                    _initBeforesArray.push_back(depInit);
            }
            ImageRef ref(0, proxy->_groupNum, proxy->_indexInGroup);
            if ( std::find(_initBeforesArray.begin(), _initBeforesArray.end(), ref) == _initBeforesArray.end() )
                _initBeforesArray.push_back(ref);
        }
    }
    //fprintf(stderr, "final init-before info for %s\n", _runtimePath.c_str());
    //for (ImageRef ref : _initBeforesArray) {
    //    fprintf(stderr, "   ref = {%d, %d, %d}\n", ref.linkKind, ref.group, ref.index);
    //}
}

const std::vector<ImageRef>& ImageProxy::getInitBeforeList(ImageProxyGroup& owningGroup)
{
    if ( !_initBeforesArraySet ) {
        _initBeforesArraySet = true; // break cycles
        recursiveBuildInitBeforeInfo(owningGroup);
        convertInitBeforeInfoToArray(owningGroup);
    }
    return _initBeforesArray;
}

ImageProxy::FixupInfo ImageProxy::buildFixups(Diagnostics& diag, uint64_t cacheUnslideBaseAddress, launch_cache::ImageGroupWriter& groupWriter) const
{
    __block ImageProxy::FixupInfo info;
    MachOParser image(_mh, _dyldCacheIsRaw);

    // add fixup for each rebase
    __block bool rebaseError = false;
    image.forEachRebase(diag, ^(uint32_t segIndex, uint64_t segOffset, uint8_t type, bool& stop) {
        dyld3::launch_cache::ImageGroupWriter::FixupType fixupType = launch_cache::ImageGroupWriter::FixupType::rebase;
        switch ( type ) {
            case REBASE_TYPE_POINTER:
                fixupType = launch_cache::ImageGroupWriter::FixupType::rebase;
                break;
            case REBASE_TYPE_TEXT_ABSOLUTE32:
                fixupType = launch_cache::ImageGroupWriter::FixupType::rebaseText;
                info.hasTextRelocs = true;
                break;
            case REBASE_TYPE_TEXT_PCREL32:
                diag.error("pcrel text rebasing not supported");
                stop = true;
                rebaseError = true;
                break;
            default:
                diag.error("unknown rebase type");
                stop = true;
                rebaseError = true;
                break;
        }
        info.fixups.push_back({segIndex, segOffset, fixupType, TargetSymbolValue::makeInvalid()});
        //fprintf(stderr, "rebase: segIndex=%d, segOffset=0x%0llX, type=%d\n", segIndex, segOffset, type);
    });
    if ( diag.hasError() )
        return FixupInfo();

    // add fixup for each bind
    image.forEachBind(diag, ^(uint32_t segIndex, uint64_t segOffset, uint8_t type, int libOrdinal,
                              uint64_t addend, const char* symbolName, bool weakImport, bool lazy, bool& stop) {
        launch_cache::ImageGroupWriter::FixupType fixupType;
        switch ( type ) {
            case BIND_TYPE_POINTER:
                if ( lazy )
                    fixupType = launch_cache::ImageGroupWriter::FixupType::pointerLazyBind;
                else
                    fixupType = launch_cache::ImageGroupWriter::FixupType::pointerBind;
                break;
            case BIND_TYPE_TEXT_ABSOLUTE32:
                fixupType = launch_cache::ImageGroupWriter::FixupType::bindText;
                info.hasTextRelocs = true;
                break;
            case BIND_TYPE_TEXT_PCREL32:
                fixupType = launch_cache::ImageGroupWriter::FixupType::bindTextRel;
                info.hasTextRelocs = true;
                break;
            case BIND_TYPE_IMPORT_JMP_REL32:
                fixupType = launch_cache::ImageGroupWriter::FixupType::bindImportJmpRel;
                break;
           default:
                diag.error("malformed executable, unknown bind type (%d)", type);
                stop = true;
                return;
        }
        const ImageProxy*    depProxy    = nullptr;
        bool                isWeakDylib = false;
        if ( libOrdinal == BIND_SPECIAL_DYLIB_MAIN_EXECUTABLE ) {
            // -bundle_loader symbols cannot be bound ahead of time, we must look them up at load time
            uint32_t imagePathPoolOffset   =  groupWriter.addString("@main");
            uint32_t imageSymbolPoolOffset =  groupWriter.addString(symbolName);
            info.fixups.push_back({segIndex, segOffset, fixupType, TargetSymbolValue::makeDynamicGroupValue(imagePathPoolOffset, imageSymbolPoolOffset, weakImport)});
            return;
        }
        else if ( libOrdinal == BIND_SPECIAL_DYLIB_FLAT_LOOKUP ) {
            // -dynamic_lookup symbols cannot be bound ahead of time, we must look them up at load time
            uint32_t imagePathPoolOffset   =  groupWriter.addString("@flat");
            uint32_t imageSymbolPoolOffset =  groupWriter.addString(symbolName);
            info.fixups.push_back({segIndex, segOffset, fixupType, TargetSymbolValue::makeDynamicGroupValue(imagePathPoolOffset, imageSymbolPoolOffset, weakImport)});
            return;
        }
        else if ( libOrdinal == BIND_SPECIAL_DYLIB_SELF ) {
            depProxy = this;
        }
        else if ( (libOrdinal >= 1) && (libOrdinal <= _dependents.size()) ) {
            isWeakDylib = (_dependentsKind[libOrdinal-1] == LinkKind::weak);
            depProxy    = _dependents[libOrdinal-1];
        }
        else {
            diag.error("ordinal %d not supported", libOrdinal);
            stop = true;
            return;
        }
        if ( depProxy != nullptr ) {
            MachOParser::FoundSymbol foundInfo;
            if ( depProxy->findExportedSymbol(diag, symbolName, foundInfo) ) {
                MachOParser implDylib(foundInfo.foundInDylib, _dyldCacheIsRaw);
                switch ( foundInfo.kind ) {
                    case MachOParser::FoundSymbol::Kind::headerOffset:
                    case MachOParser::FoundSymbol::Kind::resolverOffset:
                        if ( implDylib.inDyldCache() ) {
                            uint32_t cacheOffset = (uint32_t)(implDylib.preferredLoadAddress() + foundInfo.value - cacheUnslideBaseAddress + addend);
                            info.fixups.push_back({segIndex, segOffset, fixupType, TargetSymbolValue::makeSharedCacheOffset(cacheOffset)});
                        }
                        else {
                            ImageProxy* foundProxy   = (ImageProxy*)(foundInfo.foundExtra);
                            bool isIndirectGroupNum  = foundProxy->_groupNum >= 128;
                            uint32_t groupNum        = isIndirectGroupNum ? groupWriter.addIndirectGroupNum(foundProxy->_groupNum) : foundProxy->_groupNum;
                            info.fixups.push_back({segIndex, segOffset, fixupType, TargetSymbolValue::makeGroupValue(groupNum, foundProxy->_indexInGroup, foundInfo.value+addend, isIndirectGroupNum)});
                        }
                        break;
                   case MachOParser::FoundSymbol::Kind::absolute:
                        if (((((intptr_t)(foundInfo.value+addend)) << 2) >> 2) != (foundInfo.value+addend)) {
                            diag.error("absolute value %lld not supported", foundInfo.value+addend);
                            stop = true;
                            return;
                        }
                        info.fixups.push_back({segIndex, segOffset, fixupType, TargetSymbolValue::makeAbsolute(foundInfo.value+addend)});
                        break;
                }
            }
            else {
                if ( !weakImport ) {
                    diag.error("symbol '%s' not found, expected in '%s'", symbolName, depProxy->runtimePath().c_str());
                    stop = true;
                }
                // mark fixup needs to set fixup location to zero
                info.fixups.push_back({segIndex, segOffset, fixupType, TargetSymbolValue::makeAbsolute(0)});
            }
        }
        else {
            if ( isWeakDylib ) {
                // dylib not found and is weak, set pointers into it to zero
                info.fixups.push_back({segIndex, segOffset, fixupType, TargetSymbolValue::makeAbsolute(0)});
            }
            else {
                diag.error("dylib ordinal %d not found and not weak", libOrdinal);
                stop = true;
            }
         }
    });
    if ( diag.hasError() )
        return FixupInfo();

    uint32_t weakDefPathPoolOffset = groupWriter.addString("@weak_def");
    image.forEachWeakDef(diag, ^(bool strongDef, uint32_t segIndex, uint64_t segOffset, uint64_t addend, const char* symbolName, bool& stop) {
        if ( strongDef )
            return;
        // find fixup for that location and change it to be a @weakdef dynamic target
        bool altered = false;
        for (FixUp& fixup : info.fixups) {
            if ( (fixup.segOffset == segOffset) && (fixup.segIndex == segIndex) ) {
                uint32_t symbolPoolOffset =  groupWriter.addString(symbolName);
                fixup.type   = launch_cache::ImageGroupWriter::FixupType::pointerBind;
                fixup.target = TargetSymbolValue::makeDynamicGroupValue(weakDefPathPoolOffset, symbolPoolOffset, false);
                altered = true;
            }
        }
        if ( !altered ) {
            if ( image.isSlideable() ) {
                fprintf(stderr, "weak def for %s can't find underlying rebase/bind in %s\n", symbolName, runtimePath().c_str());
            }
            else {
                // no-pie executable does not have rebase for weak-def fixup, so add fixup
                uint32_t symbolPoolOffset =  groupWriter.addString(symbolName);
                info.fixups.push_back({segIndex, segOffset, launch_cache::ImageGroupWriter::FixupType::pointerBind, TargetSymbolValue::makeDynamicGroupValue(weakDefPathPoolOffset, symbolPoolOffset, false)} );
            }
        }

    });

    return info;
}


void ImageProxy::setOverrideOf(uint32_t groupNum, uint32_t indexInGroup)
{
    _overrideOf = ImageRef(0, groupNum, indexInGroup);
}


static bool alreadyInList(const std::vector<ImageProxy*>& imageList, ImageProxy* image)
{
    for (ImageProxy* proxy : imageList) {
        if ( proxy == image )
            return true;
    }
    return false;
}

void ImageProxy::addToFlatLookup(std::vector<ImageProxy*>& imageList)
{
    // add all images shallow
    bool addedSomething = false;
    for (ImageProxy* dep : _dependents) {
        if ( dep == nullptr )
            continue;
        if ( !alreadyInList(imageList, dep) ) {
            imageList.push_back(dep);
            addedSomething = true;
        }
    }
    // recurse
    if ( addedSomething ) {
        for (ImageProxy* dep : _dependents) {
            if ( dep == nullptr )
                continue;
            dep->addToFlatLookup(imageList);
        }
    }
}


///////////////////////////  ImageProxyGroup  ///////////////////////////


class StringPool
{
public:
    uint32_t            add(const std::string& str);
    size_t              size() const   { return _buffer.size(); }
    const char*         buffer() const { return &_buffer[0]; }
    void                align();
private:
    std::vector<char>                           _buffer;
    std::unordered_map<std::string, uint32_t>   _existingEntries;
};

uint32_t StringPool::add(const std::string& str)
{
    auto pos = _existingEntries.find(str);
    if ( pos != _existingEntries.end() )
        return pos->second;
    size_t len = str.size() + 1;
    size_t offset = _buffer.size();
    _buffer.insert(_buffer.end(), &str[0], &str[len]);
    _existingEntries[str] = (uint32_t)offset;
    assert(offset < 0xFFFF);
    return (uint32_t)offset;
}

void StringPool::align()
{
    while ( (_buffer.size() % 4) != 0 )
        _buffer.push_back('\0');
}

ImageProxyGroup::ImageProxyGroup(uint32_t groupNum, const DyldCacheParser& dyldCache, const launch_cache::binary_format::ImageGroup* basedOn,
                                 ImageProxyGroup* next, const std::string& mainProgRuntimePath,
                                 const std::vector<const BinaryImageGroupData*>& knownGroups,
                                 const std::vector<std::string>& buildTimePrefixes,
                                 const std::vector<std::string>& envVars,
                                 bool stubsEliminated, bool dylibsExpectedOnDisk, bool inodesAreSameAsRuntime)
    : _pathOverrides(envVars), _patchTable(nullptr), _basedOn(basedOn), _dyldCache(dyldCache), _nextSearchGroup(next), _groupNum(groupNum),
      _stubEliminated(stubsEliminated), _dylibsExpectedOnDisk(dylibsExpectedOnDisk), _inodesAreSameAsRuntime(inodesAreSameAsRuntime),
      _knownGroups(knownGroups), _buildTimePrefixes(buildTimePrefixes), _mainProgRuntimePath(mainProgRuntimePath), _platform(Platform::unknown)
{
    _archName = dyldCache.cacheHeader()->archName();
    _platform = (Platform)(dyldCache.cacheHeader()->platform());
}


ImageProxyGroup::~ImageProxyGroup()
{
    for (DyldSharedCache::MappedMachO& mapping : _ownedMappings ) {
        vm_deallocate(mach_task_self(), (vm_address_t)mapping.mh, mapping.length);
    }
    for (ImageProxy* proxy : _images) {
        delete proxy;
    }
}


std::string ImageProxyGroup::normalizedPath(const std::string& path)
{
    for (const std::string& prefix : _buildTimePrefixes) {
        std::string fullPath = prefix + path;
        if ( fileExists(fullPath) ) {
            if ( (fullPath.find("/../") != std::string::npos) || (fullPath.find("//") != std::string::npos) || (fullPath.find("/./") != std::string::npos) ) {
                char resolvedPath[PATH_MAX];
                if ( realpath(fullPath.c_str(), resolvedPath) != nullptr ) {
                    std::string resolvedUnPrefixed = &resolvedPath[prefix.size()];
                    return resolvedUnPrefixed;
                }
            }
            break;
        }
    }
    return path;
}


ImageProxy* ImageProxyGroup::findImage(Diagnostics& diag, const std::string& runtimeLoadPath, bool canBeMissing, ImageProxy::RPathChain* rChain)
{
    __block ImageProxy* result = nullptr;
    _pathOverrides.forEachPathVariant(runtimeLoadPath.c_str(), _platform, ^(const char* possiblePath, bool& stop) {
        if ( startsWith(possiblePath, "@rpath/") ) {
            std::string trailing = &possiblePath[6];
            for (const ImageProxy::RPathChain* cur=rChain; cur != nullptr; cur = cur->prev) {
                for (const std::string& rpath : cur->rpaths) {
                    std::string aPath = rpath + trailing;
                    result = findAbsoluteImage(diag, aPath, true, false);
                    if ( result != nullptr ) {
                        _pathToProxy[runtimeLoadPath] = result;
                        stop = true;
                        return;
                    }
                }
            }
            // if cannot be found via current stack of rpaths, check if already found
            auto pos = _pathToProxy.find(possiblePath);
            if ( pos != _pathToProxy.end() ) {
                result = pos->second;
                stop = true;
                return;
            }
        }
        else if ( startsWith(possiblePath, "@loader_path/") ) {
            std::string loaderFile = rChain->inProxy->runtimePath();
            size_t lastSlash = loaderFile.rfind('/');
            if ( lastSlash != std::string::npos ) {
                std::string loaderDir = loaderFile.substr(0, lastSlash);
                std::string newPath = loaderDir + &possiblePath[12];
                result = findAbsoluteImage(diag, newPath, canBeMissing, false);
                if ( result != nullptr ) {
                    _pathToProxy[runtimeLoadPath] = result;
                    stop = true;
                    return;
                }
            }
        }
        else if ( startsWith(possiblePath, "@executable_path/") ) {
            for (const ImageProxy::RPathChain* cur=rChain; cur != nullptr; cur = cur->prev) {
                if ( cur->inProxy->mh()->filetype == MH_EXECUTE ) {
                    std::string mainProg = cur->inProxy->runtimePath();
                    size_t lastSlash = mainProg.rfind('/');
                    if ( lastSlash != std::string::npos ) {
                        std::string mainDir = mainProg.substr(0, lastSlash);
                        std::string newPath = mainDir + &possiblePath[16];
                        result = findAbsoluteImage(diag, newPath, canBeMissing, false);
                        if ( result != nullptr ) {
                            _pathToProxy[runtimeLoadPath] = result;
                            stop = true;
                            return;
                        }
                    }
                }
            }
        }
        else {
            // load command is full path to dylib
            result = findAbsoluteImage(diag, possiblePath, canBeMissing, false);
            if ( result != nullptr ) {
                stop = true;
                return;
            }
        }
    });

    // when building closure, check if an added dylib is an override for something in the cache
    if ( (result != nullptr) && (_groupNum > 1) && !result->isProxyForCachedDylib() ) {
        for (ImageProxyGroup* grp = this; grp != nullptr; grp = grp->_nextSearchGroup) {
            if ( grp->_basedOn == nullptr )
                continue;
            uint32_t indexInGroup;
            launch_cache::ImageGroup imageGroup(grp->_basedOn);
            if ( imageGroup.findImageByPath(runtimeLoadPath.c_str(), indexInGroup) ) {
                result->setOverrideOf(imageGroup.groupNum(), indexInGroup);
                break;
            }
        }
    }

    return result;
}


bool ImageProxyGroup::builtImageStillValid(const launch_cache::Image& image)
{
    // only do checks when running on system
    if ( _buildTimePrefixes.size() != 1 )
        return true;
    if ( _buildTimePrefixes.front().size() != 0 )
        return true;
    if ( _platform != MachOParser::currentPlatform() )
        return true;

    struct stat statBuf;
    bool expectedOnDisk   = image.group().dylibsExpectedOnDisk();
    bool overridableDylib = image.overridableDylib();
    bool cachedDylib      = !image.isDiskImage();
    bool fileFound        = ( ::stat(image.path(), &statBuf) == 0 );

    if ( cachedDylib ) {
        if ( expectedOnDisk ) {
            if ( fileFound ) {
                // macOS case: verify dylib file info matches what it was when cache was built
                return ( (image.fileModTime() == statBuf.st_mtime) && (image.fileINode() == statBuf.st_ino) );
            }
            else {
                // macOS case: dylib missing
                return false;
            }
        }
        else {
            if ( fileFound ) {
                if ( overridableDylib ) {
                    // iOS case: internal install with dylib root
                    return false;
                }
                else {
                    // iOS case: customer install, ignore dylib on disk
                    return true;
                }
            }
            else {
                // iOS case: cached dylib not on disk as expected
                return true;
            }
        }
    }
    else {
        if ( fileFound ) {
            if ( image.validateUsingModTimeAndInode() ) {
                // macOS case: verify dylib file info matches what it was when cache was built
                return ( (image.fileModTime() == statBuf.st_mtime) && (image.fileINode() == statBuf.st_ino) );
            }
            else {
                // FIXME: need to verify file cdhash
                return true;
            }
        }
        else {
            // dylib not on disk as expected
            return false;
        }
    }
}

ImageProxy* ImageProxyGroup::findAbsoluteImage(Diagnostics& diag, const std::string& runtimeLoadPath, bool canBeMissing, bool makeErrorMessage, bool pathIsAlreadyReal)
{
    auto pos = _pathToProxy.find(runtimeLoadPath);
    if ( pos != _pathToProxy.end() )
        return pos->second;

    // see if this ImageProxyGroup is a proxy for an ImageGroup from the dyld shared cache
    if ( _basedOn != nullptr ) {
        uint32_t foundIndex;
        launch_cache::ImageGroup imageGroup(_basedOn);
        if ( imageGroup.findImageByPath(runtimeLoadPath.c_str(), foundIndex) ) {
            launch_cache::Image image = imageGroup.image(foundIndex);
            if ( builtImageStillValid(image) ) {
                ImageProxy* proxy = nullptr;
                if ( _groupNum == 0 ) {
                    const mach_header* mh = (mach_header*)((uint8_t*)(_dyldCache.cacheHeader()) + image.cacheOffset());
                    proxy = new ImageProxy(mh, image.binaryData(), foundIndex, _dyldCache.cacheIsMappedRaw());
                }
                else {
                    DyldSharedCache::MappedMachO* mapping = addMappingIfValidMachO(diag, runtimeLoadPath);
                    if ( mapping != nullptr ) {
                        proxy = new ImageProxy(*mapping, _groupNum, foundIndex, false);
                    }
                }
                if ( proxy != nullptr ) {
                    _pathToProxy[runtimeLoadPath] = proxy;
                    _images.push_back(proxy);
                    if ( runtimeLoadPath != image.path() ) {
                        // lookup path is an alias, add real path too
                        _pathToProxy[image.path()] = proxy;
                    }
                    return proxy;
                }
            }
        }
    }

    if ( _nextSearchGroup != nullptr ) {
        ImageProxy* result = _nextSearchGroup->findAbsoluteImage(diag, runtimeLoadPath, true, false);
        if ( result != nullptr )
            return result;
    }

    // see if this is a symlink to a dylib
    if ( !pathIsAlreadyReal ) {
        for (const std::string& prefix : _buildTimePrefixes) {
            std::string fullPath = prefix + runtimeLoadPath;
            if ( endsWith(prefix, "/") )
                fullPath = prefix.substr(0, prefix.size()-1) + runtimeLoadPath;
            if ( fileExists(fullPath) ) {
                std::string resolvedPath = realFilePath(fullPath);
                if ( !resolvedPath.empty() && (resolvedPath!= fullPath) ) {
                    std::string resolvedRuntimePath = resolvedPath.substr(prefix.size());
                    ImageProxy* proxy = findAbsoluteImage(diag, resolvedRuntimePath, true, false, true);
                    if ( proxy != nullptr )
                        return proxy;
                }
            }
        }
    }

    if ( (_groupNum >= 2) && (_basedOn == nullptr) ) {
        if ( (runtimeLoadPath[0] != '/') && (runtimeLoadPath[0] != '@') ) {
            for (ImageProxy* aProxy : _images) {
                if ( endsWith(aProxy->runtimePath(), runtimeLoadPath) ) {
                    aProxy->setCwdMustBeThisDir();
                    return aProxy;
                }
            }
        }

        DyldSharedCache::MappedMachO* mapping = addMappingIfValidMachO(diag, runtimeLoadPath);
        if ( mapping != nullptr ) {
            ImageProxy* proxy = new ImageProxy(*mapping, _groupNum, (uint32_t)_images.size(), false);
            _pathToProxy[runtimeLoadPath] = proxy;
            _images.push_back(proxy);
            return proxy;
        }
    }

    if ( !canBeMissing && makeErrorMessage ) {
        if ( diag.warnings().empty() ) {
            if ( diag.hasError() ) {
                std::string orgMsg = diag.errorMessage();
                diag.error("'%s' %s", runtimeLoadPath.c_str(), orgMsg.c_str());
            }
            else {
                diag.error("could not find '%s'", runtimeLoadPath.c_str());
            }
        }
        else {
            std::string allTries;
            for (const std::string& warn : diag.warnings()) {
                if ( allTries.empty() )
                    allTries = warn;
                else
                    allTries = allTries + ", " + warn;
            }
            diag.clearWarnings();
            diag.error("could not use '%s'. Did try: %s", runtimeLoadPath.c_str(), allTries.c_str());
        }
    }

    // record locations not found so it can be verified they are still missing at runtime
    _mustBeMissingFiles.insert(runtimeLoadPath);

    return nullptr;
}


DyldSharedCache::MappedMachO* ImageProxyGroup::addMappingIfValidMachO(Diagnostics& diag, const std::string& runtimePath, bool ignoreMainExecutables)
{
    bool fileFound = false;
    for (const std::string& prefix : _buildTimePrefixes) {
        std::string fullPath = prefix + runtimePath;
        struct stat statBuf;
        if ( stat(fullPath.c_str(), &statBuf) != 0 )
            continue;
        fileFound = true;
        // map whole file and determine if it is mach-o or a fat file
        int fd = ::open(fullPath.c_str(), O_RDONLY);
        if ( fd < 0 ) {
            diag.warning("file not open()able '%s' errno=%d", fullPath.c_str(), errno);
            continue;
        }
        size_t len = (size_t)statBuf.st_size;
        size_t offset = 0;
        const void* p = ::mmap(NULL, len, PROT_READ, MAP_PRIVATE, fd, 0);
        if ( p != MAP_FAILED ) {
            size_t sliceLen;
            size_t sliceOffset;
            bool missingSlice;
            Diagnostics fatDiag;
            if ( FatUtil::isFatFileWithSlice(fatDiag, p, len, _archName, sliceOffset, sliceLen, missingSlice) ) {
                // unmap whole file
                ::munmap((void*)p, len);
                // remap just slice
                p = ::mmap(NULL, sliceLen, PROT_READ, MAP_PRIVATE, fd, sliceOffset);
                if ( p != MAP_FAILED ) {
                    offset = sliceOffset;
                    len    = sliceLen;
                }
            }
            else if ( fatDiag.hasError() ) {
                diag.warning("%s", fatDiag.errorMessage().c_str());
            }
            if ( (p != MAP_FAILED) && !missingSlice && MachOParser::isValidMachO(diag, _archName, _platform, p, len, fullPath, ignoreMainExecutables) ) {
                bool issetuid = (statBuf.st_mode & (S_ISUID|S_ISGID));
                bool sip = false; // FIXME
                _ownedMappings.emplace_back(runtimePath, (mach_header*)p, len, issetuid, sip, offset, statBuf.st_mtime, statBuf.st_ino);
                ::close(fd);
                return &_ownedMappings.back();
            }
            else if (p != MAP_FAILED) {
                ::munmap((void*)p, len);
            }
        }
        ::close(fd);
    }
    if ( !fileFound )
        diag.warning("file not found '%s'", runtimePath.c_str());

    return nullptr;
}

static bool dontExamineDir(const std::string& dirPath)
{
    return endsWith(dirPath, ".app") || endsWith(dirPath, ".xctoolchain") || endsWith(dirPath, ".sdk") || endsWith(dirPath, ".platform");
}

void ImageProxyGroup::addExtraMachOsInBundle(const std::string& appDir)
{
    iterateDirectoryTree("", appDir, ^(const std::string& dirPath) { return dontExamineDir(dirPath); }, ^(const std::string& path, const struct stat& statBuf) {
        // ignore files that don't have 'x' bit set (all runnable mach-o files do)
        const bool hasXBit = ((statBuf.st_mode & S_IXOTH) == S_IXOTH);
        if ( !hasXBit )
            return;

        // ignore files too small
        if ( statBuf.st_size < 0x1000 )
            return;

        // if the file is mach-o, add to list
        if ( _pathToProxy.find(path) == _pathToProxy.end() ) {
            Diagnostics  machoDiag;
            DyldSharedCache::MappedMachO* mapping = addMappingIfValidMachO(machoDiag, path, true);
            if ( mapping != nullptr ) {
                ImageProxy* proxy = new ImageProxy(*mapping, _groupNum, (uint32_t)_images.size(), false);
                if ( proxy != nullptr ) {
                    _pathToProxy[path] = proxy;
                    _images.push_back(proxy);
                }
            }
        }
    });
}

// used when building dyld shared cache
ImageProxyGroup* ImageProxyGroup::makeDyldCacheDylibsGroup(Diagnostics& diag, const DyldCacheParser& dyldCache,
                                                           const std::vector<DyldSharedCache::MappedMachO>& cachedDylibs,
                                                           const std::vector<std::string>& buildTimePrefixes,
                                                           const PatchTable& patchTable, bool stubEliminated, bool dylibsExpectedOnDisk)
{
    std::vector<std::string> emptyEnvVars; // Note: this method only used when constructing dyld cache where envs are not used
    std::vector<const BinaryImageGroupData*> noExistingGroups;
    ImageProxyGroup* groupProxy = new ImageProxyGroup(0, dyldCache, nullptr, nullptr, "", noExistingGroups, buildTimePrefixes, emptyEnvVars, stubEliminated, dylibsExpectedOnDisk);
    groupProxy->_patchTable = &patchTable;

    // add every dylib in shared cache to _images
    uint32_t indexInGroup = 0;
    for (const DyldSharedCache::MappedMachO& mapping : cachedDylibs) {
        ImageProxy* proxy = new ImageProxy(mapping, 0, indexInGroup++, true);
        groupProxy->_images.push_back(proxy);
        groupProxy->_pathToProxy[mapping.runtimePath] = proxy;
    }

    // verify libdyld is compatible
    ImageRef libdyldEntryImageRef = ImageRef::makeEmptyImageRef();
    uint32_t libdyldEntryOffset;
    groupProxy->findLibdyldEntry(diag, libdyldEntryImageRef, libdyldEntryOffset);
    if ( diag.hasError() ) {
        delete groupProxy;
        return nullptr;
    }

    // wire up dependents
    bool hadError = false;
    for (size_t i=0; i < groupProxy->_images.size(); ++i) {
        // note: addDependentsShallow() can append to _images, so can't use regular iterator
        ImageProxy* proxy = groupProxy->_images[i];
        proxy->addDependentsShallow(*groupProxy);
        if ( proxy->diagnostics().hasError() ) {
            hadError = true;
            diag.copy(proxy->diagnostics());
            break;
        }
    }

    if ( hadError ) {
        delete groupProxy;
        return nullptr;
    }

    return groupProxy;
}


// used when building dyld shared cache
ImageProxyGroup* ImageProxyGroup::makeOtherOsGroup(Diagnostics& diag, const DyldCacheParser& dyldCache, ImageProxyGroup* cachedDylibsGroup,
                                                   const std::vector<DyldSharedCache::MappedMachO>& otherDylibsAndBundles,
                                                   bool inodesAreSameAsRuntime, const std::vector<std::string>& buildTimePrefixes)
{
    std::vector<std::string> emptyEnvVars; // Note: this method only used when constructing dyld cache where envs are not used
    const BinaryImageGroupData* cachedDylibsGroupData = dyldCache.cachedDylibsGroup();
    std::vector<const BinaryImageGroupData*> existingGroups = { cachedDylibsGroupData };
    ImageProxyGroup          dyldCacheDylibProxyGroup(0, dyldCache, cachedDylibsGroupData, nullptr,           "", existingGroups, buildTimePrefixes, emptyEnvVars);
    ImageProxyGroup* groupProxy = new ImageProxyGroup(1, dyldCache, nullptr,               cachedDylibsGroup, "", existingGroups, buildTimePrefixes, emptyEnvVars,
                                                      false, true, inodesAreSameAsRuntime);

    // add every dylib/bundle in "other: list to _images
    uint32_t indexInGroup = 0;
    for (const DyldSharedCache::MappedMachO& mapping : otherDylibsAndBundles) {
        ImageProxy* proxy = new ImageProxy(mapping, 1, indexInGroup++, false);
        groupProxy->_images.push_back(proxy);
        groupProxy->_pathToProxy[mapping.runtimePath] = proxy;
    }

    // wire up dependents
    for (size_t i=0; i < groupProxy->_images.size(); ++i) {
        // note: addDependentsShallow() can append to _images, so can't use regular iterator
        ImageProxy* proxy = groupProxy->_images[i];
        // note: other-dylibs can only depend on dylibs in this group or group 0, so no need for deep dependents
        proxy->addDependentsShallow(*groupProxy);
        if ( proxy->diagnostics().hasError() ) {
            diag.warning("adding dependents to %s: %s", proxy->runtimePath().c_str(), proxy->diagnostics().errorMessage().c_str());
            proxy->markInvalid();
        }
    }
    // propagate invalidness
    __block bool somethingInvalid;
    do {
        somethingInvalid = false;
        for (ImageProxy* proxy : groupProxy->_images) {
            proxy->forEachDependent(^(ImageProxy* dep, LinkKind) {
                if ( (dep != nullptr) && dep->invalid() && !proxy->invalid()) {
                    proxy->markInvalid();
                    somethingInvalid = true;
                }
            });
        }
    } while (somethingInvalid);

    return groupProxy;
}

// used by closured for dlopen of unknown dylibs
const BinaryImageGroupData* ImageProxyGroup::makeDlopenGroup(Diagnostics& diag, const DyldCacheParser& dyldCache, uint32_t groupNum,
                                                             const std::vector<const BinaryImageGroupData*>& existingGroups,
                                                             const std::string& imagePath, const std::vector<std::string>& envVars)
{
    const std::vector<std::string>& noBuildTimePrefixes = {""};
    ImageProxyGroup dyldCacheDylibProxyGroup(0, dyldCache, existingGroups[0], nullptr,                   "",        existingGroups, noBuildTimePrefixes, envVars);
    ImageProxyGroup dyldCacheOtherProxyGroup(1, dyldCache, nullptr,           &dyldCacheDylibProxyGroup, "",        existingGroups, noBuildTimePrefixes, envVars);
    ImageProxyGroup dlopenGroupProxy(groupNum,  dyldCache, nullptr,           &dyldCacheOtherProxyGroup, imagePath, existingGroups, noBuildTimePrefixes, envVars, false, true, true);

    DyldSharedCache::MappedMachO* topMapping = dlopenGroupProxy.addMappingIfValidMachO(diag, imagePath, true);
    if ( topMapping == nullptr ) {
        if ( diag.noError() ) {
            const std::set<std::string>& warnings = diag.warnings();
            if ( warnings.empty() )
                diag.error("no loadable mach-o in %s", imagePath.c_str());
            else
                diag.error("%s", (*warnings.begin()).c_str());
        }
        return nullptr;
    }

    ImageProxy* topImageProxy = new ImageProxy(*topMapping, groupNum, 0, false);
    if ( topImageProxy == nullptr ) {
        diag.error("can't find slice matching dyld cache in %s", imagePath.c_str());
        return nullptr;
    }
    dlopenGroupProxy._images.push_back(topImageProxy);
    dlopenGroupProxy._pathToProxy[imagePath] = topImageProxy;

    // add all dylibs needed by dylib and are not in dyld cache
    topImageProxy->addDependentsDeep(dlopenGroupProxy, nullptr, false);
    if ( topImageProxy->diagnostics().hasError() ) {
        diag.copy(topImageProxy->diagnostics());
        return nullptr;
    }

    const BinaryImageGroupData* result = dlopenGroupProxy.makeImageGroupBinary(diag);

    return result;
}


// used when building dyld shared cache
BinaryClosureData* ImageProxyGroup::makeClosure(Diagnostics& diag, const DyldCacheParser& dyldCache, ImageProxyGroup* cachedDylibsGroup,
                                                ImageProxyGroup* otherOsDylibs, const DyldSharedCache::MappedMachO& mainProgMapping,
                                                bool inodesAreSameAsRuntime, const std::vector<std::string>& buildTimePrefixes)
{
    // _basedOn can not be set until ImageGroup is built
    if ( cachedDylibsGroup->_basedOn == nullptr ) {
        cachedDylibsGroup->_basedOn = dyldCache.cachedDylibsGroup();
    }
    const BinaryImageGroupData* cachedDylibsGroupData = dyldCache.cachedDylibsGroup();
    const BinaryImageGroupData* otherDylibsGroupData = dyldCache.otherDylibsGroup();
    std::vector<const BinaryImageGroupData*> existingGroups = { cachedDylibsGroupData, otherDylibsGroupData };
    std::vector<std::string> emptyEnvVars; // Note: this method only used when constructing dyld cache where envs are not used
    ImageProxyGroup mainClosureGroupProxy(2, dyldCache, nullptr, otherOsDylibs, mainProgMapping.runtimePath, existingGroups, buildTimePrefixes,
                                          emptyEnvVars, false, true, inodesAreSameAsRuntime);

    ImageProxy* mainProxy = new ImageProxy(mainProgMapping, 2, 0, false);
    if ( mainProxy == nullptr ) {
        diag.error("can't find slice matching dyld cache in %s", mainProgMapping.runtimePath.c_str());
        return nullptr;
    }
    mainClosureGroupProxy._images.push_back(mainProxy);
    mainClosureGroupProxy._pathToProxy[mainProgMapping.runtimePath] = mainProxy;

    return mainClosureGroupProxy.makeClosureBinary(diag, mainProxy, false);
}


bool ImageProxyGroup::addInsertedDylibs(Diagnostics& diag)
{
    __block bool success = true;
    _pathOverrides.forEachInsertedDylib(^(const char* dylibPath) {
        ImageProxy* insertProxy = findAbsoluteImage(diag, dylibPath, false, true);
        if ( insertProxy == nullptr )
            success = false;
    });
    return success;
}

static DyldCacheParser findDyldCache(Diagnostics& diag, const ClosureBuffer::CacheIdent& cacheIdent, task_t requestor, bool* dealloc)
{
    *dealloc = false;
#if !defined(__MAC_OS_X_VERSION_MIN_REQUIRED) || (__MAC_OS_X_VERSION_MIN_REQUIRED >= 101300)
    size_t currentCacheSize;
    const DyldSharedCache* currentCache = (const DyldSharedCache*)_dyld_get_shared_cache_range(&currentCacheSize);
    if ( currentCache != nullptr ) {
        uuid_t currentCacheUUID;
        currentCache->getUUID(currentCacheUUID);
        if ( memcmp(currentCacheUUID, cacheIdent.cacheUUID, 16) == 0 ) 
            return DyldCacheParser((const DyldSharedCache*)currentCache, false);
    }
#endif
    if ( requestor == mach_task_self() ) {
        // handle dyld_closure_util case where -cache_file option maps raw cache file into this process
        const DyldSharedCache* altCache = (DyldSharedCache*)cacheIdent.cacheAddress;
        uuid_t altCacheUUID;
        altCache->getUUID(altCacheUUID);
        if ( memcmp(altCacheUUID, cacheIdent.cacheUUID, 16) == 0 )
            return DyldCacheParser(altCache, true); // only one cache can be mapped into process, so this must be raw
        else
            diag.error("dyld cache uuid has changed");
    }
#if BUILDING_CLOSURED
    else {
        // handle case where requestor to closured is running with a different dyld cache that closured
        uint8_t cacheBuffer[4096];
        mach_vm_size_t actualReadSize = sizeof(cacheBuffer);
        kern_return_t r;
        r = mach_vm_read_overwrite(requestor, cacheIdent.cacheAddress, sizeof(cacheBuffer), (vm_address_t)&cacheBuffer, &actualReadSize);
        if ( r != KERN_SUCCESS ) {
            diag.error("unable to read cache header from requesting process (addr=0x%llX), kern err=%d", cacheIdent.cacheAddress, r);
            return DyldCacheParser(nullptr, false);
        }
        const dyld_cache_header* header = (dyld_cache_header*)cacheBuffer;
        const dyld_cache_mapping_info* mappings = (dyld_cache_mapping_info*)(cacheBuffer + header->mappingOffset);
        vm_address_t bufferAddress = 0;
        r = vm_allocate(mach_task_self(), &bufferAddress, (long)cacheIdent.cacheMappedSize, VM_FLAGS_ANYWHERE);
        if ( r != KERN_SUCCESS ) {
            diag.error("unable to allocate space to copy custom dyld cache (size=0x%llX), kern err=%d", cacheIdent.cacheMappedSize, r);
            return DyldCacheParser(nullptr, false);
        }
        uint64_t slide =  cacheIdent.cacheAddress - mappings[0].address;
        for (int i=0; i < 3; ++i) {
            mach_vm_address_t mappedAddress = bufferAddress + (mappings[i].address - mappings[0].address);
            mach_vm_size_t    mappedSize    = mappings[i].size;
            vm_prot_t         curProt       = VM_PROT_READ;
            vm_prot_t         maxProt       = VM_PROT_READ;
            r = mach_vm_remap(mach_task_self(), &mappedAddress, mappedSize, 0, VM_FLAGS_FIXED | VM_FLAGS_OVERWRITE,
                              requestor, mappings[i].address+slide, true, &curProt, &maxProt, VM_INHERIT_NONE);
            if ( r != KERN_SUCCESS ) {
                 diag.error("unable to mach_vm_remap region %d custom dyld cache (request addr=0x%llX, size=0x%llX), kern err=%d, localBuffer=0x%lX, localMapTarget=0x%llX",
                           i, mappings[i].address+slide, mappedSize, r, (long)bufferAddress, mappedAddress);
                 return DyldCacheParser(nullptr, false);
            }
            if ( curProt != VM_PROT_READ )
                vm_protect(mach_task_self(), (long)mappedAddress, (long)mappedSize, false, VM_PROT_READ);
       }
       *dealloc = true;
       return DyldCacheParser((DyldSharedCache*)bufferAddress, false);  // assumes cache in other process is mapped as three regions
    }
#endif
    return DyldCacheParser(nullptr, false);
}

BinaryClosureData* ImageProxyGroup::makeClosure(Diagnostics& diag, const ClosureBuffer& buffer, task_t requestor, const std::vector<std::string>& buildTimePrefixes)
{
    // unpack buffer
    bool deallocCacheCopy;
    DyldCacheParser dyldCache = findDyldCache(diag, buffer.cacheIndent(), requestor, &deallocCacheCopy);
    if ( diag.hasError() )
        return nullptr;
    const char* mainProg = buffer.targetPath();
    std::vector<std::string> envVars;
    int envCount = buffer.envVarCount();
    const char* envVarCStrings[envCount];
    buffer.copyImageGroups(envVarCStrings);
    for (int i=0; i < envCount; ++i) {
        envVars.push_back(envVarCStrings[i]);
    }

    // make ImageProxyGroups: 0, 1, 2
    const BinaryImageGroupData* cachedDylibsGroupData = dyldCache.cachedDylibsGroup();
    const BinaryImageGroupData* otherDylibsGroupData  = dyldCache.otherDylibsGroup();
    std::vector<std::string> realBuildTimePrefixes;
    for (const std::string& prefix : buildTimePrefixes)  {
        char resolvedPath[PATH_MAX];
        if ( realpath(prefix.c_str(), resolvedPath) != nullptr )
            realBuildTimePrefixes.push_back(resolvedPath);
        else
            realBuildTimePrefixes.push_back(prefix);
    }
    std::vector<const BinaryImageGroupData*> existingGroups = { cachedDylibsGroupData, otherDylibsGroupData };
    ImageProxyGroup dyldCacheDylibProxyGroup(0, dyldCache, cachedDylibsGroupData, nullptr,                   "",       existingGroups, realBuildTimePrefixes, envVars);
    ImageProxyGroup dyldCacheOtherProxyGroup(1, dyldCache, otherDylibsGroupData,  &dyldCacheDylibProxyGroup, "",       existingGroups, realBuildTimePrefixes, envVars);
    ImageProxyGroup mainClosureGroupProxy(   2, dyldCache, nullptr,               &dyldCacheOtherProxyGroup, mainProg, existingGroups, realBuildTimePrefixes, envVars, false, true, true);

    // add any DYLD_INSERTED_LIBRARIES then main program into closure
    BinaryClosureData* result = nullptr;
    if ( mainClosureGroupProxy.addInsertedDylibs(diag) ) {
        ImageProxy* proxy = mainClosureGroupProxy.findAbsoluteImage(diag, mainProg, false, true);
        if ( proxy != nullptr ) {
            // build closure
            result = mainClosureGroupProxy.makeClosureBinary(diag, proxy, false);
        }
    }

    // if client has a different cache, unmap our copy
    if ( deallocCacheCopy )
        vm_deallocate(mach_task_self(), (vm_address_t)dyldCache.cacheHeader(), (long)buffer.cacheIndent().cacheMappedSize);

    return result;
}

ClosureBuffer closured_CreateImageGroup(const ClosureBuffer& input)
{
    Diagnostics diag;
    const BinaryImageGroupData* newGroup = ImageProxyGroup::makeDlopenGroup(diag, input, mach_task_self(), {""});

    if ( diag.noError() ) {
        // on success return the ImageGroup binary in the ClosureBuffer
        dyld3::ClosureBuffer result(newGroup);
        free((void*)newGroup);
        return result;
    }
    else {
        // on failure return the error message in the ClosureBuffer
        dyld3::ClosureBuffer err(diag.errorMessage().c_str());
        return err;
    }
}

const BinaryImageGroupData* ImageProxyGroup::makeDlopenGroup(Diagnostics& diag, const ClosureBuffer& buffer, task_t requestor, const std::vector<std::string>& buildTimePrefixes)
{
    // unpack buffer
    bool deallocCacheCopy;
    DyldCacheParser dyldCache = findDyldCache(diag, buffer.cacheIndent(), requestor, &deallocCacheCopy);
    if ( diag.hasError() )
        return nullptr;

    const char* targetDylib = buffer.targetPath();
    std::vector<std::string> envVars;
    int envCount = buffer.envVarCount();
    const char* envVarCStrings[envCount];
    buffer.copyImageGroups(envVarCStrings);
    for (int i=0; i < envCount; ++i) {
        envVars.push_back(envVarCStrings[i]);
    }
    uint32_t groupCount = buffer.imageGroupCount() + 2;
    const launch_cache::BinaryImageGroupData* groupDataPtrs[groupCount];
    groupDataPtrs[0] = dyldCache.cachedDylibsGroup();
    groupDataPtrs[1] = dyldCache.otherDylibsGroup();
    buffer.copyImageGroups(&groupDataPtrs[2]);

    // build an ImageProxyGroup for each existing group, and one for new group being constructed
    std::vector<const launch_cache::BinaryImageGroupData*> existingGroups;
    std::vector<std::unique_ptr<ImageProxyGroup>> proxies;
    ImageProxyGroup* prevProxy = nullptr;
    for (uint32_t i=0; i < groupCount; ++i) {
        const launch_cache::BinaryImageGroupData* groupData = groupDataPtrs[i];
        existingGroups.push_back(groupData);
        launch_cache::ImageGroup group(groupData);
        uint32_t groupNum = group.groupNum();
        assert(groupNum == proxies.size());
        proxies.emplace_back(new ImageProxyGroup(groupNum, dyldCache, groupData, prevProxy, "", existingGroups, buildTimePrefixes, envVars));
        prevProxy = proxies.back().get();
    }
    ImageProxyGroup dlopenGroupProxy(groupCount, dyldCache, nullptr, prevProxy, targetDylib, existingGroups, buildTimePrefixes, envVars);

    // find and mmap() top level dylib
    DyldSharedCache::MappedMachO* topMapping = dlopenGroupProxy.addMappingIfValidMachO(diag, targetDylib, true);
    if ( topMapping == nullptr ) {
        std::string allWarnings;
        for (const std::string& warn : diag.warnings()) {
            if ( allWarnings.empty() )
                allWarnings = warn;
            else
                allWarnings = allWarnings + ", " + warn;
        }
        diag.clearWarnings();
        diag.error("%s", allWarnings.c_str());
        if ( deallocCacheCopy )
            vm_deallocate(mach_task_self(), (vm_address_t)dyldCache.cacheHeader(), (long)buffer.cacheIndent().cacheMappedSize);
        return nullptr;
    }

    // make ImageProxy for top level dylib
    ImageProxy* topImageProxy = new ImageProxy(*topMapping, groupCount, 0, false);
    if ( topImageProxy == nullptr ) {
        diag.error("can't find slice matching dyld cache in %s", targetDylib);
        if ( deallocCacheCopy )
            vm_deallocate(mach_task_self(), (vm_address_t)dyldCache.cacheHeader(), (long)buffer.cacheIndent().cacheMappedSize);
        return nullptr;
    }
    dlopenGroupProxy._images.push_back(topImageProxy);
    dlopenGroupProxy._pathToProxy[targetDylib] = topImageProxy;

    // add all dylibs needed by dylib and are not in dyld cache
    topImageProxy->addDependentsDeep(dlopenGroupProxy, nullptr, false);
    if ( topImageProxy->diagnostics().hasError() ) {
        diag.copy(topImageProxy->diagnostics());
        if ( deallocCacheCopy )
            vm_deallocate(mach_task_self(), (vm_address_t)dyldCache.cacheHeader(), (long)buffer.cacheIndent().cacheMappedSize);
        return nullptr;
    }

    // construct ImageGroup from ImageProxies
    const BinaryImageGroupData* result = dlopenGroupProxy.makeImageGroupBinary(diag);

    // clean up
    if ( deallocCacheCopy )
        vm_deallocate(mach_task_self(), (vm_address_t)dyldCache.cacheHeader(), (long)buffer.cacheIndent().cacheMappedSize);

    return result;
}




// Used by closured and dyld_closure_util
BinaryClosureData* ImageProxyGroup::makeClosure(Diagnostics& diag, const DyldCacheParser& dyldCache,
                                                const std::string& mainProg, bool includeDylibsInDir,
                                                const std::vector<std::string>& buildTimePrefixes,
                                                const std::vector<std::string>& envVars)
{
    const BinaryImageGroupData* cachedDylibsGroupData = dyldCache.cachedDylibsGroup();
    const BinaryImageGroupData* otherDylibsGroupData  = dyldCache.otherDylibsGroup();
    std::vector<std::string> realBuildTimePrefixes;
    for (const std::string& prefix : buildTimePrefixes)  {
        char resolvedPath[PATH_MAX];
        if ( realpath(prefix.c_str(), resolvedPath) != nullptr )
            realBuildTimePrefixes.push_back(resolvedPath);
        else
            realBuildTimePrefixes.push_back(prefix);
    }
    std::vector<const BinaryImageGroupData*> existingGroups = { cachedDylibsGroupData, otherDylibsGroupData };
    ImageProxyGroup dyldCacheDylibProxyGroup(0, dyldCache, cachedDylibsGroupData, nullptr,                   "",       existingGroups, realBuildTimePrefixes, envVars);
    ImageProxyGroup dyldCacheOtherProxyGroup(1, dyldCache, otherDylibsGroupData,  &dyldCacheDylibProxyGroup, "",       existingGroups, realBuildTimePrefixes, envVars);
    ImageProxyGroup mainClosureGroupProxy(   2, dyldCache, nullptr,               &dyldCacheOtherProxyGroup, mainProg, existingGroups, realBuildTimePrefixes, envVars, false, true, true);

    // add any DYLD_INSERTED_LIBRARIES into closure
    if ( !mainClosureGroupProxy.addInsertedDylibs(diag) )
        return nullptr;

    ImageProxy* proxy = mainClosureGroupProxy.findAbsoluteImage(diag, mainProg, false, true);
    if ( proxy == nullptr )
        return nullptr;

    return mainClosureGroupProxy.makeClosureBinary(diag, proxy, includeDylibsInDir);
}

const char* sSkipPrograms_macOS[] = {
    "/Applications/iBooks.app/Contents/MacOS/iBooks",
};

const char* sSkipPrograms_embeddedOSes[] = {
    "/sbin/launchd",
    "/usr/local/sbin/launchd.debug",
    "/usr/local/sbin/launchd.development"
};

BinaryClosureData* ImageProxyGroup::makeClosureBinary(Diagnostics& diag, ImageProxy* mainProgProxy, bool includeDylibsInDir)
{
    assert(mainProgProxy != nullptr);
    assert(_images.size() >= 1);

    // check black list
    if ( _platform == Platform::macOS ) {
        for (const char* skipProg : sSkipPrograms_macOS) {
            if ( mainProgProxy->runtimePath() == skipProg ) {
                diag.error("black listed program");
                return nullptr;
            }
        }
    } else {
        for (const char* skipProg : sSkipPrograms_embeddedOSes) {
            if ( mainProgProxy->runtimePath() == skipProg ) {
                diag.error("black listed program");
                return nullptr;
            }
        }
    }

    _mainExecutableIndex = (uint32_t)_images.size() - 1;
    // add all dylibs needed by main excutable and are not in dyld cache
    mainProgProxy->addDependentsDeep(*this, nullptr, true);
    if ( mainProgProxy->diagnostics().hasError() ) {
        diag.copy(mainProgProxy->diagnostics());
        return nullptr;
    }

    // if main program is in .app bundle, look for other mach-o files to add to closure for use by dlopen
    bool isAppMainExecutable = false;
    std::string appDir;
    std::string leafName = basePath(mainProgProxy->runtimePath());
    size_t posAppX = mainProgProxy->runtimePath().rfind(std::string("/") + leafName + ".appex/");
    size_t posApp  = mainProgProxy->runtimePath().rfind(std::string("/") + leafName + ".app/");
    if (  posAppX != std::string::npos ) {
        appDir = mainProgProxy->runtimePath().substr(0, posAppX+leafName.size()+7);
        isAppMainExecutable = true;
    }
    else if ( posApp != std::string::npos ) {
        appDir = mainProgProxy->runtimePath().substr(0, posApp+leafName.size()+5);
        isAppMainExecutable = true;
    }
    if ( isAppMainExecutable ) {
        addExtraMachOsInBundle(appDir);
        for (size_t i=0; i < _images.size(); ++i) {
            // note: addDependentsDeep() can append to _images, so can't use regular iterator
            ImageProxy* aProxy = _images[i];
            ImageProxy::RPathChain base = { aProxy, nullptr, mainProgProxy->rpaths() };
            aProxy->addDependentsDeep(*this, &base, false);
            if ( aProxy->diagnostics().hasError() ) {
                aProxy->markInvalid();
                diag.warning("%s could not be added to closure because %s", aProxy->runtimePath().c_str(), aProxy->diagnostics().errorMessage().c_str());
            }
        }
    }
    else if ( includeDylibsInDir ) {
        size_t pos = mainProgProxy->runtimePath().rfind('/');
        if ( pos != std::string::npos ) {
            std::string mainDir = mainProgProxy->runtimePath().substr(0, pos);
            addExtraMachOsInBundle(mainDir);
            for (size_t i=0; i < _images.size(); ++i) {
                // note: addDependentsDeep() can append to _images, so can't use regular iterator
                ImageProxy* aProxy = _images[i];
                aProxy->addDependentsDeep(*this, nullptr, false);
            }
        }
    }

    // add addition dependents of any inserted libraries
    if ( _mainExecutableIndex != 0 ) {
        for (uint32_t i=0; i < _mainExecutableIndex; ++i) {
            _images[i]->addDependentsDeep(*this, nullptr, true);
            if ( _images[i]->diagnostics().hasError() )
                return nullptr;
        }
    }

    // gather warnings from all statically dependent images
    for (ImageProxy* proxy : _images) {
        if ( !proxy->staticallyReferenced() && proxy->diagnostics().hasError() )
            continue;
        diag.copy(proxy->diagnostics());
        if ( diag.hasError() ) {
            return nullptr;
        }
    }

    // get program entry
    MachOParser mainExecutableParser(mainProgProxy->mh(), _dyldCache.cacheIsMappedRaw());
    bool usesCRT;
    uint32_t entryOffset;
    mainExecutableParser.getEntry(entryOffset, usesCRT);

    // build ImageGroupWriter
    launch_cache::ImageGroupWriter groupWriter(_groupNum, mainExecutableParser.uses16KPages(), mainExecutableParser.is64(), _dylibsExpectedOnDisk, _inodesAreSameAsRuntime);
    populateGroupWriter(diag, groupWriter);
    if ( diag.hasError() )
        return nullptr;

    // pre-compute libSystem and libdyld into closure
    ImageRef libdyldEntryImageRef = ImageRef::makeEmptyImageRef();
    uint32_t libdyldEntryOffset;
    findLibdyldEntry(diag, libdyldEntryImageRef, libdyldEntryOffset);
    if ( diag.hasError() )
        return nullptr;
    ImageRef libSystemImageRef = ImageRef::makeEmptyImageRef();

    findLibSystem(diag, mainExecutableParser.isSimulatorBinary(), libSystemImageRef);
    if ( diag.hasError() )
        return nullptr;

    // build info about missing files and env vars
    __block StringPool            stringPool;
    __block std::vector<uint32_t> envVarOffsets;
    std::vector<uint16_t>         missingFileComponentOffsets;
    stringPool.add(" ");
    for (const std::string& path : _mustBeMissingFiles) {
        size_t start = 1;
        size_t slashPos = path.find('/', start);
        while (slashPos != std::string::npos) {
            std::string component = path.substr(start, slashPos - start);
            uint16_t offset = stringPool.add(component);
            missingFileComponentOffsets.push_back(offset);
            start = slashPos + 1;
            slashPos = path.find('/', start);
        }
        std::string lastComponent = path.substr(start);
        uint16_t offset = stringPool.add(lastComponent);
        missingFileComponentOffsets.push_back(offset);
        missingFileComponentOffsets.push_back(0);  // mark end of a path
    }
    missingFileComponentOffsets.push_back(0);  // mark end of all paths
    if ( missingFileComponentOffsets.size() & 1 )
        missingFileComponentOffsets.push_back(0);  // 4-byte align array
    __block uint32_t envVarCount = 0;
    _pathOverrides.forEachEnvVar(^(const char* envVar) {
       envVarOffsets.push_back(stringPool.add(envVar));
       ++envVarCount;
    });

    // 4-byte align string pool size
    stringPool.align();

    // malloc a buffer and fill in ImageGroup part
    uint32_t groupSize             = groupWriter.size();
    uint32_t missingFilesArraySize = (uint32_t)((missingFileComponentOffsets.size()*sizeof(uint16_t) + 3) & (-4));
    uint32_t envVarsSize           = (uint32_t)(envVarOffsets.size()*sizeof(uint32_t));
    uint32_t stringPoolSize        = (uint32_t)stringPool.size();
    size_t allocSize = sizeof(launch_cache::binary_format::Closure)
                     + groupSize
                     + missingFilesArraySize
                     + envVarsSize
                     + stringPoolSize;
    BinaryClosureData* clo = (BinaryClosureData*)malloc(allocSize);
    groupWriter.finalizeTo(diag, _knownGroups, &clo->group);
    launch_cache::ImageGroup cloGroup(&clo->group);
    launch_cache::Image      mainImage(cloGroup.imageBinary(_mainExecutableIndex));

    uint32_t maxImageLoadCount = groupWriter.maxLoadCount(diag, _knownGroups, &clo->group);

    if ( mainImage.isInvalid() ) {
        free((void*)clo);
        diag.error("depends on invalid dylib");
        return nullptr;
    }

    // fill in closure attributes
    clo->magic                          = launch_cache::binary_format::Closure::magicV1;
    clo->usesCRT                        = usesCRT;
    clo->isRestricted                   = mainProgProxy->isSetUID() || mainExecutableParser.isRestricted();
    clo->usesLibraryValidation          = mainExecutableParser.usesLibraryValidation();
    clo->padding                        = 0;
    clo->missingFileComponentsOffset    = offsetof(launch_cache::binary_format::Closure, group) + groupSize;
    clo->dyldEnvVarsOffset              = clo->missingFileComponentsOffset + missingFilesArraySize;
    clo->dyldEnvVarsCount               = envVarCount;
    clo->stringPoolOffset               = clo->dyldEnvVarsOffset + envVarsSize;
    clo->stringPoolSize                 = stringPoolSize;
    clo->libSystemRef                   = libSystemImageRef;
    clo->libDyldRef                     = libdyldEntryImageRef;
    clo->libdyldVectorOffset            = libdyldEntryOffset;
    clo->mainExecutableIndexInGroup     = _mainExecutableIndex;
    clo->mainExecutableEntryOffset      = entryOffset;
    clo->initialImageCount              = maxImageLoadCount;
    _dyldCache.cacheHeader()->getUUID(clo->dyldCacheUUID);

    if ( !mainExecutableParser.getCDHash(clo->mainExecutableCdHash) ) {
        // if no code signature, fill in 16-bytes with UUID then 4 bytes of zero
        bzero(clo->mainExecutableCdHash, 20);
        mainExecutableParser.getUuid(clo->mainExecutableCdHash);
    }
    if ( missingFilesArraySize != 0 )
        memcpy((uint8_t*)clo + clo->missingFileComponentsOffset, &missingFileComponentOffsets[0], missingFileComponentOffsets.size()*sizeof(uint16_t));
    if ( envVarsSize != 0 )
        memcpy((uint8_t*)clo + clo->dyldEnvVarsOffset, &envVarOffsets[0], envVarsSize);
    if ( stringPool.size() != 0 )
        memcpy((uint8_t*)clo + clo->stringPoolOffset, stringPool.buffer(), stringPool.size());

    return clo;
}

const BinaryImageGroupData* ImageProxyGroup::makeImageGroupBinary(Diagnostics& diag, const char* const neverEliminateStubs[])
{
    const bool continueIfErrors = (_groupNum == 1);
    bool uses16KPages = true;
    bool is64 = true;
    if ( !_images.empty() ) {
        MachOParser firstParser(_images.front()->mh(), _dyldCache.cacheIsMappedRaw());
        uses16KPages = firstParser.uses16KPages();
        is64         = firstParser.is64();
    }
    launch_cache::ImageGroupWriter groupWriter(_groupNum, uses16KPages, is64, _dylibsExpectedOnDisk, _inodesAreSameAsRuntime);
    populateGroupWriter(diag, groupWriter, neverEliminateStubs);
    if ( diag.hasError() )
        return nullptr;

    // malloc a buffer and fill in ImageGroup part
    BinaryImageGroupData* groupData = (BinaryImageGroupData*)malloc(groupWriter.size());
    groupWriter.finalizeTo(diag, _knownGroups, groupData);

    if ( !continueIfErrors && groupWriter.isInvalid(0) ) {
        free((void*)groupData);
        diag.error("depends on invalid dylib");
        return nullptr;
    }

    return groupData;
}


void ImageProxyGroup::findLibdyldEntry(Diagnostics& diag, ImageRef& ref, uint32_t& vmOffsetInLibDyld)
{
    Diagnostics libDyldDiag;
    ImageProxy* libDyldProxy = findImage(libDyldDiag, "/usr/lib/system/libdyld.dylib", false, nullptr);
    if ( libDyldProxy == nullptr ) {
        diag.error("can't find libdyld.dylib");
        return;
    }
    ref = ImageRef(0, libDyldProxy->groupNum(), libDyldProxy->indexInGroup());

    // find offset of "dyld3::entryVectorForDyld" in libdyld.dylib
    Diagnostics entryDiag;
    MachOParser::FoundSymbol dyldEntryInfo;
    MachOParser libDyldParser(libDyldProxy->mh(), _dyldCache.cacheIsMappedRaw());
    if ( !libDyldParser.findExportedSymbol(entryDiag, "__ZN5dyld318entryVectorForDyldE", nullptr, dyldEntryInfo, nullptr) ) {
        diag.error("can't find dyld entry point into libdyld.dylib");
        return;
    }
    vmOffsetInLibDyld = (uint32_t)dyldEntryInfo.value;
    const LibDyldEntryVector* entry = (LibDyldEntryVector*)(libDyldParser.content(vmOffsetInLibDyld));
    if ( entry == nullptr ) {
        diag.error("dyld entry point at offset 0x%0X not found in libdyld.dylib", vmOffsetInLibDyld);
        return;
    }
    if ( entry->vectorVersion != LibDyldEntryVector::kCurrentVectorVersion )
        diag.error("libdyld.dylib vector version is incompatible with this dyld cache builder");
    else if ( entry->binaryFormatVersion != launch_cache::binary_format::kFormatVersion )
        diag.error("libdyld.dylib closures binary format version is incompatible with this dyld cache builder");
}

void ImageProxyGroup::findLibSystem(Diagnostics& diag, bool forSimulator, ImageRef& ref)
{
    Diagnostics libSysDiag;
    ImageProxy* libSystemProxy = findImage(libSysDiag, forSimulator ? "/usr/lib/libSystem.dylib" : "/usr/lib/libSystem.B.dylib" , false, nullptr);
    if ( libSystemProxy == nullptr ) {
        diag.error("can't find libSystem.dylib");
        return;
    }
    ref = ImageRef(0, libSystemProxy->groupNum(), libSystemProxy->indexInGroup());
}


std::vector<ImageProxy*> ImageProxyGroup::flatLookupOrder()
{
    std::vector<ImageProxy*> results;
    // start with main executable and any inserted dylibs
    for (uint32_t i=0; i <= _mainExecutableIndex; ++i)
        results.push_back(_images[i]);

    // recursive add dependents of main executable
    _images[_mainExecutableIndex]->addToFlatLookup(results);

    // recursive add dependents of any inserted dylibs
    for (uint32_t i=0; i < _mainExecutableIndex; ++i)
        _images[i]->addToFlatLookup(results);

    return results;
}

void ImageProxyGroup::populateGroupWriter(Diagnostics& diag, launch_cache::ImageGroupWriter& groupWriter, const char* const neverEliminateStubs[])
{
    const bool buildingDylibsInCache = (_groupNum == 0);
    const bool continueIfErrors      = (_groupNum == 1);

    std::unordered_set<std::string>  neverStubEliminate;
    if ( neverEliminateStubs != nullptr ) {
        for (const char* const* nes=neverEliminateStubs; *nes != nullptr; ++nes)
            neverStubEliminate.insert(*nes);
    }
    
    // pass 1: add all images
    const uint64_t cacheUnslideBaseAddress = _dyldCache.cacheHeader()->unslidLoadAddress();
    const uint32_t imageCount = (uint32_t)_images.size();
    groupWriter.setImageCount(imageCount);
    for (uint32_t i=0; i < imageCount; ++i) {
        MachOParser imageParser(_images[i]->mh(), _dyldCache.cacheIsMappedRaw());
        assert((imageParser.inDyldCache() == buildingDylibsInCache) && "all images must be same type");
        // add info for each image
        groupWriter.setImagePath(i, _images[i]->runtimePath().c_str());
        groupWriter.setImageIsBundle(i, (imageParser.fileType() == MH_BUNDLE));
        bool hasObjC = imageParser.hasObjC();
        groupWriter.setImageHasObjC(i, hasObjC);
        bool isEncrypted = imageParser.isEncrypted();
        groupWriter.setImageIsEncrypted(i, isEncrypted);
        bool mayHavePlusLoad = false;
        if ( hasObjC ) {
            mayHavePlusLoad = isEncrypted || imageParser.hasPlusLoadMethod(diag);
            groupWriter.setImageMayHavePlusLoads(i, mayHavePlusLoad);
        }
        groupWriter.setImageHasWeakDefs(i, imageParser.hasWeakDefs());
        groupWriter.setImageMustBeThisDir(i, _images[i]->cwdMustBeThisDir());
        groupWriter.setImageIsPlatformBinary(i, _images[i]->isPlatformBinary());
        groupWriter.setImageOverridableDylib(i, !_stubEliminated || (neverStubEliminate.count(_images[i]->runtimePath()) != 0));
        uuid_t uuid;
        if ( imageParser.getUuid(uuid) )
            groupWriter.setImageUUID(i, uuid);
        if ( _inodesAreSameAsRuntime ) {
            groupWriter.setImageFileMtimeAndInode(i, _images[i]->fileModTime(), _images[i]->fileInode());
        }
        else {
            uint8_t cdHash[20];
            if ( !imageParser.getCDHash(cdHash) )
                bzero(cdHash, 20);
            // if image is not code signed, cdHash filled with all zeros
            groupWriter.setImageCdHash(i, cdHash);
        }
        if ( !buildingDylibsInCache ) {
            groupWriter.setImageSliceOffset(i, _images[i]->sliceFileOffset());
            uint32_t fairPlayTextOffset;
            uint32_t fairPlaySize;
            if ( imageParser.isFairPlayEncrypted(fairPlayTextOffset, fairPlaySize) )
                groupWriter.setImageFairPlayRange(i, fairPlayTextOffset, fairPlaySize);
            uint32_t codeSigOffset;
            uint32_t codeSigSize;
            if ( imageParser.hasCodeSignature(codeSigOffset, codeSigSize) )
                groupWriter.setImageCodeSignatureLocation(i, codeSigOffset, codeSigSize);
        }
        groupWriter.setImageDependentsCount(i, imageParser.dependentDylibCount());
        // add segments to image
        groupWriter.setImageSegments(i, imageParser, cacheUnslideBaseAddress);
        // add initializers to image
        __block std::vector<uint32_t> initOffsets;
        imageParser.forEachInitializer(diag, ^(uint32_t offset) {
            initOffsets.push_back(offset);
        });
        groupWriter.setImageInitializerOffsets(i, initOffsets);
        if ( diag.hasError() && !continueIfErrors ) {
            return;
        }
        // add DOFs to image
        __block std::vector<uint32_t> dofOffsets;
        imageParser.forEachDOFSection(diag, ^(uint32_t offset) {
            dofOffsets.push_back(offset);
        });
        groupWriter.setImageDOFOffsets(i, dofOffsets);
        if ( diag.hasError() && !continueIfErrors ) {
            return;
        }
        bool neverUnload = false;
        if ( buildingDylibsInCache )
            neverUnload = true;
        if ( _images[i]->staticallyReferenced() )
            neverUnload = true;
        if ( imageParser.hasObjC() && (imageParser.fileType() == MH_DYLIB) )
            neverUnload = true;
        if ( imageParser.hasThreadLocalVariables() )
            neverUnload = true;
        if ( !dofOffsets.empty() )
            neverUnload = true;
        groupWriter.setImageNeverUnload(i, neverUnload);
        if ( _images[i]->invalid() )
            groupWriter.setImageInvalid(i);
        // record if this is an override of an OS dylib
        ImageRef stdRef = _images[i]->overrideOf();
        if ( stdRef != ImageRef::weakImportMissing() ) {
            ImageRef thisImageRef(0, _groupNum, i);
            groupWriter.addImageIsOverride(stdRef, thisImageRef);
        }

        // add alias if runtimepath does not match installName
        if ( imageParser.fileType() == MH_DYLIB ) {
            const char* installName = imageParser.installName();
            if ( installName[0] == '/' ) {
                if ( _images[i]->runtimePath() != installName ) {
                    // add install name as an alias
                    groupWriter.addImageAliasPath(i, installName);
                }
            }
            // IOKit.framework on embedded uses not flat bundle, but clients dlopen() it as if it were flat
            if ( buildingDylibsInCache && (_platform != Platform::macOS) && (_images[i]->runtimePath() == "/System/Library/Frameworks/IOKit.framework/Versions/A/IOKit") ) {
                groupWriter.addImageAliasPath(i, "/System/Library/Frameworks/IOKit.framework/IOKit");
            }
        }
    }

    // pass 2: add all dependencies (now that we have indexes defined)
    for (uint32_t i=0; (i < imageCount) && diag.noError(); ++i) {
        // add dependents to image
        __block uint32_t depIndex = 0;
        _images[i]->forEachDependent(^(ImageProxy* dep, LinkKind kind) {
            if ( dep == nullptr ) {
                if ( kind == LinkKind::weak )
                    groupWriter.setImageDependent(i, depIndex, launch_cache::binary_format::ImageRef::weakImportMissing());
                else
                    groupWriter.setImageInvalid(i);
            }
            else {
                launch_cache::binary_format::ImageRef ref((uint8_t)kind, dep->groupNum(), dep->indexInGroup());
                groupWriter.setImageDependent(i, depIndex, ref);
            }
            ++depIndex;
        });
    }

    // pass 3: invalidate any images dependent on invalid images)
    if ( continueIfErrors ) {
        const launch_cache::binary_format::ImageRef missingRef = launch_cache::binary_format::ImageRef::weakImportMissing();
        __block bool somethingInvalidated = false;
        do {
            somethingInvalidated = false;
            for (uint32_t i=0; i < imageCount; ++i) {
                if ( groupWriter.isInvalid(i) )
                    continue;
                uint32_t depCount = groupWriter.imageDependentsCount(i);
                for (uint32_t depIndex=0; depIndex < depCount; ++depIndex) {
                    launch_cache::binary_format::ImageRef ref = groupWriter.imageDependent(i, depIndex);
                    if ( ref == missingRef )
                        continue;
                    if ( ref.groupNum() == _groupNum ) {
                        if ( groupWriter.isInvalid(ref.indexInGroup()) ) {
                            // this image depends on something invalid, so mark it invalid
                            //fprintf(stderr, "warning: image %s depends on invalid %s\n", _images[i]->runtimePath().c_str(), _images[ref.index()]->runtimePath().c_str());
                            groupWriter.setImageInvalid(i);
                            somethingInvalidated = true;
                            break;
                        }
                    }
                }
            }
        } while (somethingInvalidated);
    }

    // pass 4: add fixups for each image, if needed
    bool someBadFixups = false;
    if ( !buildingDylibsInCache ) {
        // compute fix ups for all images
        __block std::vector<ImageProxy::FixupInfo> fixupInfos;
        fixupInfos.resize(imageCount);
        for (uint32_t imageIndex=0; imageIndex < imageCount; ++imageIndex) {
            if ( groupWriter.isInvalid(imageIndex) )
                continue;
            Diagnostics fixupDiag;
            fixupInfos[imageIndex] = _images[imageIndex]->buildFixups(fixupDiag, cacheUnslideBaseAddress, groupWriter);
            if ( fixupDiag.hasError() ) {
                // disable image in group
                someBadFixups = true;
                groupWriter.setImageInvalid(imageIndex);
                if ( continueIfErrors ) {
                    diag.warning("fixup problem in %s: %s", _images[imageIndex]->runtimePath().c_str(), fixupDiag.errorMessage().c_str());
                    continue;
                }
                else {
                    diag.error("fixup problem in %s: %s", _images[imageIndex]->runtimePath().c_str(), fixupDiag.errorMessage().c_str());
                    return;
                }
            }
        }
        // if building closure, build patches to shared cache
        if ( _groupNum == 2) {
            std::unordered_set<ImageProxy*> staticImagesWithWeakDefs;
            ImageProxyGroup* cacheGroup = _nextSearchGroup->_nextSearchGroup;
            assert(cacheGroup->_basedOn != nullptr);
            launch_cache::ImageGroup dyldCacheGroup(cacheGroup->_basedOn);
            for (uint32_t imageIndex=0; imageIndex < imageCount; ++imageIndex) {
                if ( groupWriter.isInvalid(imageIndex) )
                    continue;
                ImageProxy* thisProxy = _images[imageIndex];
                // Only process interposing info on dylibs statically linked into closure
                if ( !thisProxy->staticallyReferenced() )
                    continue;
                MachOParser imageParser(thisProxy->mh(), _dyldCache.cacheIsMappedRaw());
                // if any images in closure interpose on something in dyld cache, record the cache patches needed
                imageParser.forEachInterposingTuple(diag, ^(uint32_t segIndex, uint64_t replacementSegOffset, uint64_t replaceeSegOffset, uint64_t replacementContent, bool& tupleStop) {
                    if ( _groupNum != 2 ) {
                        groupWriter.setImageInvalid(imageIndex);
                        return;
                    }
                    TargetSymbolValue interposeReplacee    = TargetSymbolValue::makeInvalid();
                    TargetSymbolValue interposeReplacement = TargetSymbolValue::makeInvalid();
                    for (const FixUp& fixup : fixupInfos[imageIndex].fixups) {
                        if ( fixup.segIndex != segIndex )
                            continue;
                        if ( fixup.segOffset == replacementSegOffset ) {
                            if ( fixup.type == launch_cache::ImageGroupWriter::FixupType::rebase ) {
                                uint64_t offsetInImage = replacementContent - imageParser.preferredLoadAddress();
                                interposeReplacement = TargetSymbolValue::makeGroupValue(2, imageIndex, offsetInImage, false);
                            }
                            else {
                                diag.warning("bad interposing implementation in %s", _images[imageIndex]->runtimePath().c_str());
                                return;
                            }
                        }
                        else if ( fixup.segOffset ==  replaceeSegOffset ) {
                            if ( fixup.type == launch_cache::ImageGroupWriter::FixupType::pointerBind ) {
                                interposeReplacee = fixup.target;
                            }
                            else {
                                diag.warning("bad interposing target in %s", _images[imageIndex]->runtimePath().c_str());
                                return;
                            }
                        }
                    }
                    // scan through fixups of other images in closure looking to see what functions this entry references
                    for (uint32_t otherIndex=0; otherIndex < imageCount; ++otherIndex) {
                        if ( otherIndex == imageIndex )
                            continue;
                        for (FixUp& fixup : fixupInfos[otherIndex].fixups) {
                            switch ( fixup.type ) {
                                case launch_cache::ImageGroupWriter::FixupType::pointerBind:
                                case launch_cache::ImageGroupWriter::FixupType::pointerLazyBind:
                                    // alter fixup to use interposed function instead of requested
                                    if ( fixup.target == interposeReplacee )
                                        fixup.target = interposeReplacement;
                                    break;
                                case launch_cache::ImageGroupWriter::FixupType::rebase:
                                case launch_cache::ImageGroupWriter::FixupType::rebaseText:
                                case launch_cache::ImageGroupWriter::FixupType::ignore:
                                case launch_cache::ImageGroupWriter::FixupType::bindText:
                                case launch_cache::ImageGroupWriter::FixupType::bindTextRel:
                                case launch_cache::ImageGroupWriter::FixupType::bindImportJmpRel:
                                   break;
                            }
                        }
                    }
                    if ( interposeReplacee.isInvalid() || interposeReplacement.isInvalid() ) {
                        diag.error("malformed interposing section in %s", _images[imageIndex]->runtimePath().c_str());
                        tupleStop = true;
                        return;
                    }
                    // record any overrides in shared cache that will need to be applied at launch time
                    uint64_t offsetInCache;
                    if ( interposeReplacee.isSharedCacheTarget(offsetInCache) ) {
                        uint32_t patchTableIndex;
                        if ( dyldCacheGroup.hasPatchTableIndex((uint32_t)offsetInCache, patchTableIndex) ) {
                            uint32_t    replacementGroupNum;
                            uint32_t    replacementIndexInGroup;
                            uint64_t    replacementOffsetInImage;
                            assert(interposeReplacement.isGroupImageTarget(replacementGroupNum, replacementIndexInGroup, replacementOffsetInImage));
                            assert(replacementGroupNum == 2);
                            assert(replacementIndexInGroup < (1 << 8));
                            assert(replacementOffsetInImage < 0xFFFFFFFFULL);
                            DyldCacheOverride cacheOverride;
                            cacheOverride.patchTableIndex = patchTableIndex;
                            cacheOverride.imageIndex      = replacementIndexInGroup;
                            cacheOverride.imageOffset     = replacementOffsetInImage;
                            _cacheOverrides.push_back(cacheOverride);
                        }
                    }
                });
                if ( diag.hasError() && !continueIfErrors ) {
                    return;
                }
                // if any dylibs in the closure override a dyld cache dylib, then record the cache patches needed
                ImageRef overrideOf = thisProxy->overrideOf();
                if ( (overrideOf != ImageRef::makeEmptyImageRef()) && (overrideOf.groupNum() == 0) ) {
                     //fprintf(stderr, "need to patch %s into cache\n", thisProxy->runtimePath().c_str());
                    const launch_cache::Image imageInCache = dyldCacheGroup.image(overrideOf.indexInGroup());
                    const mach_header* imageInCacheMH = (mach_header*)((char*)(_dyldCache.cacheHeader()) + imageInCache.cacheOffset());
                    MachOParser inCacheParser(imageInCacheMH, _dyldCache.cacheIsMappedRaw());
                    // walk all exported symbols in dylib in cache
                    inCacheParser.forEachExportedSymbol(diag, ^(const char* symbolName, uint64_t imageOffset, bool isReExport, bool &stop) {
                        if ( isReExport )
                            return;
                        uint32_t cacheOffsetOfSymbol = (uint32_t)(imageInCache.cacheOffset() + imageOffset);
                        //fprintf(stderr, "  patch cache offset 0x%08X which is %s\n", cacheOffsetOfSymbol, symbolName);
                        // for each exported symbol, see if it is in patch table (used by something else in cache)
                        uint32_t patchTableIndex;
                        if ( dyldCacheGroup.hasPatchTableIndex(cacheOffsetOfSymbol, patchTableIndex) ) {
                            //fprintf(stderr, "  need patch cache offset 0x%08X\n", cacheOffsetOfSymbol);
                            // lookup address of symbol in override dylib and add patch info
                            MachOParser::FoundSymbol foundInfo;
                            if ( imageParser.findExportedSymbol(diag, symbolName, nullptr, foundInfo, nullptr) ) {
                                DyldCacheOverride cacheOverride;
                                assert(patchTableIndex < (1 << 24));
                                assert(thisProxy->indexInGroup() < (1 << 8));
                                assert(foundInfo.value < (1ULL << 32));
                                cacheOverride.patchTableIndex = patchTableIndex;
                                cacheOverride.imageIndex      = thisProxy->indexInGroup();
                                cacheOverride.imageOffset     = foundInfo.value;
                                _cacheOverrides.push_back(cacheOverride);
                            }
                        }
                    });
                }
                // save off all images in closure with weak defines
                if ( thisProxy->mh()->flags & (MH_WEAK_DEFINES|MH_BINDS_TO_WEAK) ) {
                    staticImagesWithWeakDefs.insert(thisProxy);
                }
            }
            // if any dylibs in the closure override a weak symbol in a cached dylib, then record the cache patches needed
            if ( !staticImagesWithWeakDefs.empty() ) {
                // build list of all weak def symbol names
                __block std::unordered_map<std::string, DyldCacheOverride> weakSymbols;
                for (ImageProxy* proxy : staticImagesWithWeakDefs ) {
                    MachOParser weakDefParser(proxy->mh(), _dyldCache.cacheIsMappedRaw());
                    weakDefParser.forEachWeakDef(diag, ^(bool strongDef, uint32_t segIndex, uint64_t segOffset, uint64_t addend, const char* symbolName, bool& stop) {
                        weakSymbols[symbolName] = { 0, 0, 0 };
                    });
                }
                // do a flat namespace walk of all images
                std::vector<ImageProxy*> flatSearchOrder = flatLookupOrder();
                for (ImageProxy* proxy : flatSearchOrder) {
                    // only look at images that participate in weak coalescing
                    if ( (proxy->mh()->flags & (MH_WEAK_DEFINES|MH_BINDS_TO_WEAK)) == 0 )
                        continue;
                    // look only at images in closure
                    if ( proxy->groupNum() == 2 ) {
                        MachOParser weakDefParser(proxy->mh(), _dyldCache.cacheIsMappedRaw());
                        // check if this closure image defines any of the not-yet found weak symbols
                        for (auto& entry : weakSymbols ) {
                            if ( entry.second.imageOffset != 0 )
                                continue;
                            Diagnostics weakDiag;
                            MachOParser::FoundSymbol foundInfo;
                            if ( weakDefParser.findExportedSymbol(weakDiag, entry.first.c_str(), nullptr, foundInfo, nullptr) ) {
                                assert(proxy->indexInGroup() < (1 << 8));
                                assert(foundInfo.value < (1ULL << 32));
                                entry.second.imageIndex  = proxy->indexInGroup();
                                entry.second.imageOffset = foundInfo.value;
                            }
                        }
                    }
                }
                for (ImageProxy* proxy : flatSearchOrder) {
                    // only look at images that participate in weak coalescing
                    if ( (proxy->mh()->flags & (MH_WEAK_DEFINES|MH_BINDS_TO_WEAK)) == 0 )
                        continue;
                    // look only at images in dyld cache
                    if ( proxy->groupNum() == 0 ) {
                        const launch_cache::Image imageInCache = dyldCacheGroup.image(proxy->indexInGroup());
                        MachOParser inCacheParser(proxy->mh(), _dyldCache.cacheIsMappedRaw());
                        Diagnostics cacheDiag;
                        for (auto& entry : weakSymbols) {
                            if ( entry.second.imageOffset == 0 )
                                continue;
                            Diagnostics weakDiag;
                            MachOParser::FoundSymbol foundInfo;
                            if ( inCacheParser.findExportedSymbol(weakDiag, entry.first.c_str(), nullptr, foundInfo, nullptr) ) {
                                uint32_t cacheOffsetOfSymbol = (uint32_t)(imageInCache.cacheOffset() + foundInfo.value);
                                // see if this symbol is in patch table (used by something else in cache)
                                uint32_t patchTableIndex;
                                if ( dyldCacheGroup.hasPatchTableIndex(cacheOffsetOfSymbol, patchTableIndex) ) {
                                    //fprintf(stderr, "  need patch cache offset 0x%08X\n", cacheOffsetOfSymbol);
                                    DyldCacheOverride cacheOverride;
                                    cacheOverride.patchTableIndex = patchTableIndex;
                                    cacheOverride.imageIndex      = entry.second.imageIndex;
                                    cacheOverride.imageOffset     = entry.second.imageOffset;
                                    _cacheOverrides.push_back(cacheOverride);
                                }
                            }
                        }
                    }
                }
            }
        }
        // record fixups for each image
        for (uint32_t imageIndex=0; imageIndex < imageCount; ++imageIndex) {
            groupWriter.setImageFixups(diag, imageIndex, fixupInfos[imageIndex].fixups, fixupInfos[imageIndex].hasTextRelocs);
        }
    }

    // pass 5: invalidate any images dependent on invalid images)
    if ( someBadFixups && continueIfErrors ) {
        __block bool somethingInvalidated = false;
        do {
            somethingInvalidated = false;
            for (uint32_t i=0; i < imageCount; ++i) {
                if ( groupWriter.isInvalid(i) )
                    continue;
                uint32_t depCount = groupWriter.imageDependentsCount(i);
                for (uint32_t depIndex=0; depIndex < depCount; ++depIndex) {
                    launch_cache::binary_format::ImageRef ref = groupWriter.imageDependent(i, depIndex);
                    if ( ref.groupNum() == _groupNum ) {
                        if ( groupWriter.isInvalid(ref.indexInGroup()) ) {
                            // this image depends on something invalid, so mark it invalid
                            //fprintf(stderr, "warning: image %s depends on invalid %s\n", _images[i]->runtimePath().c_str(), _images[ref.index()]->runtimePath().c_str());
                            groupWriter.setImageInvalid(i);
                            somethingInvalidated = true;
                            break;
                        }
                    }
                }
            }
        } while (somethingInvalidated);
    }

    // pass 6: compute initializer lists for each image
    const bool log = false;
    for (uint32_t imageIndex=0; imageIndex < imageCount; ++imageIndex) {
        if ( groupWriter.isInvalid(imageIndex) )
            continue;

        auto inits = _images[imageIndex]->getInitBeforeList(*this);
        if ( log && buildingDylibsInCache ) {
            fprintf(stderr, "%s\n   init list: ", _images[imageIndex]->runtimePath().c_str());
            for (launch_cache::binary_format::ImageRef ref : inits) {
                if ( ref.groupNum() == 0 ) {
                    std::string dep = _images[ref.indexInGroup()]->runtimePath();
                    size_t off = dep.rfind('/');
                    fprintf(stderr, "%s, ", dep.substr(off+1).c_str());
                }
            }
            fprintf(stderr, "\n");
        }
        groupWriter.setImageInitBefore(imageIndex, inits);
    }

    // pass 7: compute DOFs
    for (uint32_t imageIndex=0; imageIndex < imageCount; ++imageIndex) {
        if ( groupWriter.isInvalid(imageIndex) )
            continue;

        auto inits = _images[imageIndex]->getInitBeforeList(*this);
        if ( log && buildingDylibsInCache ) {
            fprintf(stderr, "%s\n   DOFs: ", _images[imageIndex]->runtimePath().c_str());
            for (launch_cache::binary_format::ImageRef ref : inits) {
                if ( ref.groupNum() == 0 ) {
                    std::string dep = _images[ref.indexInGroup()]->runtimePath();
                    size_t off = dep.rfind('/');
                    fprintf(stderr, "%s, ", dep.substr(off+1).c_str());
                }
            }
            fprintf(stderr, "\n");
        }
        groupWriter.setImageInitBefore(imageIndex, inits);
    }

    // pass 8: add patch table entries iff this is dyld cache ImageGroup
    assert(buildingDylibsInCache == (_patchTable != nullptr));
    if ( _patchTable != nullptr ) {
        for (uint32_t i=0; i < imageCount; ++i) {
            const auto pos = _patchTable->find(_images[i]->mh());
            if ( pos != _patchTable->end() ) {
                for (const auto& entry : pos->second ) {
                    uint32_t defFunctionOffset = entry.first;
                    groupWriter.setImagePatchLocations(i, defFunctionOffset, entry.second);
                }
            }
        }
    }

    // if this is a main closure group with an interposing dylib, add cache overrides
    if ( !_cacheOverrides.empty() ) {
        groupWriter.setGroupCacheOverrides(_cacheOverrides);
    }

    // align string pool
    groupWriter.alignStringPool();
}



} // namespace dyld3