Loading...
--- /dev/null
+++ dyld/dyld-519.2.2/dyld3/shared-cache/OptimizerLinkedit.cpp
@@ -0,0 +1,1180 @@
+/* -*- mode: C++; c-basic-offset: 4; indent-tabs-mode: nil -*-
+ *
+ * Copyright (c) 2014 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 <dirent.h>
+#include <sys/errno.h>
+#include <sys/fcntl.h>
+#include <mach-o/loader.h>
+#include <mach-o/fat.h>
+#include <assert.h>
+
+#include <fstream>
+#include <string>
+#include <algorithm>
+#include <unordered_map>
+#include <unordered_set>
+
+#include "MachOFileAbstraction.hpp"
+#include "Trie.hpp"
+#include "DyldSharedCache.h"
+#include "CacheBuilder.h"
+
+
+#define ALIGN_AS_TYPE(value, type) \
+ ((value + alignof(type) - 1) & (-alignof(type)))
+
+namespace {
+
+template <typename P>
+class SortedStringPool
+{
+public:
+ // add a string and symbol table entry index to be updated later
+ void add(uint32_t symbolIndex, const char* symbolName) {
+ _map[symbolName].push_back(symbolIndex);
+ }
+
+ // copy sorted strings to buffer and update all symbol's string offsets
+ uint32_t copyPoolAndUpdateOffsets(char* dstStringPool, macho_nlist<P>* symbolTable) {
+ // make sorted list of strings
+ std::vector<std::string> allStrings;
+ allStrings.reserve(_map.size());
+ for (auto& entry : _map) {
+ allStrings.push_back(entry.first);
+ }
+ std::sort(allStrings.begin(), allStrings.end());
+ // walk sorted list of strings
+ dstStringPool[0] = '\0'; // tradition for start of pool to be empty string
+ uint32_t poolOffset = 1;
+ for (const std::string& symName : allStrings) {
+ // append string to pool
+ strcpy(&dstStringPool[poolOffset], symName.c_str());
+ // set each string offset of each symbol using it
+ for (uint32_t symbolIndex : _map[symName]) {
+ symbolTable[symbolIndex].set_n_strx(poolOffset);
+ }
+ poolOffset += symName.size() + 1;
+ }
+ // return size of pool
+ return poolOffset;
+ }
+
+ size_t size() {
+ size_t size = 1;
+ for (auto& entry : _map) {
+ size += (entry.first.size() + 1);
+ }
+ return size;
+ }
+
+
+private:
+ std::unordered_map<std::string, std::vector<uint32_t>> _map;
+};
+
+
+
+
+struct LocalSymbolInfo
+{
+ uint32_t dylibOffset;
+ uint32_t nlistStartIndex;
+ uint32_t nlistCount;
+};
+
+
+template <typename P>
+class LinkeditOptimizer {
+public:
+ LinkeditOptimizer(void* cacheBuffer, macho_header<P>* mh, Diagnostics& diag);
+
+ uint32_t linkeditSize() { return _linkeditSize; }
+ uint32_t linkeditOffset() { return _linkeditCacheOffset; }
+ uint64_t linkeditAddr() { return _linkeditAddr; }
+ const char* installName() { return _installName; }
+ void copyWeakBindingInfo(uint8_t* newLinkEditContent, uint32_t& offset);
+ void copyLazyBindingInfo(uint8_t* newLinkEditContent, uint32_t& offset);
+ void copyBindingInfo(uint8_t* newLinkEditContent, uint32_t& offset);
+ void copyExportInfo(uint8_t* newLinkEditContent, uint32_t& offset);
+ void copyExportedSymbols(uint8_t* newLinkEditContent, SortedStringPool<P>& stringPool, uint32_t& offset, uint32_t& symbolIndex);
+ void copyImportedSymbols(uint8_t* newLinkEditContent, SortedStringPool<P>& stringPool, uint32_t& offset, uint32_t& symbolIndex);
+ void copyLocalSymbols(uint8_t* newLinkEditContent, SortedStringPool<P>& stringPool, uint32_t& offset, uint32_t& symbolIndex,
+ bool redact, std::vector<LocalSymbolInfo>& localSymbolInfos,
+ std::vector<macho_nlist<P>>& unmappedLocalSymbols, SortedStringPool<P>& localSymbolsStringPool);
+ void copyFunctionStarts(uint8_t* newLinkEditContent, uint32_t& offset);
+ void copyDataInCode(uint8_t* newLinkEditContent, uint32_t& offset);
+ void copyIndirectSymbolTable(uint8_t* newLinkEditContent, uint32_t& offset);
+ void updateLoadCommands(uint32_t linkeditStartOffset, uint64_t mergedLinkeditAddr, uint64_t newLinkeditSize,
+ uint32_t sharedSymbolTableStartOffset, uint32_t sharedSymbolTableCount,
+ uint32_t sharedSymbolStringsOffset, uint32_t sharedSymbolStringsSize);
+
+ macho_header<P>* machHeader() { return _mh; }
+ const std::vector<const char*> getDownwardDependents() { return _downDependentPaths; }
+ const std::vector<const char*> getAllDependents() { return _allDependentPaths; }
+ const std::vector<const char*> getReExportPaths() { return _reExportPaths; }
+ const std::vector<uint64_t> initializerAddresses() { return _initializerAddresses; }
+ const std::vector<macho_section<P>*> dofSections() { return _dofSections; }
+ uint32_t exportsTrieLinkEditOffset() { return _newExportInfoOffset; }
+ uint32_t exportsTrieLinkEditSize() { return _exportInfoSize; }
+ uint32_t weakBindingLinkEditOffset() { return _newWeakBindingInfoOffset; }
+ uint32_t weakBindingLinkEditSize() { return _newWeakBindingSize; }
+ uint64_t dyldSectionAddress() { return _dyldSectionAddr; }
+ const std::vector<macho_segment_command<P>*>& segCmds() { return _segCmds; }
+
+
+private:
+
+ typedef typename P::uint_t pint_t;
+ typedef typename P::E E;
+
+ macho_header<P>* _mh;
+ void* _cacheBuffer;
+ Diagnostics& _diagnostics;
+ uint32_t _linkeditSize = 0;
+ uint32_t _linkeditCacheOffset = 0;
+ uint64_t _linkeditAddr = 0;
+ const uint8_t* _linkeditBias = nullptr;
+ const char* _installName = nullptr;
+ macho_symtab_command<P>* _symTabCmd = nullptr;
+ macho_dysymtab_command<P>* _dynSymTabCmd = nullptr;
+ macho_dyld_info_command<P>* _dyldInfo = nullptr;
+ macho_linkedit_data_command<P>* _functionStartsCmd = nullptr;
+ macho_linkedit_data_command<P>* _dataInCodeCmd = nullptr;
+ std::vector<macho_segment_command<P>*> _segCmds;
+ std::unordered_map<uint32_t,uint32_t> _oldToNewSymbolIndexes;
+ std::vector<const char*> _reExportPaths;
+ std::vector<const char*> _downDependentPaths;
+ std::vector<const char*> _allDependentPaths;
+ std::vector<uint64_t> _initializerAddresses;
+ std::vector<macho_section<P>*> _dofSections;
+ uint32_t _newWeakBindingInfoOffset = 0;
+ uint32_t _newLazyBindingInfoOffset = 0;
+ uint32_t _newBindingInfoOffset = 0;
+ uint32_t _newExportInfoOffset = 0;
+ uint32_t _exportInfoSize = 0;
+ uint32_t _newWeakBindingSize = 0;
+ uint32_t _newExportedSymbolsStartIndex = 0;
+ uint32_t _newExportedSymbolCount = 0;
+ uint32_t _newImportedSymbolsStartIndex = 0;
+ uint32_t _newImportedSymbolCount = 0;
+ uint32_t _newLocalSymbolsStartIndex = 0;
+ uint32_t _newLocalSymbolCount = 0;
+ uint32_t _newFunctionStartsOffset = 0;
+ uint32_t _newDataInCodeOffset = 0;
+ uint32_t _newIndirectSymbolTableOffset = 0;
+ uint64_t _dyldSectionAddr = 0;
+};
+
+
+
+template <typename P>
+class AcceleratorTables {
+public:
+ AcceleratorTables(DyldSharedCache* cache, uint64_t linkeditStartAddr, Diagnostics& diag, const std::vector<LinkeditOptimizer<P>*>& optimizers);
+
+ uint32_t totalSize() const;
+ void copyTo(uint8_t* buffer);
+
+private:
+ typedef typename P::E E;
+
+ struct NodeChain;
+
+ struct DepNode {
+ std::vector<DepNode*> _dependents;
+ unsigned _depth;
+ const char* _installName;
+
+ DepNode() : _depth(0), _installName(nullptr) { }
+ void computeDepth();
+ static void verifyUnreachable(DepNode* target, NodeChain& chain, Diagnostics& diag, std::unordered_set<DepNode*>& visitedNodes, const std::vector<DepNode*>& from);
+ };
+
+ struct NodeChain {
+ NodeChain* prev;
+ DepNode* node;
+ };
+
+ std::unordered_map<macho_header<P>*, DepNode> _depDAG;
+ std::vector<dyld_cache_image_info_extra> _extraInfo;
+ std::vector<uint8_t> _trieBytes;
+ std::vector<uint16_t> _reExportArray;
+ std::vector<uint16_t> _dependencyArray;
+ std::vector<uint16_t> _bottomUpArray;
+ std::vector<dyld_cache_accelerator_initializer> _initializers;
+ std::vector<dyld_cache_accelerator_dof> _dofSections;
+ std::vector<dyld_cache_range_entry> _rangeTable;
+ std::unordered_map<macho_header<P>*, uint32_t> _machHeaderToImageIndex;
+ std::unordered_map<std::string, macho_header<P>*> _dylibPathToMachHeader;
+ std::unordered_map<macho_header<P>*, LinkeditOptimizer<P>*> _machHeaderToOptimizer;
+ dyld_cache_accelerator_info _acceleratorInfoHeader;
+};
+
+
+template <typename P>
+void AcceleratorTables<P>::AcceleratorTables::DepNode::verifyUnreachable(AcceleratorTables<P>::DepNode* target, struct AcceleratorTables<P>::NodeChain& chain, Diagnostics& diag,
+ std::unordered_set<DepNode*>& visitedNodes, const std::vector<AcceleratorTables<P>::DepNode*>& from) {
+ for (DepNode* node : from) {
+ bool foundCycle = (node == target);
+ for (NodeChain* c = &chain; c->prev != nullptr; c = c->prev) {
+ if ( c->node == target ) {
+ foundCycle = true;
+ break;
+ }
+ }
+ if ( foundCycle ) {
+ NodeChain* chp = &chain;
+ std::string msg = std::string("found cycle for ") + target->_installName;
+ while (chp != nullptr) {
+ msg = msg + "\n " + chp->node->_installName;
+ chp = chp->prev;
+ }
+ diag.warning("%s", msg.c_str());
+ return;
+ }
+
+ if ( visitedNodes.count(node) )
+ continue;
+ visitedNodes.insert(node);
+ NodeChain nextChain;
+ nextChain.prev = &chain;
+ nextChain.node = node;
+ verifyUnreachable(target, nextChain, diag, visitedNodes, node->_dependents);
+ }
+}
+
+const uint16_t kBranchIslandDylibIndex = 0x7FFF;
+
+template <typename P>
+AcceleratorTables<P>::AcceleratorTables(DyldSharedCache* cache, uint64_t linkeditStartAddr, Diagnostics& diag, const std::vector<LinkeditOptimizer<P>*>& optimizers)
+{
+ // build table mapping tables to map between mach_header, index, and optimizer
+ for ( LinkeditOptimizer<P>* op : optimizers ) {
+ _machHeaderToOptimizer[op->machHeader()] = op;
+ }
+ const dyld_cache_mapping_info* mappings = (dyld_cache_mapping_info*)((uint8_t*)cache + cache->header.mappingOffset);
+ uint64_t cacheStartAddress = mappings[0].address;
+ const dyld_cache_image_info* images = (dyld_cache_image_info*)((uint8_t*)cache + cache->header.imagesOffset);
+ for (unsigned i=0; i < cache->header.imagesCount; ++i) {
+ uint64_t segCacheFileOffset = images[i].address - cacheStartAddress;
+ macho_header<P>* mhMapped = (macho_header<P>*)((uint8_t*)cache+segCacheFileOffset);
+ const char* path = (char*)cache + images[i].pathFileOffset;
+ _dylibPathToMachHeader[path] = mhMapped;
+ // don't add alias entries (path offset in pool near start of cache) to header->index map
+ if ( images[i].pathFileOffset > segCacheFileOffset )
+ _machHeaderToImageIndex[mhMapped] = i;
+ }
+
+
+ // build DAG of image dependencies
+ for (LinkeditOptimizer<P>* op : optimizers) {
+ _depDAG[op->machHeader()]._installName = op->installName();
+ }
+ for (LinkeditOptimizer<P>* op : optimizers) {
+ DepNode& node = _depDAG[op->machHeader()];
+ for (const char* depPath : op->getDownwardDependents()) {
+ macho_header<P>* depMH = _dylibPathToMachHeader[depPath];
+ assert(depMH != NULL);
+ DepNode* depNode = &_depDAG[depMH];
+ node._dependents.push_back(depNode);
+ }
+ }
+
+ // check for cycles in DAG
+ for (auto& entry : _depDAG) {
+ DepNode* node = &entry.second;
+ NodeChain chain;
+ chain.prev = nullptr;
+ chain.node = node;
+ std::unordered_set<DepNode*> visitedNodes;
+ DepNode::verifyUnreachable(node, chain, diag, visitedNodes, node->_dependents);
+ }
+
+ // compute depth for each DAG node
+ for (auto& entry : _depDAG) {
+ entry.second.computeDepth();
+ }
+
+ // build sorted (bottom up) list of images
+ std::vector<macho_header<P>*> sortedMachHeaders;
+ sortedMachHeaders.reserve(optimizers.size());
+ for (LinkeditOptimizer<P>* op : optimizers) {
+ if ( strcmp(op->installName(), "dyld_shared_cache_branch_islands") != 0 )
+ sortedMachHeaders.push_back(op->machHeader());
+ else
+ _machHeaderToImageIndex[op->machHeader()] = kBranchIslandDylibIndex;
+ }
+ std::sort(sortedMachHeaders.begin(), sortedMachHeaders.end(),
+ [&](macho_header<P>* lmh, macho_header<P>* rmh) -> bool {
+ if ( _depDAG[lmh]._depth != _depDAG[rmh]._depth )
+ return (_depDAG[lmh]._depth < _depDAG[rmh]._depth);
+ else
+ return (lmh < rmh);
+ });
+
+ // build zeroed array of extra infos
+ dyld_cache_image_info_extra emptyExtra;
+ emptyExtra.exportsTrieAddr = 0;
+ emptyExtra.weakBindingsAddr = 0;
+ emptyExtra.exportsTrieSize = 0;
+ emptyExtra.weakBindingsSize = 0;
+ emptyExtra.dependentsStartArrayIndex = 0;
+ emptyExtra.reExportsStartArrayIndex = 0;
+ _extraInfo.insert(_extraInfo.begin(), sortedMachHeaders.size(), emptyExtra);
+
+ //for ( macho_header<P>* mh : sortedMachHeaders ) {
+ // fprintf(stderr, "depth: %3d mh: %p path: %s\n", _depDAG[mh]._depth, mh, _machHeaderToOptimizer[mh]->installName());
+ //}
+
+ // build dependency table
+ _dependencyArray.push_back(0xFFFF); // reserve 0 slot to be "no-dependencies"
+ for (macho_header<P>* mh : sortedMachHeaders) {
+ LinkeditOptimizer<P>* op = _machHeaderToOptimizer[mh];
+ unsigned index = _machHeaderToImageIndex[mh];
+ auto depPaths = op->getAllDependents();
+ if ( depPaths.empty() ) {
+ _extraInfo[index].dependentsStartArrayIndex = 0;
+ }
+ else {
+ _extraInfo[index].dependentsStartArrayIndex = (uint32_t)_dependencyArray.size();
+ auto downPaths = op->getDownwardDependents();
+ for (const char* depPath : depPaths) {
+ macho_header<P>* depMH = _dylibPathToMachHeader[depPath];
+ uint16_t depIndex = _machHeaderToImageIndex[depMH];
+ if ( std::find(downPaths.begin(), downPaths.end(), depPath) == downPaths.end())
+ depIndex |= 0x8000;
+ _dependencyArray.push_back(depIndex);
+ }
+ _dependencyArray.push_back(0xFFFF); // mark end of list
+ }
+ }
+
+ // build re-exports table
+ _reExportArray.push_back(0xFFFF); // reserve 0 slot to be "no-re-exports"
+ for (macho_header<P>* mh : sortedMachHeaders) {
+ LinkeditOptimizer<P>* op = _machHeaderToOptimizer[mh];
+ unsigned index = _machHeaderToImageIndex[mh];
+ auto reExPaths = op->getReExportPaths();
+ if ( reExPaths.empty() ) {
+ _extraInfo[index].reExportsStartArrayIndex = 0;
+ }
+ else {
+ _extraInfo[index].reExportsStartArrayIndex = (uint32_t)_reExportArray.size();
+ for (const char* reExPath : reExPaths) {
+ macho_header<P>* reExMH = _dylibPathToMachHeader[reExPath];
+ uint32_t reExIndex = _machHeaderToImageIndex[reExMH];
+ _reExportArray.push_back(reExIndex);
+ }
+ _reExportArray.push_back(0xFFFF); // mark end of list
+ }
+ }
+
+ // build ordered list of initializers
+ for (macho_header<P>* mh : sortedMachHeaders) {
+ LinkeditOptimizer<P>* op = _machHeaderToOptimizer[mh];
+ unsigned index = _machHeaderToImageIndex[mh];
+ _bottomUpArray.push_back(index);
+ for (uint64_t initializer : op->initializerAddresses()) {
+ //fprintf(stderr, "0x%08llX %s\n", initializer, op->installName());
+ dyld_cache_accelerator_initializer entry;
+ entry.functionOffset = (uint32_t)(initializer-cacheStartAddress);
+ entry.imageIndex = _machHeaderToImageIndex[mh];
+ _initializers.push_back(entry);
+ }
+ }
+
+ // build ordered list of DOF sections
+ for (macho_header<P>* mh : sortedMachHeaders) {
+ LinkeditOptimizer<P>* op = _machHeaderToOptimizer[mh];
+ assert(op != NULL);
+ unsigned imageIndex = _machHeaderToImageIndex[mh];
+ for (auto& sect : op->dofSections()) {
+ //fprintf(stderr, "0x%08llX %s\n", initializer, op->installName());
+ dyld_cache_accelerator_dof entry;
+ entry.sectionAddress = sect->addr();
+ entry.sectionSize = (uint32_t)sect->size();
+ entry.imageIndex = imageIndex;
+ _dofSections.push_back(entry);
+ }
+ }
+
+ // register exports trie and weak binding info in each dylib with image extra info
+ for (macho_header<P>* mh : sortedMachHeaders) {
+ LinkeditOptimizer<P>* op = _machHeaderToOptimizer[mh];
+ unsigned index = _machHeaderToImageIndex[mh];
+ _extraInfo[index].exportsTrieAddr = op->exportsTrieLinkEditOffset() + linkeditStartAddr;
+ _extraInfo[index].exportsTrieSize = op->exportsTrieLinkEditSize();
+ _extraInfo[index].weakBindingsAddr = op->weakBindingLinkEditOffset() + linkeditStartAddr;
+ _extraInfo[index].weakBindingsSize = op->weakBindingLinkEditSize();
+ }
+
+ // record location of __DATA/__dyld section in libdyld.dylib
+ macho_header<P>* libdyldMH = _dylibPathToMachHeader["/usr/lib/system/libdyld.dylib"];
+ LinkeditOptimizer<P>* libdyldOp = _machHeaderToOptimizer[libdyldMH];
+ uint64_t dyldSectionAddr = libdyldOp->dyldSectionAddress();
+
+ // build range table for fast address->image lookups
+ for (macho_header<P>* mh : sortedMachHeaders) {
+ LinkeditOptimizer<P>* op = _machHeaderToOptimizer[mh];
+ unsigned imageIndex = _machHeaderToImageIndex[mh];
+ for (const macho_segment_command<P>* segCmd : op->segCmds()) {
+ if ( strcmp(segCmd->segname(), "__LINKEDIT") == 0 )
+ continue;
+ dyld_cache_range_entry entry;
+ entry.startAddress = segCmd->vmaddr();
+ entry.size = (uint32_t)segCmd->vmsize();
+ entry.imageIndex = imageIndex;
+ _rangeTable.push_back(entry);
+ }
+ }
+ std::sort(_rangeTable.begin(), _rangeTable.end(),
+ [&](const dyld_cache_range_entry& lRange, const dyld_cache_range_entry& rRange) -> bool {
+ return (lRange.startAddress < rRange.startAddress);
+ });
+
+ // build trie that maps install names to image index
+ std::vector<DylibIndexTrie::Entry> dylibEntrys;
+ for (auto &x : _dylibPathToMachHeader) {
+ const std::string& path = x.first;
+ unsigned index = _machHeaderToImageIndex[x.second];
+ dylibEntrys.push_back(DylibIndexTrie::Entry(path, DylibIndex(index)));
+ }
+ DylibIndexTrie dylibsTrie(dylibEntrys);
+ dylibsTrie.emit(_trieBytes);
+ while ( (_trieBytes.size() % 4) != 0 )
+ _trieBytes.push_back(0);
+
+ // fill out header
+ _acceleratorInfoHeader.version = 1;
+ _acceleratorInfoHeader.imageExtrasCount = (uint32_t)_extraInfo.size();
+ _acceleratorInfoHeader.imagesExtrasOffset = ALIGN_AS_TYPE(sizeof(dyld_cache_accelerator_info), dyld_cache_image_info_extra);
+ _acceleratorInfoHeader.bottomUpListOffset = _acceleratorInfoHeader.imagesExtrasOffset + _acceleratorInfoHeader.imageExtrasCount*sizeof(dyld_cache_image_info_extra);
+ _acceleratorInfoHeader.dylibTrieOffset = _acceleratorInfoHeader.bottomUpListOffset + _acceleratorInfoHeader.imageExtrasCount*sizeof(uint16_t);
+ _acceleratorInfoHeader.dylibTrieSize = (uint32_t)_trieBytes.size();
+ _acceleratorInfoHeader.initializersOffset = ALIGN_AS_TYPE(_acceleratorInfoHeader.dylibTrieOffset + _acceleratorInfoHeader.dylibTrieSize, dyld_cache_accelerator_initializer);
+ _acceleratorInfoHeader.initializersCount = (uint32_t)_initializers.size();
+ _acceleratorInfoHeader.dofSectionsOffset = ALIGN_AS_TYPE(_acceleratorInfoHeader.initializersOffset + _acceleratorInfoHeader.initializersCount*sizeof(dyld_cache_accelerator_initializer), dyld_cache_accelerator_initializer);
+ _acceleratorInfoHeader.dofSectionsCount = (uint32_t)_dofSections.size();
+ _acceleratorInfoHeader.reExportListOffset = ALIGN_AS_TYPE(_acceleratorInfoHeader.dofSectionsOffset + _acceleratorInfoHeader.dofSectionsCount*sizeof(dyld_cache_accelerator_dof), dyld_cache_accelerator_dof);
+ _acceleratorInfoHeader.reExportCount = (uint32_t)_reExportArray.size();
+ _acceleratorInfoHeader.depListOffset = ALIGN_AS_TYPE(_acceleratorInfoHeader.reExportListOffset + _acceleratorInfoHeader.reExportCount*sizeof(uint16_t), uint16_t);
+ _acceleratorInfoHeader.depListCount = (uint32_t)_dependencyArray.size();
+ _acceleratorInfoHeader.rangeTableOffset = ALIGN_AS_TYPE(_acceleratorInfoHeader.depListOffset + _acceleratorInfoHeader.depListCount*sizeof(uint16_t), dyld_cache_range_entry);
+ _acceleratorInfoHeader.rangeTableCount = (uint32_t)_rangeTable.size();
+ _acceleratorInfoHeader.dyldSectionAddr = dyldSectionAddr;
+}
+
+
+template <typename P>
+void AcceleratorTables<P>::DepNode::computeDepth()
+{
+ if ( _depth != 0 )
+ return;
+ _depth = 1;
+ for (DepNode* node : _dependents) {
+ node->computeDepth();
+ if ( node->_depth >= _depth )
+ _depth = node->_depth + 1;
+ }
+}
+
+template <typename P>
+uint32_t AcceleratorTables<P>::totalSize() const
+{
+ return (uint32_t)align(_acceleratorInfoHeader.rangeTableOffset + _acceleratorInfoHeader.rangeTableCount*sizeof(dyld_cache_range_entry), 14);
+}
+
+template <typename P>
+void AcceleratorTables<P>::copyTo(uint8_t* buffer)
+{
+ memcpy(buffer, &_acceleratorInfoHeader, sizeof(dyld_cache_accelerator_info));
+ memcpy(&buffer[_acceleratorInfoHeader.imagesExtrasOffset], &_extraInfo[0], _extraInfo.size()*sizeof(dyld_cache_image_info_extra));
+ memcpy(&buffer[_acceleratorInfoHeader.bottomUpListOffset], &_bottomUpArray[0], _bottomUpArray.size()*sizeof(uint16_t));
+ memcpy(&buffer[_acceleratorInfoHeader.initializersOffset], &_initializers[0], _initializers.size()*sizeof(dyld_cache_accelerator_initializer));
+ memcpy(&buffer[_acceleratorInfoHeader.reExportListOffset], &_reExportArray[0], _reExportArray.size()*sizeof(uint16_t));
+ memcpy(&buffer[_acceleratorInfoHeader.dofSectionsOffset], &_dofSections[0], _dofSections.size()*sizeof(dyld_cache_accelerator_dof));
+ memcpy(&buffer[_acceleratorInfoHeader.depListOffset], &_dependencyArray[0], _dependencyArray.size()*sizeof(uint16_t));
+ memcpy(&buffer[_acceleratorInfoHeader.rangeTableOffset], &_rangeTable[0], _rangeTable.size()*sizeof(dyld_cache_range_entry));
+ memcpy(&buffer[_acceleratorInfoHeader.dylibTrieOffset], &_trieBytes[0], _trieBytes.size());
+}
+
+
+
+template <typename P>
+LinkeditOptimizer<P>::LinkeditOptimizer(void* cacheBuffer, macho_header<P>* mh, Diagnostics& diag)
+: _mh(mh), _cacheBuffer(cacheBuffer), _diagnostics(diag)
+{
+ _linkeditBias = (uint8_t*)cacheBuffer;
+ const unsigned origLoadCommandsSize = mh->sizeofcmds();
+ unsigned bytesRemaining = origLoadCommandsSize;
+ unsigned removedCount = 0;
+ const macho_load_command<P>* const cmds = (macho_load_command<P>*)((uint8_t*)mh + sizeof(macho_header<P>));
+ const uint32_t cmdCount = mh->ncmds();
+ const macho_load_command<P>* cmd = cmds;
+ const macho_dylib_command<P>* dylibCmd;
+ const macho_routines_command<P>* routinesCmd;
+ macho_segment_command<P>* segCmd;
+ for (uint32_t i = 0; i < cmdCount; ++i) {
+ bool remove = false;
+ switch (cmd->cmd()) {
+ case LC_ID_DYLIB:
+ _installName = ((macho_dylib_command<P>*)cmd)->name();
+ break;
+ case LC_SYMTAB:
+ _symTabCmd = (macho_symtab_command<P>*)cmd;
+ break;
+ case LC_DYSYMTAB:
+ _dynSymTabCmd = (macho_dysymtab_command<P>*)cmd;
+ break;
+ case LC_DYLD_INFO:
+ case LC_DYLD_INFO_ONLY:
+ _dyldInfo = (macho_dyld_info_command<P>*)cmd;
+ _exportInfoSize = _dyldInfo->export_size();
+ break;
+ case LC_FUNCTION_STARTS:
+ _functionStartsCmd = (macho_linkedit_data_command<P>*)cmd;
+ break;
+ case LC_DATA_IN_CODE:
+ _dataInCodeCmd = (macho_linkedit_data_command<P>*)cmd;
+ break;
+ case LC_ROUTINES:
+ case LC_ROUTINES_64:
+ routinesCmd = (macho_routines_command<P>*)cmd;
+ _initializerAddresses.push_back(routinesCmd->init_address());
+ break;
+ case LC_REEXPORT_DYLIB:
+ case LC_LOAD_DYLIB:
+ case LC_LOAD_WEAK_DYLIB:
+ case LC_LOAD_UPWARD_DYLIB:
+ dylibCmd = (macho_dylib_command<P>*)cmd;
+ _allDependentPaths.push_back(dylibCmd->name());
+ if ( cmd->cmd() != LC_LOAD_UPWARD_DYLIB )
+ _downDependentPaths.push_back(dylibCmd->name());
+ if ( cmd->cmd() == LC_REEXPORT_DYLIB )
+ _reExportPaths.push_back(dylibCmd->name());
+ break;
+ case macho_segment_command<P>::CMD:
+ segCmd = (macho_segment_command<P>*)cmd;
+ _segCmds.push_back(segCmd);
+ if ( strcmp(segCmd->segname(), "__LINKEDIT") == 0 ) {
+ _linkeditSize = (uint32_t)segCmd->vmsize();
+ _linkeditCacheOffset = (uint32_t)segCmd->fileoff();
+ _linkeditAddr = segCmd->vmaddr();
+ }
+ else if ( segCmd->nsects() > 0 ) {
+ macho_section<P>* const sectionsStart = (macho_section<P>*)((uint8_t*)segCmd + sizeof(macho_segment_command<P>));
+ macho_section<P>* const sectionsEnd = §ionsStart[segCmd->nsects()];
+ for (macho_section<P>* sect=sectionsStart; sect < sectionsEnd; ++sect) {
+ const uint8_t type = sect->flags() & SECTION_TYPE;
+ if ( type == S_MOD_INIT_FUNC_POINTERS ) {
+ const pint_t* inits = (pint_t*)((char*)cacheBuffer + sect->offset());
+ const size_t count = sect->size() / sizeof(pint_t);
+ for (size_t j=0; j < count; ++j) {
+ uint64_t func = P::getP(inits[j]);
+ _initializerAddresses.push_back(func);
+ }
+ }
+ else if ( type == S_DTRACE_DOF ) {
+ _dofSections.push_back(sect);
+ }
+ else if ( (strcmp(sect->sectname(), "__dyld") == 0) && (strncmp(sect->segname(), "__DATA", 6) == 0) ) {
+ _dyldSectionAddr = sect->addr();
+ }
+ }
+ }
+ break;
+ case LC_SEGMENT_SPLIT_INFO:
+ remove = true;
+ break;
+ }
+ uint32_t cmdSize = cmd->cmdsize();
+ macho_load_command<P>* nextCmd = (macho_load_command<P>*)(((uint8_t*)cmd)+cmdSize);
+ if ( remove ) {
+ ::memmove((void*)cmd, (void*)nextCmd, bytesRemaining);
+ ++removedCount;
+ }
+ else {
+ bytesRemaining -= cmdSize;
+ cmd = nextCmd;
+ }
+ }
+ // zero out stuff removed
+ ::bzero((void*)cmd, bytesRemaining);
+ // update header
+ mh->set_ncmds(cmdCount - removedCount);
+ mh->set_sizeofcmds(origLoadCommandsSize - bytesRemaining);
+}
+
+/*
+static void dumpLoadCommands(const uint8_t* mheader)
+{
+ const mach_header* const mh = (mach_header*)mheader;
+ const uint32_t cmd_count = mh->ncmds;
+ bool is64 = (mh->magic == MH_MAGIC_64);
+ const load_command* cmds = (load_command*)(mheader + (is64 ? sizeof(mach_header_64) : sizeof(mach_header)));
+ const load_command* cmd = cmds;
+ const segment_command* segCmd;
+ const segment_command_64* seg64Cmd;
+ const symtab_command* symTab;
+ const linkedit_data_command* leData;
+ const uint8_t* linkEditBias = NULL;
+ for (uint32_t i = 0; i < cmd_count; ++i) {
+ switch (cmd->cmd) {
+ case LC_SEGMENT:
+ segCmd = (const segment_command*)cmd;
+ printf("LC_SEGMENT\n");
+ printf(" segname = %s\n", segCmd->segname);
+ printf(" vmaddr = 0x%08X\n", segCmd->vmaddr);
+ printf(" vmsize = 0x%08X\n", segCmd->vmsize);
+ printf(" fileoff = 0x%08X\n", segCmd->fileoff);
+ printf(" filesize = 0x%08X\n", segCmd->filesize);
+ if ( strcmp(segCmd->segname, "__TEXT") == 0 ) {
+ linkEditBias = mheader - segCmd->fileoff;
+ }
+ break;
+ case LC_SEGMENT_64:
+ seg64Cmd = (const segment_command_64*)cmd;
+ printf("LC_SEGMENT_64\n");
+ printf(" segname = %s\n", seg64Cmd->segname);
+ printf(" vmaddr = 0x%09llX\n", seg64Cmd->vmaddr);
+ printf(" vmsize = 0x%09llX\n", seg64Cmd->vmsize);
+ printf(" fileoff = 0x%09llX\n", seg64Cmd->fileoff);
+ printf(" filesize = 0x%09llX\n", seg64Cmd->filesize);
+ if ( strcmp(seg64Cmd->segname, "__TEXT") == 0 ) {
+ linkEditBias = mheader - seg64Cmd->fileoff;
+ }
+ break;
+ case LC_SYMTAB:
+ symTab = (const symtab_command*)cmd;
+ printf("LC_SYMTAB\n");
+ printf(" symoff = 0x%08X\n", symTab->symoff);
+ printf(" nsyms = 0x%08X\n", symTab->nsyms);
+ printf(" stroff = 0x%08X\n", symTab->stroff);
+ printf(" strsize = 0x%08X\n", symTab->strsize);
+ {
+ const char* strPool = (char*)&linkEditBias[symTab->stroff];
+ const nlist_64* sym0 = (nlist_64*)(&linkEditBias[symTab->symoff]);
+ printf(" sym[0].n_strx = 0x%08X (%s)\n", sym0->n_un.n_strx, &strPool[sym0->n_un.n_strx]);
+ printf(" sym[0].n_type = 0x%02X\n", sym0->n_type);
+ printf(" sym[0].n_sect = 0x%02X\n", sym0->n_sect);
+ printf(" sym[0].n_desc = 0x%04X\n", sym0->n_desc);
+ printf(" sym[0].n_value = 0x%llX\n", sym0->n_value);
+ const nlist_64* sym1 = (nlist_64*)(&linkEditBias[symTab->symoff+16]);
+ printf(" sym[1].n_strx = 0x%08X (%s)\n", sym1->n_un.n_strx, &strPool[sym1->n_un.n_strx]);
+ printf(" sym[1].n_type = 0x%02X\n", sym1->n_type);
+ printf(" sym[1].n_sect = 0x%02X\n", sym1->n_sect);
+ printf(" sym[1].n_desc = 0x%04X\n", sym1->n_desc);
+ printf(" sym[1].n_value = 0x%llX\n", sym1->n_value);
+ }
+ break;
+ case LC_FUNCTION_STARTS:
+ leData = (const linkedit_data_command*)cmd;
+ printf("LC_FUNCTION_STARTS\n");
+ printf(" dataoff = 0x%08X\n", leData->dataoff);
+ printf(" datasize = 0x%08X\n", leData->datasize);
+ default:
+ //printf("0x%08X\n", cmd->cmd);
+ break;
+ }
+ cmd = (const load_command*)(((uint8_t*)cmd)+cmd->cmdsize);
+ }
+}
+*/
+
+template <typename P>
+void LinkeditOptimizer<P>::updateLoadCommands(uint32_t mergedLinkeditStartOffset, uint64_t mergedLinkeditAddr, uint64_t newLinkeditSize,
+ uint32_t sharedSymbolTableStartOffset, uint32_t sharedSymbolTableCount,
+ uint32_t sharedSymbolStringsOffset, uint32_t sharedSymbolStringsSize)
+{
+ // update __LINKEDIT segment in all dylibs to overlap the same shared region
+ for (macho_segment_command<P>* segCmd : _segCmds) {
+ if ( strcmp(segCmd->segname(), "__LINKEDIT") == 0 ) {
+ segCmd->set_vmaddr(mergedLinkeditAddr);
+ segCmd->set_vmsize(newLinkeditSize);
+ segCmd->set_fileoff(mergedLinkeditStartOffset);
+ segCmd->set_filesize(newLinkeditSize);
+ }
+ else if ( strcmp(segCmd->segname(), "__TEXT") == 0 ) {
+ // HACK until lldb fixed in: <rdar://problem/20357466> DynamicLoaderMacOSXDYLD fixes for Monarch dyld shared cache
+ //segCmd->set_fileoff(0);
+
+ }
+ }
+
+ // update symbol table to point to shared symbol table
+ _symTabCmd->set_symoff(mergedLinkeditStartOffset + sharedSymbolTableStartOffset + _newLocalSymbolsStartIndex*sizeof(macho_nlist<P>));
+ _symTabCmd->set_nsyms(_newLocalSymbolCount+_newExportedSymbolCount+_newImportedSymbolCount);
+ _symTabCmd->set_stroff(mergedLinkeditStartOffset + sharedSymbolStringsOffset);
+ _symTabCmd->set_strsize(sharedSymbolStringsSize);
+
+ // update dynamic symbol table to have proper offsets into shared symbol table
+ _dynSymTabCmd->set_ilocalsym(0);
+ _dynSymTabCmd->set_nlocalsym(_newLocalSymbolCount);
+ _dynSymTabCmd->set_iextdefsym(_newExportedSymbolsStartIndex-_newLocalSymbolsStartIndex);
+ _dynSymTabCmd->set_nextdefsym(_newExportedSymbolCount);
+ _dynSymTabCmd->set_iundefsym(_newImportedSymbolsStartIndex-_newLocalSymbolsStartIndex);
+ _dynSymTabCmd->set_nundefsym(_newImportedSymbolCount);
+ _dynSymTabCmd->set_tocoff(0);
+ _dynSymTabCmd->set_ntoc(0);
+ _dynSymTabCmd->set_modtaboff(0);
+ _dynSymTabCmd->set_nmodtab(0);
+ _dynSymTabCmd->set_indirectsymoff(mergedLinkeditStartOffset + _newIndirectSymbolTableOffset);
+ _dynSymTabCmd->set_extreloff(0);
+ _dynSymTabCmd->set_locreloff(0);
+ _dynSymTabCmd->set_nlocrel(0);
+
+ // update dyld info
+ if ( _dyldInfo != nullptr ) {
+ _dyldInfo->set_rebase_off(0);
+ _dyldInfo->set_rebase_size(0);
+ _dyldInfo->set_bind_off(_dyldInfo->bind_size() ? mergedLinkeditStartOffset + _newBindingInfoOffset : 0);
+ _dyldInfo->set_weak_bind_off(_dyldInfo->weak_bind_size() ? mergedLinkeditStartOffset + _newWeakBindingInfoOffset : 0 );
+ _dyldInfo->set_lazy_bind_off(_dyldInfo->lazy_bind_size() ? mergedLinkeditStartOffset + _newLazyBindingInfoOffset : 0 );
+ _dyldInfo->set_export_off(mergedLinkeditStartOffset + _newExportInfoOffset);
+ }
+
+ // update function-starts
+ if ( _functionStartsCmd != nullptr )
+ _functionStartsCmd->set_dataoff(mergedLinkeditStartOffset+_newFunctionStartsOffset);
+
+ // update data-in-code
+ if ( _dataInCodeCmd != nullptr )
+ _dataInCodeCmd->set_dataoff(mergedLinkeditStartOffset+_newDataInCodeOffset);
+}
+
+template <typename P>
+void LinkeditOptimizer<P>::copyWeakBindingInfo(uint8_t* newLinkEditContent, uint32_t& offset)
+{
+ if ( _dyldInfo == nullptr )
+ return;
+ unsigned size = _dyldInfo->weak_bind_size();
+ if ( size != 0 ) {
+ ::memcpy(&newLinkEditContent[offset], &_linkeditBias[_dyldInfo->weak_bind_off()], size);
+ _newWeakBindingInfoOffset = offset;
+ _newWeakBindingSize = size;
+ offset += size;
+ }
+}
+
+
+template <typename P>
+void LinkeditOptimizer<P>::copyLazyBindingInfo(uint8_t* newLinkEditContent, uint32_t& offset)
+{
+ if ( _dyldInfo == nullptr )
+ return;
+ unsigned size = _dyldInfo->lazy_bind_size();
+ if ( size != 0 ) {
+ ::memcpy(&newLinkEditContent[offset], &_linkeditBias[_dyldInfo->lazy_bind_off()], size);
+ _newLazyBindingInfoOffset = offset;
+ offset += size;
+ }
+}
+
+template <typename P>
+void LinkeditOptimizer<P>::copyBindingInfo(uint8_t* newLinkEditContent, uint32_t& offset)
+{
+ if ( _dyldInfo == nullptr )
+ return;
+ unsigned size = _dyldInfo->bind_size();
+ if ( size != 0 ) {
+ ::memcpy(&newLinkEditContent[offset], &_linkeditBias[_dyldInfo->bind_off()], size);
+ _newBindingInfoOffset = offset;
+ offset += size;
+ }
+}
+
+template <typename P>
+void LinkeditOptimizer<P>::copyExportInfo(uint8_t* newLinkEditContent, uint32_t& offset)
+{
+ if ( _dyldInfo == nullptr )
+ return;
+ unsigned size = _dyldInfo->export_size();
+ if ( size != 0 ) {
+ ::memcpy(&newLinkEditContent[offset], &_linkeditBias[_dyldInfo->export_off()], size);
+ _newExportInfoOffset = offset;
+ offset += size;
+ }
+}
+
+
+template <typename P>
+void LinkeditOptimizer<P>::copyFunctionStarts(uint8_t* newLinkEditContent, uint32_t& offset)
+{
+ if ( _functionStartsCmd == nullptr )
+ return;
+ unsigned size = _functionStartsCmd->datasize();
+ ::memcpy(&newLinkEditContent[offset], &_linkeditBias[_functionStartsCmd->dataoff()], size);
+ _newFunctionStartsOffset = offset;
+ offset += size;
+}
+
+template <typename P>
+void LinkeditOptimizer<P>::copyDataInCode(uint8_t* newLinkEditContent, uint32_t& offset)
+{
+ if ( _dataInCodeCmd == nullptr )
+ return;
+ unsigned size = _dataInCodeCmd->datasize();
+ ::memcpy(&newLinkEditContent[offset], &_linkeditBias[_dataInCodeCmd->dataoff()], size);
+ _newDataInCodeOffset = offset;
+ offset += size;
+}
+
+
+template <typename P>
+void LinkeditOptimizer<P>::copyLocalSymbols(uint8_t* newLinkEditContent, SortedStringPool<P>& stringPool, uint32_t& offset, uint32_t& symbolIndex,
+ bool redact, std::vector<LocalSymbolInfo>& localSymbolInfos,
+ std::vector<macho_nlist<P>>& unmappedLocalSymbols, SortedStringPool<P>& localSymbolsStringPool)
+{
+ LocalSymbolInfo localInfo;
+ localInfo.dylibOffset = (uint32_t)(((uint8_t*)_mh) - (uint8_t*)_cacheBuffer);
+ localInfo.nlistStartIndex = (uint32_t)unmappedLocalSymbols.size();
+ localInfo.nlistCount = 0;
+ _newLocalSymbolsStartIndex = symbolIndex;
+ const char* strings = (char*)&_linkeditBias[_symTabCmd->stroff()];
+ const macho_nlist<P>* const symbolTable = (macho_nlist<P>*)(&_linkeditBias[_symTabCmd->symoff()]);
+ const macho_nlist<P>* const firstExport = &symbolTable[_dynSymTabCmd->ilocalsym()];
+ const macho_nlist<P>* const lastExport = &symbolTable[_dynSymTabCmd->ilocalsym()+_dynSymTabCmd->nlocalsym()];
+ for (const macho_nlist<P>* entry = firstExport; entry < lastExport; ++entry) {
+ if ( (entry->n_type() & N_TYPE) != N_SECT)
+ continue;
+ if ( (entry->n_type() & N_STAB) != 0)
+ continue;
+ const char* name = &strings[entry->n_strx()];
+ macho_nlist<P>* newSymbolEntry = (macho_nlist<P>*)&newLinkEditContent[offset];
+ *newSymbolEntry = *entry;
+ if ( redact ) {
+ // if removing local symbols, change __text symbols to "<redacted>" so backtraces don't have bogus names
+ if ( entry->n_sect() == 1 ) {
+ stringPool.add(symbolIndex, "<redacted>");
+ ++symbolIndex;
+ offset += sizeof(macho_nlist<P>);
+ }
+ // copy local symbol to unmmapped locals area
+ localSymbolsStringPool.add((uint32_t)unmappedLocalSymbols.size(), name);
+ unmappedLocalSymbols.push_back(*entry);
+ unmappedLocalSymbols.back().set_n_strx(0);
+ }
+ else {
+ stringPool.add(symbolIndex, name);
+ ++symbolIndex;
+ offset += sizeof(macho_nlist<P>);
+ }
+ }
+ _newLocalSymbolCount = symbolIndex - _newLocalSymbolsStartIndex;
+ localInfo.nlistCount = (uint32_t)unmappedLocalSymbols.size() - localInfo.nlistStartIndex;
+ localSymbolInfos.push_back(localInfo);
+}
+
+
+template <typename P>
+void LinkeditOptimizer<P>::copyExportedSymbols(uint8_t* newLinkEditContent, SortedStringPool<P>& stringPool, uint32_t& offset, uint32_t& symbolIndex)
+{
+ _newExportedSymbolsStartIndex = symbolIndex;
+ const char* strings = (char*)&_linkeditBias[_symTabCmd->stroff()];
+ const macho_nlist<P>* const symbolTable = (macho_nlist<P>*)(&_linkeditBias[_symTabCmd->symoff()]);
+ const macho_nlist<P>* const firstExport = &symbolTable[_dynSymTabCmd->iextdefsym()];
+ const macho_nlist<P>* const lastExport = &symbolTable[_dynSymTabCmd->iextdefsym()+_dynSymTabCmd->nextdefsym()];
+ uint32_t oldSymbolIndex = _dynSymTabCmd->iextdefsym();
+ for (const macho_nlist<P>* entry = firstExport; entry < lastExport; ++entry, ++oldSymbolIndex) {
+ if ( (entry->n_type() & N_TYPE) != N_SECT)
+ continue;
+ const char* name = &strings[entry->n_strx()];
+ if ( strncmp(name, ".objc_", 6) == 0 )
+ continue;
+ if ( strncmp(name, "$ld$", 4) == 0 )
+ continue;
+ macho_nlist<P>* newSymbolEntry = (macho_nlist<P>*)&newLinkEditContent[offset];
+ *newSymbolEntry = *entry;
+ newSymbolEntry->set_n_strx(0);
+ stringPool.add(symbolIndex, name);
+ _oldToNewSymbolIndexes[oldSymbolIndex] = symbolIndex - _newLocalSymbolsStartIndex;
+ ++symbolIndex;
+ offset += sizeof(macho_nlist<P>);
+ }
+ _newExportedSymbolCount = symbolIndex - _newExportedSymbolsStartIndex;
+}
+
+template <typename P>
+void LinkeditOptimizer<P>::copyImportedSymbols(uint8_t* newLinkEditContent, SortedStringPool<P>& stringPool, uint32_t& offset, uint32_t& symbolIndex)
+{
+ _newImportedSymbolsStartIndex = symbolIndex;
+ const char* strings = (char*)&_linkeditBias[_symTabCmd->stroff()];
+ const macho_nlist<P>* const symbolTable = (macho_nlist<P>*)(&_linkeditBias[_symTabCmd->symoff()]);
+ const macho_nlist<P>* const firstImport = &symbolTable[_dynSymTabCmd->iundefsym()];
+ const macho_nlist<P>* const lastImport = &symbolTable[_dynSymTabCmd->iundefsym()+_dynSymTabCmd->nundefsym()];
+ uint32_t oldSymbolIndex = _dynSymTabCmd->iundefsym();
+ for (const macho_nlist<P>* entry = firstImport; entry < lastImport; ++entry, ++oldSymbolIndex) {
+ if ( (entry->n_type() & N_TYPE) != N_UNDF)
+ continue;
+ const char* name = &strings[entry->n_strx()];
+ macho_nlist<P>* newSymbolEntry = (macho_nlist<P>*)&newLinkEditContent[offset];
+ *newSymbolEntry = *entry;
+ newSymbolEntry->set_n_strx(0);
+ stringPool.add(symbolIndex, name);
+ _oldToNewSymbolIndexes[oldSymbolIndex] = symbolIndex - _newLocalSymbolsStartIndex;
+ ++symbolIndex;
+ offset += sizeof(macho_nlist<P>);
+ }
+ _newImportedSymbolCount = symbolIndex - _newImportedSymbolsStartIndex;
+}
+
+template <typename P>
+void LinkeditOptimizer<P>::copyIndirectSymbolTable(uint8_t* newLinkEditContent, uint32_t& offset)
+{
+ _newIndirectSymbolTableOffset = offset;
+ const uint32_t* const indirectTable = (uint32_t*)&_linkeditBias[_dynSymTabCmd->indirectsymoff()];
+ uint32_t* newIndirectTable = (uint32_t*)&newLinkEditContent[offset];
+ for (int i=0; i < _dynSymTabCmd->nindirectsyms(); ++i) {
+ uint32_t symbolIndex = E::get32(indirectTable[i]);
+ if ( (symbolIndex == INDIRECT_SYMBOL_ABS) || (symbolIndex == INDIRECT_SYMBOL_LOCAL) )
+ E::set32(newIndirectTable[i], symbolIndex);
+ else
+ E::set32(newIndirectTable[i], _oldToNewSymbolIndexes[symbolIndex]);
+ offset += sizeof(uint32_t);
+ }
+}
+
+template <typename P>
+uint64_t mergeLinkedits(DyldSharedCache* cache, bool dontMapLocalSymbols, bool addAcceleratorTables, std::vector<LinkeditOptimizer<P>*>& optimizers, Diagnostics& diagnostics, dyld_cache_local_symbols_info** localsInfo)
+{
+ // allocate space for new linkedit data
+ uint32_t linkeditStartOffset = 0xFFFFFFFF;
+ uint32_t linkeditEndOffset = 0;
+ uint64_t linkeditStartAddr = 0;
+ for (LinkeditOptimizer<P>* op : optimizers) {
+ uint32_t leOffset = op->linkeditOffset();
+ if ( leOffset < linkeditStartOffset ) {
+ linkeditStartOffset = leOffset;
+ linkeditStartAddr = op->linkeditAddr();
+ }
+ uint32_t leEndOffset = op->linkeditOffset() + op->linkeditSize();
+ if ( leEndOffset > linkeditEndOffset )
+ linkeditEndOffset = leEndOffset;
+ }
+ uint64_t totalUnoptLinkeditsSize = linkeditEndOffset - linkeditStartOffset;
+ uint8_t* newLinkEdit = (uint8_t*)calloc(totalUnoptLinkeditsSize, 1);
+ SortedStringPool<P> stringPool;
+ uint32_t offset = 0;
+
+ diagnostics.verbose("Merged LINKEDIT:\n");
+
+ // copy weak binding info
+ uint32_t startWeakBindInfosOffset = offset;
+ for (LinkeditOptimizer<P>* op : optimizers) {
+ op->copyWeakBindingInfo(newLinkEdit, offset);
+ }
+ diagnostics.verbose(" weak bindings size: %5uKB\n", (uint32_t)(offset-startWeakBindInfosOffset)/1024);
+
+ // copy export info
+ uint32_t startExportInfosOffset = offset;
+ for (LinkeditOptimizer<P>* op : optimizers) {
+ op->copyExportInfo(newLinkEdit, offset);
+ }
+ diagnostics.verbose(" exports info size: %5uKB\n", (uint32_t)(offset-startExportInfosOffset)/1024);
+
+ // in theory, an optimized cache can drop the binding info
+ if ( true ) {
+ // copy binding info
+ uint32_t startBindingsInfosOffset = offset;
+ for (LinkeditOptimizer<P>* op : optimizers) {
+ op->copyBindingInfo(newLinkEdit, offset);
+ }
+ diagnostics.verbose(" bindings size: %5uKB\n", (uint32_t)(offset-startBindingsInfosOffset)/1024);
+
+ // copy lazy binding info
+ uint32_t startLazyBindingsInfosOffset = offset;
+ for (LinkeditOptimizer<P>* op : optimizers) {
+ op->copyLazyBindingInfo(newLinkEdit, offset);
+ }
+ diagnostics.verbose(" lazy bindings size: %5uKB\n", (offset-startLazyBindingsInfosOffset)/1024);
+ }
+
+ // copy symbol table entries
+ std::vector<macho_nlist<P>> unmappedLocalSymbols;
+ if ( dontMapLocalSymbols )
+ unmappedLocalSymbols.reserve(0x01000000);
+ std::vector<LocalSymbolInfo> localSymbolInfos;
+ localSymbolInfos.reserve(optimizers.size());
+ SortedStringPool<P> localSymbolsStringPool;
+ uint32_t symbolIndex = 0;
+ const uint32_t sharedSymbolTableStartOffset = offset;
+ uint32_t sharedSymbolTableExportsCount = 0;
+ uint32_t sharedSymbolTableImportsCount = 0;
+ for (LinkeditOptimizer<P>* op : optimizers) {
+ op->copyLocalSymbols(newLinkEdit, stringPool, offset, symbolIndex, dontMapLocalSymbols,
+ localSymbolInfos, unmappedLocalSymbols, localSymbolsStringPool);
+ uint32_t x = symbolIndex;
+ op->copyExportedSymbols(newLinkEdit, stringPool, offset, symbolIndex);
+ sharedSymbolTableExportsCount += (symbolIndex-x);
+ uint32_t y = symbolIndex;
+ op->copyImportedSymbols(newLinkEdit, stringPool, offset, symbolIndex);
+ sharedSymbolTableImportsCount += (symbolIndex-y);
+ }
+ uint32_t sharedSymbolTableCount = symbolIndex;
+ const uint32_t sharedSymbolTableEndOffset = offset;
+
+ // copy function starts
+ uint32_t startFunctionStartsOffset = offset;
+ for (LinkeditOptimizer<P>* op : optimizers) {
+ op->copyFunctionStarts(newLinkEdit, offset);
+ }
+ diagnostics.verbose(" function starts size: %5uKB\n", (offset-startFunctionStartsOffset)/1024);
+
+ // copy data-in-code info
+ uint32_t startDataInCodeOffset = offset;
+ for (LinkeditOptimizer<P>* op : optimizers) {
+ op->copyDataInCode(newLinkEdit, offset);
+ }
+ diagnostics.verbose(" data in code size: %5uKB\n", (offset-startDataInCodeOffset)/1024);
+
+ // copy indirect symbol tables
+ for (LinkeditOptimizer<P>* op : optimizers) {
+ op->copyIndirectSymbolTable(newLinkEdit, offset);
+ }
+ // if indirect table has odd number of entries, end will not be 8-byte aligned
+ if ( (offset % sizeof(typename P::uint_t)) != 0 )
+ offset += 4;
+
+ // copy string pool
+ uint32_t sharedSymbolStringsOffset = offset;
+ uint32_t sharedSymbolStringsSize = stringPool.copyPoolAndUpdateOffsets((char*)&newLinkEdit[sharedSymbolStringsOffset], (macho_nlist<P>*)&newLinkEdit[sharedSymbolTableStartOffset]);
+ offset += sharedSymbolStringsSize;
+ uint32_t newLinkeditUnalignedSize = offset;
+ uint64_t newLinkeditEnd = align(linkeditStartOffset+newLinkeditUnalignedSize, 14);
+ diagnostics.verbose(" symbol table size: %5uKB (%d exports, %d imports)\n", (sharedSymbolTableEndOffset-sharedSymbolTableStartOffset)/1024, sharedSymbolTableExportsCount, sharedSymbolTableImportsCount);
+ diagnostics.verbose(" symbol string pool size: %5uKB\n", sharedSymbolStringsSize/1024);
+
+ // overwrite mapped LINKEDIT area in cache with new merged LINKEDIT content
+ diagnostics.verbose("LINKEDITS optimized from %uMB to %uMB\n", (uint32_t)totalUnoptLinkeditsSize/(1024*1024), (uint32_t)newLinkeditUnalignedSize/(1024*1024));
+ ::memcpy((char*)cache + linkeditStartOffset, newLinkEdit, newLinkeditUnalignedSize);
+ ::bzero((char*)cache + linkeditStartOffset+newLinkeditUnalignedSize, totalUnoptLinkeditsSize-newLinkeditUnalignedSize);
+ ::free(newLinkEdit);
+
+ // If making cache for customers, add extra accelerator tables for dyld
+ if ( addAcceleratorTables ) {
+ AcceleratorTables<P> tables(cache, linkeditStartAddr, diagnostics, optimizers);
+ uint32_t tablesSize = tables.totalSize();
+ if ( tablesSize < (totalUnoptLinkeditsSize-newLinkeditUnalignedSize) ) {
+ tables.copyTo((uint8_t*)cache+newLinkeditEnd);
+ newLinkeditEnd += tablesSize;
+ uint64_t accelInfoAddr = align(linkeditStartAddr + newLinkeditUnalignedSize, 14);
+ cache->header.accelerateInfoAddr = accelInfoAddr;
+ cache->header.accelerateInfoSize = tablesSize;
+ diagnostics.verbose("Accelerator tables %uMB\n", (uint32_t)tablesSize/(1024*1024));
+ }
+ else {
+ diagnostics.warning("not enough room to add dyld accelerator tables");
+ }
+ }
+
+ // update mapping to reduce linkedit size
+ dyld_cache_mapping_info* mappings = (dyld_cache_mapping_info*)((char*)cache + cache->header.mappingOffset);
+ mappings[2].size = newLinkeditEnd - mappings[2].fileOffset;
+
+ // overwrite end of un-opt linkedits to create a new unmapped region for local symbols
+ uint64_t newFileSize = newLinkeditEnd;
+ if ( dontMapLocalSymbols ) {
+ typedef typename P::E E;
+ const uint32_t entriesOffset = sizeof(dyld_cache_local_symbols_info);
+ const uint32_t entriesCount = (uint32_t)localSymbolInfos.size();
+ const uint32_t nlistOffset = (uint32_t)align(entriesOffset + entriesCount * sizeof(dyld_cache_local_symbols_info), 4); // 16-byte align start
+ const uint32_t nlistCount = (uint32_t)unmappedLocalSymbols.size();
+ const uint32_t stringsSize = (uint32_t)localSymbolsStringPool.size();
+ const uint32_t stringsOffset = nlistOffset + nlistCount * sizeof(macho_nlist<P>);
+ // allocate buffer for local symbols
+ const size_t localsBufferSize = align(stringsOffset + stringsSize, 14);
+ dyld_cache_local_symbols_info* infoHeader = (dyld_cache_local_symbols_info*)malloc(localsBufferSize);
+ // fill in header info
+ infoHeader->nlistOffset = nlistOffset;
+ infoHeader->nlistCount = nlistCount;
+ infoHeader->stringsOffset = stringsOffset;
+ infoHeader->stringsSize = stringsSize;
+ infoHeader->entriesOffset = entriesOffset;
+ infoHeader->entriesCount = entriesCount;
+ // copy info for each dylib
+ dyld_cache_local_symbols_entry* entries = (dyld_cache_local_symbols_entry*)(((uint8_t*)infoHeader)+entriesOffset);
+ for (int i=0; i < entriesCount; ++i) {
+ entries[i].dylibOffset = localSymbolInfos[i].dylibOffset;
+ entries[i].nlistStartIndex = localSymbolInfos[i].nlistStartIndex;
+ entries[i].nlistCount = localSymbolInfos[i].nlistCount;
+ }
+ // copy nlists
+ macho_nlist<P>* newLocalsSymbolTable = (macho_nlist<P>*)(((uint8_t*)infoHeader)+nlistOffset);
+ ::memcpy(newLocalsSymbolTable, &unmappedLocalSymbols[0], nlistCount*sizeof(macho_nlist<P>));
+ // copy string pool
+ localSymbolsStringPool.copyPoolAndUpdateOffsets(((char*)infoHeader)+stringsOffset, newLocalsSymbolTable);
+ // return buffer of local symbols, caller to free() it
+ *localsInfo = infoHeader;
+ }
+
+ // update all load commands to new merged layout
+ for (LinkeditOptimizer<P>* op : optimizers) {
+ op->updateLoadCommands(linkeditStartOffset, linkeditStartAddr, newLinkeditEnd-linkeditStartOffset,
+ sharedSymbolTableStartOffset, sharedSymbolTableCount,
+ sharedSymbolStringsOffset, sharedSymbolStringsSize);
+ }
+
+ return newFileSize;
+}
+
+} // anonymous namespace
+
+template <typename P>
+uint64_t optimizeLinkedit(DyldSharedCache* cache, bool dontMapLocalSymbols, bool addAcceleratorTables, const std::vector<uint64_t>& branchPoolOffsets, Diagnostics& diag, dyld_cache_local_symbols_info** localsInfo)
+{
+ // construct a LinkeditOptimizer for each image
+ __block std::vector<LinkeditOptimizer<P>*> optimizers;
+ cache->forEachImage(^(const mach_header* mh, const char*) {
+ optimizers.push_back(new LinkeditOptimizer<P>(cache, (macho_header<P>*)mh, diag));
+ });
+#if 0
+ // add optimizer for each branch pool
+ for (uint64_t poolOffset : branchPoolOffsets) {
+ macho_header<P>* mh = (macho_header<P>*)((char*)cache + poolOffset);
+ optimizers.push_back(new LinkeditOptimizer<P>(cache, mh, diag));
+ }
+#endif
+ // merge linkedit info
+ uint64_t newFileSize = mergeLinkedits(cache, dontMapLocalSymbols, addAcceleratorTables, optimizers, diag, localsInfo);
+
+ // delete optimizers
+ for (LinkeditOptimizer<P>* op : optimizers)
+ delete op;
+
+ return newFileSize;
+}
+
+uint64_t optimizeLinkedit(DyldSharedCache* cache, bool is64, bool dontMapLocalSymbols, bool addAcceleratorTables, const std::vector<uint64_t>& branchPoolOffsets, Diagnostics& diag, dyld_cache_local_symbols_info** localsInfo)
+{
+ if ( is64) {
+ return optimizeLinkedit<Pointer64<LittleEndian>>(cache, dontMapLocalSymbols, addAcceleratorTables, branchPoolOffsets, diag, localsInfo);
+ }
+ else {
+ return optimizeLinkedit<Pointer32<LittleEndian>>(cache, dontMapLocalSymbols, addAcceleratorTables, branchPoolOffsets, diag, localsInfo);
+ }
+}
+
+
+