Loading...
--- dyld/dyld-625.13/dyld3/shared-cache/DyldSharedCache.cpp
+++ dyld/dyld-832.7.3/dyld3/shared-cache/DyldSharedCache.cpp
@@ -34,8 +34,6 @@
#include <assert.h>
#include <unistd.h>
#include <dlfcn.h>
-#include <CommonCrypto/CommonDigest.h>
-#include <CommonCrypto/CommonDigestSPI.h>
#if BUILDING_CACHE_BUILDER
#include <set>
@@ -43,33 +41,34 @@
#include <vector>
#include <unordered_map>
#include <unordered_set>
+#include "SharedCacheBuilder.h"
+#include "FileUtils.h"
#endif
#define NO_ULEB
#include "MachOLoaded.h"
#include "ClosureFileSystemPhysical.h"
-#include "CacheBuilder.h"
#include "DyldSharedCache.h"
#include "Trie.hpp"
#include "StringUtils.h"
-#include "FileUtils.h"
-
+
+#include "objc-shared-cache.h"
+
+#if !(BUILDING_LIBDYLD || BUILDING_DYLD)
+#include "JSONWriter.h"
+#include <sstream>
+#endif
#if BUILDING_CACHE_BUILDER
-DyldSharedCache::CreateResults DyldSharedCache::create(const CreateOptions& options,
- const std::vector<MappedMachO>& dylibsToCache,
- const std::vector<MappedMachO>& otherOsDylibs,
- const std::vector<MappedMachO>& osExecutables)
-{
- CreateResults results;
- const char* prefix = nullptr;
- if ( (options.pathPrefixes.size() == 1) && !options.pathPrefixes[0].empty() )
- prefix = options.pathPrefixes[0].c_str();
- // FIXME: This prefix will be applied to dylib closures and executable closures, even though
- // the old code didn't have a prefix on cache dylib closures
- dyld3::closure::FileSystemPhysical fileSystem(prefix);
- CacheBuilder cache(options, fileSystem);
+DyldSharedCache::CreateResults DyldSharedCache::create(const CreateOptions& options,
+ const dyld3::closure::FileSystem& fileSystem,
+ const std::vector<MappedMachO>& dylibsToCache,
+ const std::vector<MappedMachO>& otherOsDylibs,
+ const std::vector<MappedMachO>& osExecutables)
+{
+ CreateResults results;
+ SharedCacheBuilder cache(options, fileSystem);
if (!cache.errorMessage().empty()) {
results.errorMessage = cache.errorMessage();
return results;
@@ -86,6 +85,7 @@
aliases.push_back({"/usr/lib/libstdc++.6.dylib", "/usr/lib/libstdc++.6.0.9.dylib"});
aliases.push_back({"/usr/lib/libz.1.dylib", "/usr/lib/libz.dylib"});
aliases.push_back({"/usr/lib/libSystem.B.dylib", "/usr/lib/libSystem.dylib"});
+ aliases.push_back({"/System/Library/Frameworks/Foundation.framework/Foundation", "/usr/lib/libextension.dylib"}); // <rdar://44315703>
break;
default:
break;
@@ -113,7 +113,10 @@
return results;
}
-bool DyldSharedCache::verifySelfContained(std::vector<MappedMachO>& dylibsToCache, MappedMachO (^loader)(const std::string& runtimePath), std::vector<std::pair<DyldSharedCache::MappedMachO, std::set<std::string>>>& rejected)
+bool DyldSharedCache::verifySelfContained(std::vector<MappedMachO>& dylibsToCache,
+ std::unordered_set<std::string>& badZippered,
+ MappedMachO (^loader)(const std::string& runtimePath, Diagnostics& diag),
+ std::vector<std::pair<DyldSharedCache::MappedMachO, std::set<std::string>>>& rejected)
{
// build map of dylibs
__block std::map<std::string, std::set<std::string>> badDylibs;
@@ -123,10 +126,13 @@
if ( dylib.mh->canBePlacedInDyldCache(dylib.runtimePath.c_str(), ^(const char* msg) { badDylibs[dylib.runtimePath].insert(msg);}) ) {
knownDylibs.insert(dylib.runtimePath);
knownDylibs.insert(dylib.mh->installName());
+ } else {
+ badDylibs[dylib.runtimePath].insert("");
}
}
// check all dependencies to assure every dylib in cache only depends on other dylibs in cache
+ __block std::set<std::string> missingWeakDylibs;
__block bool doAgain = true;
while ( doAgain ) {
__block std::vector<DyldSharedCache::MappedMachO> foundMappings;
@@ -136,13 +142,36 @@
if ( badDylibs.count(dylib.runtimePath) != 0 )
continue;
dylib.mh->forEachDependentDylib(^(const char* loadPath, bool isWeak, bool isReExport, bool isUpward, uint32_t compatVersion, uint32_t curVersion, bool& stop) {
+ if ( isWeak && (missingWeakDylibs.count(loadPath) != 0) )
+ return;
if ( knownDylibs.count(loadPath) == 0 ) {
doAgain = true;
+ if ( badZippered.count(loadPath) != 0 ) {
+ badDylibs[dylib.runtimePath].insert("");
+ knownDylibs.erase(dylib.runtimePath);
+ knownDylibs.erase(dylib.mh->installName());
+ badZippered.insert(dylib.runtimePath);
+ badZippered.insert(dylib.mh->installName());
+ return;
+ }
+ Diagnostics diag;
MappedMachO foundMapping;
if ( badDylibs.count(loadPath) == 0 )
- foundMapping = loader(loadPath);
+ foundMapping = loader(loadPath, diag);
if ( foundMapping.length == 0 ) {
- badDylibs[dylib.runtimePath].insert(std::string("Could not find dependency '") + loadPath +"'");
+ // We allow weakly linked dylibs to be missing only if they are not present on disk
+ // The shared cache doesn't contain enough information to patch them in later if they are
+ // found on disk, so we don't want to pull something in to cache and cut it off from a dylib it
+ // could have used.
+ if ( isWeak ) {
+ missingWeakDylibs.insert(loadPath);
+ return;
+ }
+
+ if (diag.hasError())
+ badDylibs[dylib.runtimePath].insert(diag.errorMessage());
+ else
+ badDylibs[dylib.runtimePath].insert(std::string("Could not find dependency '") + loadPath +"'");
knownDylibs.erase(dylib.runtimePath);
knownDylibs.erase(dylib.mh->installName());
}
@@ -162,6 +191,8 @@
knownDylibs.insert(loadPath);
knownDylibs.insert(foundMapping.runtimePath);
knownDylibs.insert(foundMapping.mh->installName());
+ } else {
+ badDylibs[dylib.runtimePath].insert("");
}
}
}
@@ -173,7 +204,9 @@
dylibsToCache.erase(std::remove_if(dylibsToCache.begin(), dylibsToCache.end(), [&](const DyldSharedCache::MappedMachO& dylib) {
auto i = badDylibsCopy.find(dylib.runtimePath);
if ( i != badDylibsCopy.end()) {
- rejected.push_back(std::make_pair(dylib, i->second));
+ // Only add the warning if we are not a bad zippered dylib
+ if ( badZippered.count(dylib.runtimePath) == 0 )
+ rejected.push_back(std::make_pair(dylib, i->second));
return true;
}
else {
@@ -186,12 +219,40 @@
}
#endif
-void DyldSharedCache::forEachRegion(void (^handler)(const void* content, uint64_t vmAddr, uint64_t size, uint32_t permissions)) const
-{
- const dyld_cache_mapping_info* mappings = (dyld_cache_mapping_info*)((char*)this + header.mappingOffset);
- const dyld_cache_mapping_info* mappingsEnd = &mappings[header.mappingCount];
- for (const dyld_cache_mapping_info* m=mappings; m < mappingsEnd; ++m) {
- handler((char*)this + m->fileOffset, m->address, m->size, m->initProt);
+template<typename T>
+const T DyldSharedCache::getAddrField(uint64_t addr) const {
+ uint64_t slide = (uint64_t)this - unslidLoadAddress();
+ return (const T)(addr + slide);
+}
+
+uint64_t DyldSharedCache::getCodeSignAddress() const
+{
+ auto mappings = (const dyld_cache_mapping_info*)((uint8_t*)this + header.mappingOffset);
+ return mappings[header.mappingCount-1].address + mappings[header.mappingCount-1].size;
+}
+
+void DyldSharedCache::forEachRegion(void (^handler)(const void* content, uint64_t vmAddr, uint64_t size, uint32_t permissions,
+ uint64_t flags)) const
+{
+ // <rdar://problem/49875993> sanity check cache header
+ if ( strncmp(header.magic, "dyld_v1", 7) != 0 )
+ return;
+ if ( header.mappingOffset > 1024 )
+ return;
+ if ( header.mappingCount > 20 )
+ return;
+ if ( header.mappingOffset <= __offsetof(dyld_cache_header, mappingWithSlideOffset) ) {
+ const dyld_cache_mapping_info* mappings = (dyld_cache_mapping_info*)((char*)this + header.mappingOffset);
+ const dyld_cache_mapping_info* mappingsEnd = &mappings[header.mappingCount];
+ for (const dyld_cache_mapping_info* m=mappings; m < mappingsEnd; ++m) {
+ handler((char*)this + m->fileOffset, m->address, m->size, m->initProt, 0);
+ }
+ } else {
+ const dyld_cache_mapping_and_slide_info* mappings = (const dyld_cache_mapping_and_slide_info*)((char*)this + header.mappingWithSlideOffset);
+ const dyld_cache_mapping_and_slide_info* mappingsEnd = &mappings[header.mappingCount];
+ for (const dyld_cache_mapping_and_slide_info* m=mappings; m < mappingsEnd; ++m) {
+ handler((char*)this + m->fileOffset, m->address, m->size, m->initProt, m->flags);
+ }
}
}
@@ -206,7 +267,8 @@
uintptr_t unslidStart = (uintptr_t)addr - slide;
// quick out if after end of cache
- if ( unslidStart > (mappings[2].address + mappings[2].size) )
+ const dyld_cache_mapping_info* lastMapping = &mappings[header.mappingCount - 1];
+ if ( unslidStart > (lastMapping->address + lastMapping->size) )
return false;
// walk cache regions
@@ -220,6 +282,13 @@
}
return false;
+}
+
+bool DyldSharedCache::isAlias(const char* path) const {
+ const dyld_cache_mapping_info* mappings = (dyld_cache_mapping_info*)((char*)this + header.mappingOffset);
+ uintptr_t slide = (uintptr_t)this - (uintptr_t)(mappings[0].address);
+ // paths for aliases are store between cache header and first segment
+ return path < ((char*)mappings[0].address + slide);
}
void DyldSharedCache::forEachImage(void (^handler)(const mach_header* mh, const char* installName)) const
@@ -263,6 +332,62 @@
}
}
+const bool DyldSharedCache::hasLocalSymbolsInfo() const
+{
+ return (header.localSymbolsOffset != 0 && header.mappingOffset > offsetof(dyld_cache_header,localSymbolsSize));
+}
+
+const void* DyldSharedCache::getLocalNlistEntries() const
+{
+ // check for cache without local symbols info
+ if (!this->hasLocalSymbolsInfo())
+ return nullptr;
+ const auto localInfo = (dyld_cache_local_symbols_info*)((uint8_t*)this + header.localSymbolsOffset);
+ return (uint8_t*)localInfo + localInfo->nlistOffset;
+}
+
+const uint32_t DyldSharedCache::getLocalNlistCount() const
+{
+ // check for cache without local symbols info
+ if (!this->hasLocalSymbolsInfo())
+ return 0;
+ const auto localInfo = (dyld_cache_local_symbols_info*)((uint8_t*)this + header.localSymbolsOffset);
+ return localInfo->nlistCount;
+}
+
+const char* DyldSharedCache::getLocalStrings() const
+{
+ // check for cache without local symbols info
+ if (!this->hasLocalSymbolsInfo())
+ return nullptr;
+ const auto localInfo = (dyld_cache_local_symbols_info*)((uint8_t*)this + header.localSymbolsOffset);
+ return (char*)localInfo + localInfo->stringsOffset;
+}
+
+const uint32_t DyldSharedCache::getLocalStringsSize() const
+{
+ // check for cache without local symbols info
+ if (!this->hasLocalSymbolsInfo())
+ return 0;
+ const auto localInfo = (dyld_cache_local_symbols_info*)((uint8_t*)this + header.localSymbolsOffset);
+ return localInfo->stringsSize;
+}
+
+ void DyldSharedCache::forEachLocalSymbolEntry(void (^handler)(uint32_t dylibOffset, uint32_t nlistStartIndex, uint32_t nlistCount, bool& stop)) const
+{
+ // check for cache without local symbols info
+ if (!this->hasLocalSymbolsInfo())
+ return;
+ const auto localInfo = (dyld_cache_local_symbols_info*)((uint8_t*)this + header.localSymbolsOffset);
+ const auto localEntries = (dyld_cache_local_symbols_entry*)((uint8_t*)localInfo + localInfo->entriesOffset);
+ bool stop = false;
+ for (uint32_t i = 0; i < localInfo->entriesCount; i++) {
+ dyld_cache_local_symbols_entry localEntry = localEntries[i];
+ handler(localEntry.dylibOffset, localEntry.nlistStartIndex, localEntry.nlistCount, stop);
+ }
+}
+
+
const mach_header* DyldSharedCache::getIndexedImageEntry(uint32_t index, uint64_t& mTime, uint64_t& inode) const
{
const dyld_cache_image_info* dylibs = (dyld_cache_image_info*)((char*)this + header.imagesOffset);
@@ -272,10 +397,17 @@
return (mach_header*)((uint8_t*)this + dylibs[index].address - mappings[0].address);
}
+
+ const char* DyldSharedCache::getIndexedImagePath(uint32_t index) const
+{
+ auto dylibs = (const dyld_cache_image_info*)((char*)this + header.imagesOffset);
+ return (char*)this + dylibs[index].pathFileOffset;
+}
+
void DyldSharedCache::forEachImageTextSegment(void (^handler)(uint64_t loadAddressUnslid, uint64_t textSegmentSize, const uuid_t dylibUUID, const char* installName, bool& stop)) const
{
// check for old cache without imagesText array
- if ( header.mappingOffset < 123 )
+ if ( (header.mappingOffset <= __offsetof(dyld_cache_header, imagesTextOffset)) || (header.imagesTextCount == 0) )
return;
// walk imageText table and call callback for each entry
@@ -307,7 +439,7 @@
const char* DyldSharedCache::archName() const
{
- const char* archSubString = ((char*)this) + 8;
+ const char* archSubString = ((char*)this) + 7;
while (*archSubString == ' ')
++archSubString;
return archSubString;
@@ -328,7 +460,8 @@
__block std::vector<uint64_t> regionFileOffsets;
result.reserve(256*1024);
- forEachRegion(^(const void* content, uint64_t vmAddr, uint64_t size, uint32_t permissions) {
+ forEachRegion(^(const void* content, uint64_t vmAddr, uint64_t size, uint32_t permissions,
+ uint64_t flags) {
regionStartAddresses.push_back(vmAddr);
regionSizes.push_back(size);
regionFileOffsets.push_back((uint8_t*)content - (uint8_t*)this);
@@ -379,7 +512,8 @@
{
__block uint64_t startAddr = 0;
__block uint64_t endAddr = 0;
- forEachRegion(^(const void* content, uint64_t vmAddr, uint64_t size, uint32_t permissions) {
+ forEachRegion(^(const void* content, uint64_t vmAddr, uint64_t size, uint32_t permissions,
+ uint64_t flags) {
if ( startAddr == 0 )
startAddr = vmAddr;
uint64_t end = vmAddr+size;
@@ -443,12 +577,36 @@
return false;
}
+bool DyldSharedCache::isOverridablePath(const char* dylibPath) const
+{
+ // all dylibs in customer dyld cache cannot be overridden except libdispatch.dylib
+ if ( header.cacheType == kDyldSharedCacheTypeProduction ) {
+ return (strcmp(dylibPath, "/usr/lib/system/libdispatch.dylib") == 0);
+ }
+ // in dev caches we can override all paths
+ return true;
+}
+
+bool DyldSharedCache::hasNonOverridablePath(const char* dylibPath) const
+{
+ // all dylibs in customer dyld cache cannot be overridden except libdispatch.dylib
+ bool pathIsInDyldCacheWhichCannotBeOverridden = false;
+ if ( header.cacheType == kDyldSharedCacheTypeProduction ) {
+ uint32_t imageIndex;
+ pathIsInDyldCacheWhichCannotBeOverridden = this->hasImagePath(dylibPath, imageIndex);
+ if ( pathIsInDyldCacheWhichCannotBeOverridden && isOverridablePath(dylibPath) )
+ pathIsInDyldCacheWhichCannotBeOverridden = false;
+ }
+ return pathIsInDyldCacheWhichCannotBeOverridden;
+}
+
+#if !BUILDING_LIBDSC
const dyld3::closure::Image* DyldSharedCache::findDlopenOtherImage(const char* path) const
{
const dyld_cache_mapping_info* mappings = (dyld_cache_mapping_info*)((char*)this + header.mappingOffset);
if ( mappings[0].fileOffset != 0 )
return nullptr;
- if ( header.mappingOffset < sizeof(dyld_cache_header) )
+ if ( header.mappingOffset < __offsetof(dyld_cache_header, otherImageArrayAddr) )
return nullptr;
if ( header.otherImageArrayAddr == 0 )
return nullptr;
@@ -468,9 +626,6 @@
return nullptr;
}
-
-
-
const dyld3::closure::LaunchClosure* DyldSharedCache::findClosure(const char* executablePath) const
{
const dyld_cache_mapping_info* mappings = (dyld_cache_mapping_info*)((char*)this + header.mappingOffset);
@@ -532,7 +687,23 @@
}
}
}
-#endif
+
+void DyldSharedCache::forEachDylibPath(void (^handler)(const char* dylibPath, uint32_t index)) const
+{
+ const dyld_cache_mapping_info* mappings = (dyld_cache_mapping_info*)((char*)this + header.mappingOffset);
+ uintptr_t slide = (uintptr_t)this - (uintptr_t)(mappings[0].address);
+ const uint8_t* dylibTrieStart = (uint8_t*)(this->header.dylibsTrieAddr + slide);
+ const uint8_t* dylibTrieEnd = dylibTrieStart + this->header.dylibsTrieSize;
+
+ std::vector<DylibIndexTrie::Entry> dylibEntries;
+ if ( Trie<DylibIndex>::parseTrie(dylibTrieStart, dylibTrieEnd, dylibEntries) ) {
+ for (DylibIndexTrie::Entry& entry : dylibEntries ) {
+ handler(entry.name.c_str(), entry.info.index);
+ }
+ }
+}
+#endif // !BUILDING_LIBDYLD && !BUILDING_DYLD
+#endif // !BUILDING_LIBDSC
const dyld3::closure::ImageArray* DyldSharedCache::cachedDylibsImageArray() const
{
@@ -551,7 +722,7 @@
const dyld3::closure::ImageArray* DyldSharedCache::otherOSImageArray() const
{
// check for old cache without imagesArray
- if ( header.mappingOffset < sizeof(dyld_cache_header) )
+ if ( header.mappingOffset < __offsetof(dyld_cache_header, otherImageArrayAddr) )
return nullptr;
if ( header.otherImageArrayAddr == 0 )
@@ -563,8 +734,427 @@
}
-
-
-
-
-
+uint32_t DyldSharedCache::patchableExportCount(uint32_t imageIndex) const {
+ if ( header.patchInfoAddr == 0 )
+ return 0;
+
+ const dyld_cache_patch_info* patchInfo = getAddrField<dyld_cache_patch_info*>(header.patchInfoAddr);
+ const dyld_cache_image_patches* patchArray = getAddrField<dyld_cache_image_patches*>(patchInfo->patchTableArrayAddr);
+ if (imageIndex > patchInfo->patchTableArrayCount)
+ return 0;
+ return patchArray[imageIndex].patchExportsCount;
+}
+
+void DyldSharedCache::forEachPatchableExport(uint32_t imageIndex, void (^handler)(uint32_t cacheOffsetOfImpl, const char* exportName)) const {
+ if ( header.patchInfoAddr == 0 )
+ return;
+
+ const dyld_cache_patch_info* patchInfo = getAddrField<dyld_cache_patch_info*>(header.patchInfoAddr);
+ const dyld_cache_image_patches* patchArray = getAddrField<dyld_cache_image_patches*>(patchInfo->patchTableArrayAddr);
+ if (imageIndex > patchInfo->patchTableArrayCount)
+ return;
+ const dyld_cache_image_patches& patch = patchArray[imageIndex];
+ if ( (patch.patchExportsStartIndex + patch.patchExportsCount) > patchInfo->patchExportArrayCount )
+ return;
+ const dyld_cache_patchable_export* patchExports = getAddrField<dyld_cache_patchable_export*>(patchInfo->patchExportArrayAddr);
+ const char* exportNames = getAddrField<char*>(patchInfo->patchExportNamesAddr);
+ for (uint64_t exportIndex = 0; exportIndex != patch.patchExportsCount; ++exportIndex) {
+ const dyld_cache_patchable_export& patchExport = patchExports[patch.patchExportsStartIndex + exportIndex];
+ const char* exportName = ( patchExport.exportNameOffset < patchInfo->patchExportNamesSize ) ? &exportNames[patchExport.exportNameOffset] : "";
+ handler(patchExport.cacheOffsetOfImpl, exportName);
+ }
+}
+
+void DyldSharedCache::forEachPatchableUseOfExport(uint32_t imageIndex, uint32_t cacheOffsetOfImpl,
+ void (^handler)(dyld_cache_patchable_location patchLocation)) const {
+ if ( header.patchInfoAddr == 0 )
+ return;
+
+ // Loading a new cache so get the data from the cache header
+ const dyld_cache_patch_info* patchInfo = getAddrField<dyld_cache_patch_info*>(header.patchInfoAddr);
+ const dyld_cache_image_patches* patchArray = getAddrField<dyld_cache_image_patches*>(patchInfo->patchTableArrayAddr);
+ if (imageIndex > patchInfo->patchTableArrayCount)
+ return;
+ const dyld_cache_image_patches& patch = patchArray[imageIndex];
+ if ( (patch.patchExportsStartIndex + patch.patchExportsCount) > patchInfo->patchExportArrayCount )
+ return;
+ const dyld_cache_patchable_export* patchExports = getAddrField<dyld_cache_patchable_export*>(patchInfo->patchExportArrayAddr);
+ const dyld_cache_patchable_location* patchLocations = getAddrField<dyld_cache_patchable_location*>(patchInfo->patchLocationArrayAddr);
+ for (uint64_t exportIndex = 0; exportIndex != patch.patchExportsCount; ++exportIndex) {
+ const dyld_cache_patchable_export& patchExport = patchExports[patch.patchExportsStartIndex + exportIndex];
+ if ( patchExport.cacheOffsetOfImpl != cacheOffsetOfImpl )
+ continue;
+ if ( (patchExport.patchLocationsStartIndex + patchExport.patchLocationsCount) > patchInfo->patchLocationArrayCount )
+ return;
+ for (uint64_t locationIndex = 0; locationIndex != patchExport.patchLocationsCount; ++locationIndex) {
+ const dyld_cache_patchable_location& patchLocation = patchLocations[patchExport.patchLocationsStartIndex + locationIndex];
+ handler(patchLocation);
+ }
+ }
+}
+
+#if !(BUILDING_LIBDYLD || BUILDING_DYLD)
+// MRM map file generator
+std::string DyldSharedCache::generateJSONMap(const char* disposition) const {
+ dyld3::json::Node cacheNode;
+
+ cacheNode.map["version"].value = "1";
+ cacheNode.map["disposition"].value = disposition;
+ cacheNode.map["base-address"].value = dyld3::json::hex(unslidLoadAddress());
+ uuid_t cache_uuid;
+ getUUID(cache_uuid);
+ uuid_string_t cache_uuidStr;
+ uuid_unparse(cache_uuid, cache_uuidStr);
+ cacheNode.map["uuid"].value = cache_uuidStr;
+
+ __block dyld3::json::Node imagesNode;
+ forEachImage(^(const mach_header *mh, const char *installName) {
+ dyld3::json::Node imageNode;
+ imageNode.map["path"].value = installName;
+ dyld3::MachOAnalyzer* ma = (dyld3::MachOAnalyzer*)mh;
+ uuid_t uuid;
+ if (ma->getUuid(uuid)) {
+ uuid_string_t uuidStr;
+ uuid_unparse(uuid, uuidStr);
+ imageNode.map["uuid"].value = uuidStr;
+ }
+
+ __block dyld3::json::Node segmentsNode;
+ ma->forEachSegment(^(const dyld3::MachOAnalyzer::SegmentInfo &info, bool &stop) {
+ dyld3::json::Node segmentNode;
+ segmentNode.map["name"].value = info.segName;
+ segmentNode.map["start-vmaddr"].value = dyld3::json::hex(info.vmAddr);
+ segmentNode.map["end-vmaddr"].value = dyld3::json::hex(info.vmAddr + info.vmSize);
+ segmentsNode.array.push_back(segmentNode);
+ });
+ imageNode.map["segments"] = segmentsNode;
+ imagesNode.array.push_back(imageNode);
+ });
+
+ cacheNode.map["images"] = imagesNode;
+
+ std::stringstream stream;
+ printJSON(cacheNode, 0, stream);
+
+ return stream.str();
+}
+
+std::string DyldSharedCache::generateJSONDependents() const {
+ std::unordered_map<std::string, std::set<std::string>> dependents;
+ computeTransitiveDependents(dependents);
+
+ std::stringstream stream;
+
+ stream << "{";
+ bool first = true;
+ for (auto p : dependents) {
+ if (!first) stream << "," << std::endl;
+ first = false;
+
+ stream << "\"" << p.first << "\" : [" << std::endl;
+ bool firstDependent = true;
+ for (const std::string & dependent : p.second) {
+ if (!firstDependent) stream << "," << std::endl;
+ firstDependent = false;
+ stream << " \"" << dependent << "\"";
+ }
+ stream << "]" << std::endl;
+ }
+ stream << "}" << std::endl;
+ return stream.str();
+}
+
+#endif
+
+#if !(BUILDING_LIBDYLD || BUILDING_DYLD)
+dyld3::MachOAnalyzer::VMAddrConverter DyldSharedCache::makeVMAddrConverter(bool contentRebased) const {
+ typedef dyld3::MachOAnalyzer::VMAddrConverter VMAddrConverter;
+
+ __block VMAddrConverter::SharedCacheFormat pointerFormat = VMAddrConverter::SharedCacheFormat::none;
+ __block uint64_t pointerValueAdd = 0;;
+ forEachSlideInfo(^(uint64_t mappingStartAddress, uint64_t mappingSize, const uint8_t *mappingPagesStart, uint64_t slideInfoOffset, uint64_t slideInfoSize, const dyld_cache_slide_info *slideInfoHeader) {
+ assert(slideInfoHeader->version >= 2);
+ if ( slideInfoHeader->version == 2 ) {
+ const dyld_cache_slide_info2* slideInfo = (dyld_cache_slide_info2*)(slideInfoHeader);
+ assert(slideInfo->delta_mask == 0x00FFFF0000000000);
+ pointerFormat = VMAddrConverter::SharedCacheFormat::v2_x86_64_tbi;
+ pointerValueAdd = slideInfo->value_add;
+ } else if ( slideInfoHeader->version == 3 ) {
+ pointerFormat = VMAddrConverter::SharedCacheFormat::v3;
+ pointerValueAdd = unslidLoadAddress();
+ } else {
+ assert(false);
+ }
+ });
+
+ const dyld_cache_mapping_info* mappings = (dyld_cache_mapping_info*)((char*)this + header.mappingOffset);
+ uintptr_t slide = (uintptr_t)this - (uintptr_t)(mappings[0].address);
+
+ VMAddrConverter vmAddrConverter;
+ vmAddrConverter.preferredLoadAddress = pointerValueAdd;
+ vmAddrConverter.slide = slide;
+ vmAddrConverter.chainedPointerFormat = 0;
+ vmAddrConverter.sharedCacheChainedPointerFormat = pointerFormat;
+ vmAddrConverter.contentRebased = contentRebased;
+
+ return vmAddrConverter;
+}
+#endif
+
+const dyld_cache_slide_info* DyldSharedCache::legacyCacheSlideInfo() const
+{
+ assert(header.mappingOffset <= __offsetof(dyld_cache_header, mappingWithSlideOffset));
+ const dyld_cache_mapping_info* mappings = (dyld_cache_mapping_info*)((char*)this + header.mappingOffset);
+ uintptr_t slide = (uintptr_t)this - (uintptr_t)(mappings[0].address);
+
+ uint64_t offsetInLinkEditRegion = (header.slideInfoOffsetUnused - mappings[2].fileOffset);
+ return (dyld_cache_slide_info*)((uint8_t*)(mappings[2].address) + slide + offsetInLinkEditRegion);
+}
+
+const dyld_cache_mapping_info* DyldSharedCache::legacyCacheDataRegionMapping() const
+{
+ assert(header.mappingOffset <= __offsetof(dyld_cache_header, mappingWithSlideOffset));
+ const dyld_cache_mapping_info* mappings = (dyld_cache_mapping_info*)((char*)this + header.mappingOffset);
+ return &mappings[1];
+}
+
+const uint8_t* DyldSharedCache::legacyCacheDataRegionBuffer() const
+{
+ assert(header.mappingOffset <= __offsetof(dyld_cache_header, mappingWithSlideOffset));
+ const dyld_cache_mapping_info* mappings = (dyld_cache_mapping_info*)((char*)this + header.mappingOffset);
+ uintptr_t slide = (uintptr_t)this - (uintptr_t)(mappings[0].address);
+
+ return (uint8_t*)(legacyCacheDataRegionMapping()->address) + slide;
+}
+
+#if !BUILDING_LIBDSC
+const objc_opt::objc_opt_t* DyldSharedCache::objcOpt() const {
+ // Find the objc image
+ const dyld3::MachOAnalyzer* objcMA = nullptr;
+
+ uint32_t imageIndex;
+ if ( hasImagePath("/usr/lib/libobjc.A.dylib", imageIndex) ) {
+ const dyld3::closure::ImageArray* images = cachedDylibsImageArray();
+ const dyld3::closure::Image* image = images->imageForNum(imageIndex+1);
+ objcMA = (const dyld3::MachOAnalyzer*)((uintptr_t)this + image->cacheOffset());
+ } else {
+ return nullptr;
+ }
+
+ // If we found the objc image, then try to find the read-only data inside.
+ __block const uint8_t* objcROContent = nullptr;
+ int64_t slide = objcMA->getSlide();
+ objcMA->forEachSection(^(const dyld3::MachOAnalyzer::SectionInfo& info, bool malformedSectionRange, bool& stop) {
+ if (strcmp(info.segInfo.segName, "__TEXT") != 0)
+ return;
+ if (strcmp(info.sectName, "__objc_opt_ro") != 0)
+ return;
+ if ( malformedSectionRange ) {
+ stop = true;
+ return;
+ }
+ objcROContent = (uint8_t*)(info.sectAddr + slide);
+ });
+
+ if (objcROContent == nullptr)
+ return nullptr;
+
+ const objc_opt::objc_opt_t* optObjCHeader = (const objc_opt::objc_opt_t*)objcROContent;
+ return optObjCHeader->version == objc_opt::VERSION ? optObjCHeader : nullptr;
+}
+
+const void* DyldSharedCache::objcOptPtrs() const {
+ // Find the objc image
+ const dyld3::MachOAnalyzer* objcMA = nullptr;
+
+ uint32_t imageIndex;
+ if ( hasImagePath("/usr/lib/libobjc.A.dylib", imageIndex) ) {
+ const dyld3::closure::ImageArray* images = cachedDylibsImageArray();
+ const dyld3::closure::Image* image = images->imageForNum(imageIndex+1);
+ objcMA = (const dyld3::MachOAnalyzer*)((uintptr_t)this + image->cacheOffset());
+ } else {
+ return nullptr;
+ }
+
+ // If we found the objc image, then try to find the read-only data inside.
+ __block const void* objcPointersContent = nullptr;
+ int64_t slide = objcMA->getSlide();
+ uint32_t pointerSize = objcMA->pointerSize();
+ objcMA->forEachSection(^(const dyld3::MachOAnalyzer::SectionInfo& info, bool malformedSectionRange, bool& stop) {
+ if ( (strncmp(info.segInfo.segName, "__DATA", 6) != 0) && (strncmp(info.segInfo.segName, "__AUTH", 6) != 0) )
+ return;
+ if (strcmp(info.sectName, "__objc_opt_ptrs") != 0)
+ return;
+ if ( info.sectSize != pointerSize ) {
+ stop = true;
+ return;
+ }
+ if ( malformedSectionRange ) {
+ stop = true;
+ return;
+ }
+ objcPointersContent = (uint8_t*)(info.sectAddr + slide);
+ });
+
+ return objcPointersContent;
+}
+#endif
+
+std::pair<const void*, uint64_t> DyldSharedCache::getObjCConstantRange() const {
+ const dyld3::MachOAnalyzer* libDyldMA = nullptr;
+ uint32_t imageIndex;
+ if ( hasImagePath("/usr/lib/system/libdyld.dylib", imageIndex) ) {
+ const dyld3::closure::ImageArray* images = cachedDylibsImageArray();
+ const dyld3::closure::Image* image = images->imageForNum(imageIndex+1);
+ libDyldMA = (const dyld3::MachOAnalyzer*)((uintptr_t)this + image->cacheOffset());
+
+ std::pair<const void*, uint64_t> ranges = { nullptr, 0 };
+#if TARGET_OS_OSX
+ ranges.first = libDyldMA->findSectionContent("__DATA", "__objc_ranges", ranges.second);
+#else
+ ranges.first = libDyldMA->findSectionContent("__DATA_CONST", "__objc_ranges", ranges.second);
+#endif
+ return ranges;
+ }
+
+ return { nullptr, 0 };
+}
+
+bool DyldSharedCache::hasSlideInfo() const {
+ if ( header.mappingOffset <= __offsetof(dyld_cache_header, mappingWithSlideOffset) ) {
+ return header.slideInfoSizeUnused != 0;
+ } else {
+ const dyld_cache_mapping_and_slide_info* slidableMappings = (const dyld_cache_mapping_and_slide_info*)((char*)this + header.mappingWithSlideOffset);
+ for (uint32_t i = 0; i != header.mappingWithSlideCount; ++i) {
+ if ( slidableMappings[i].slideInfoFileSize != 0 ) {
+ return true;
+ }
+ }
+ }
+ return false;
+}
+
+void DyldSharedCache::forEachSlideInfo(void (^handler)(uint64_t mappingStartAddress, uint64_t mappingSize,
+ const uint8_t* mappingPagesStart,
+ uint64_t slideInfoOffset, uint64_t slideInfoSize,
+ const dyld_cache_slide_info* slideInfoHeader)) const {
+ if ( header.mappingOffset <= __offsetof(dyld_cache_header, mappingWithSlideOffset) ) {
+ // Old caches should get the slide info from the cache header and assume a single data region.
+ const dyld_cache_mapping_info* dataMapping = legacyCacheDataRegionMapping();
+ uint64_t dataStartAddress = dataMapping->address;
+ uint64_t dataSize = dataMapping->size;
+ const uint8_t* dataPagesStart = legacyCacheDataRegionBuffer();
+ const dyld_cache_slide_info* slideInfoHeader = legacyCacheSlideInfo();
+
+ handler(dataStartAddress, dataSize, dataPagesStart,
+ header.slideInfoOffsetUnused, header.slideInfoSizeUnused, slideInfoHeader);
+ } else {
+ const dyld_cache_mapping_and_slide_info* slidableMappings = (const dyld_cache_mapping_and_slide_info*)((char*)this + header.mappingWithSlideOffset);
+ const dyld_cache_mapping_and_slide_info* linkeditMapping = &slidableMappings[header.mappingWithSlideCount - 1];
+ uint64_t sharedCacheSlide = (uint64_t)this - unslidLoadAddress();
+
+ for (uint32_t i = 0; i != header.mappingWithSlideCount; ++i) {
+ if ( slidableMappings[i].slideInfoFileOffset != 0 ) {
+ // Get the data pages
+ uint64_t dataStartAddress = slidableMappings[i].address;
+ uint64_t dataSize = slidableMappings[i].size;
+ const uint8_t* dataPagesStart = (uint8_t*)dataStartAddress + sharedCacheSlide;
+
+ // Get the slide info
+ uint64_t offsetInLinkEditRegion = (slidableMappings[i].slideInfoFileOffset - linkeditMapping->fileOffset);
+ const dyld_cache_slide_info* slideInfoHeader = (dyld_cache_slide_info*)((uint8_t*)(linkeditMapping->address) + sharedCacheSlide + offsetInLinkEditRegion);
+ handler(dataStartAddress, dataSize, dataPagesStart,
+ slidableMappings[i].slideInfoFileOffset, slidableMappings[i].slideInfoFileSize, slideInfoHeader);
+ }
+ }
+ }
+}
+
+#if BUILDING_LIBDYLD
+const char* DyldSharedCache::getCanonicalPath(const char *path) const {
+ uint32_t dyldCacheImageIndex;
+ if ( hasImagePath(path, dyldCacheImageIndex) )
+ return getIndexedImagePath(dyldCacheImageIndex);
+#if TARGET_OS_OSX
+ // on macOS support "Foo.framework/Foo" symlink
+ char resolvedPath[PATH_MAX];
+ realpath(path, resolvedPath);
+ int realpathErrno = errno;
+ // If realpath() resolves to a path which does not exist on disk, errno is set to ENOENT
+ if ( (realpathErrno == ENOENT) || (realpathErrno == 0) ) {
+ if ( hasImagePath(resolvedPath, dyldCacheImageIndex) )
+ return getIndexedImagePath(dyldCacheImageIndex);
+ }
+#endif
+ return nullptr;
+}
+#endif
+
+#if !(BUILDING_LIBDYLD || BUILDING_DYLD)
+void DyldSharedCache::fillMachOAnalyzersMap(std::unordered_map<std::string,dyld3::MachOAnalyzer*> & dylibAnalyzers) const {
+ forEachImage(^(const mach_header *mh, const char *iteratedInstallName) {
+ dylibAnalyzers[std::string(iteratedInstallName)] = (dyld3::MachOAnalyzer*)mh;
+ });
+}
+
+void DyldSharedCache::computeReverseDependencyMapForDylib(std::unordered_map<std::string, std::set<std::string>> &reverseDependencyMap, const std::unordered_map<std::string,dyld3::MachOAnalyzer*> & dylibAnalyzers, const std::string &loadPath) const {
+ dyld3::MachOAnalyzer *ma = dylibAnalyzers.at(loadPath);
+ if (reverseDependencyMap.find(loadPath) != reverseDependencyMap.end()) return;
+ reverseDependencyMap[loadPath] = std::set<std::string>();
+
+ ma->forEachDependentDylib(^(const char *dependencyLoadPath, bool isWeak, bool isReExport, bool isUpward, uint32_t compatVersion, uint32_t curVersion, bool &stop) {
+ if (isUpward) return;
+ std::string dependencyLoadPathString = std::string(dependencyLoadPath);
+ computeReverseDependencyMapForDylib(reverseDependencyMap, dylibAnalyzers, dependencyLoadPathString);
+ reverseDependencyMap[dependencyLoadPathString].insert(loadPath);
+ });
+}
+
+// Walks the shared cache and construct the reverse dependency graph (if dylib A depends on B,
+// constructs the graph with B -> A edges)
+void DyldSharedCache::computeReverseDependencyMap(std::unordered_map<std::string, std::set<std::string>> &reverseDependencyMap) const {
+ std::unordered_map<std::string,dyld3::MachOAnalyzer*> dylibAnalyzers;
+
+ fillMachOAnalyzersMap(dylibAnalyzers);
+ forEachImage(^(const mach_header *mh, const char *installName) {
+ computeReverseDependencyMapForDylib(reverseDependencyMap, dylibAnalyzers, std::string(installName));
+ });
+}
+
+// uses the reverse dependency graph constructed above to find the recursive set of dependents for each dylib
+void DyldSharedCache::findDependentsRecursively(std::unordered_map<std::string, std::set<std::string>> &transitiveDependents, const std::unordered_map<std::string, std::set<std::string>> &reverseDependencyMap, std::set<std::string> & visited, const std::string &loadPath) const {
+
+ if (transitiveDependents.find(loadPath) != transitiveDependents.end()) {
+ return;
+ }
+
+ if (visited.find(loadPath) != visited.end()) {
+ return;
+ }
+
+ visited.insert(loadPath);
+
+ std::set<std::string> dependents;
+
+ for (const std::string & dependent : reverseDependencyMap.at(loadPath)) {
+ findDependentsRecursively(transitiveDependents, reverseDependencyMap, visited, dependent);
+ if (transitiveDependents.find(dependent) != transitiveDependents.end()) {
+ std::set<std::string> & theseTransitiveDependents = transitiveDependents.at(dependent);
+ dependents.insert(theseTransitiveDependents.begin(), theseTransitiveDependents.end());
+ }
+ dependents.insert(dependent);
+ }
+
+ transitiveDependents[loadPath] = dependents;
+}
+
+// Fills a map from each install name N to the set of install names depending on N
+void DyldSharedCache::computeTransitiveDependents(std::unordered_map<std::string, std::set<std::string>> & transitiveDependents) const {
+ std::unordered_map<std::string, std::set<std::string>> reverseDependencyMap;
+ computeReverseDependencyMap(reverseDependencyMap);
+ forEachImage(^(const mach_header *mh, const char *installName) {
+ std::set<std::string> visited;
+ findDependentsRecursively(transitiveDependents, reverseDependencyMap, visited, std::string(installName));
+ });
+}
+#endif