Loading...
--- dyld/dyld-1231.3/other-tools/dyld_shared_cache_util.cpp
+++ dyld/dyld-1330/other-tools/dyld_shared_cache_util.cpp
@@ -48,6 +48,7 @@
#include <vector>
#include <iostream>
#include <optional>
+#include <ranges>
#include "ClosureFileSystemPhysical.h"
#include "DyldSharedCache.h"
@@ -61,14 +62,20 @@
#include "PrebuiltLoader.h"
#include "DyldProcessConfig.h"
#include "DyldRuntimeState.h"
-#include "Utils.h"
+#include "Utilities.h"
#include "objc-shared-cache.h"
#include "OptimizerObjC.h"
#include "ObjCVisitor.h"
+#include "SymbolicatedImage.h"
using namespace dyld4;
+
+using other_tools::SymbolicatedImage;
+using mach_o::Header;
+using mach_o::Platform;
+using mach_o::Version32;
#if TARGET_OS_OSX
#define DSC_BUNDLE_REL_PATH "../../lib/dsc_extractor.bundle"
@@ -106,17 +113,21 @@
modeObjCClassHashTable,
modeObjCSelectors,
modeSwiftProtocolConformances,
+ modeSwiftPtrTables,
+ modeLookupVA,
modeExtract,
modePatchTable,
+ modeDumpPatchTable,
modeRootsCost,
modeListDylibsWithSection,
modeDuplicates,
modeDuplicatesSummary,
modeMachHeaders,
- modeLoadCommands,
modeCacheHeader,
modeDylibSymbols,
modeFunctionStarts,
+ modeFunctionVariants,
+ modePrewarmingData,
};
struct Options {
@@ -128,6 +139,7 @@
const char* rootPath = nullptr;
const char* fixupsInDylib;
const char* rootsCostOfDylib = nullptr;
+ const char* lookupVA = nullptr;
bool printUUIDs;
bool printVMAddrs;
bool printDylibVersions;
@@ -139,7 +151,7 @@
fprintf(stderr, "Usage: dyld_shared_cache_util <command> [-fs-root] [-inode] [-versions] [-vmaddr] [shared-cache-file]\n"
" Commands:\n"
" -list [-uuid] [-vmaddr] list images\n"
- " -dependents <dylb-path> list dependents of dylib\n"
+ " -dependents <dylib-path> list dependents of dylib\n"
" -linkedit print linkedit contents\n"
" -info print shared cache info\n"
" -stats print size stats\n"
@@ -167,6 +179,8 @@
" -objc-class-hash-table print the contents of the ObjC class table\n"
" -objc-selectors print all ObjC selector names and locations in JSON format\n"
" -swift-proto print Swift protocol conformance table\n"
+ " -swift-ptrtables print Swift pointer tables\n"
+ " -lookup-va lookup range and symbols at the given virtual address\n"
" -extract <directory> extract images into the given directory\n"
" -patch_table print symbol patch table\n"
" -list_dylibs_with_section <seg> <sect> list images that contain the given section\n"
@@ -174,7 +188,10 @@
" -load_commands summarize load commands of each image\n"
" -cache_header print header of each shared cache file\n"
" -dylib_symbols print all symbol names and locations\n"
- " -function_starts print address of beginning of each function\n");
+ " -function_starts print address of beginning of each function\n"
+ " -function_variants print function variants fixups\n"
+ " -roots_cost <dylib-path> estimate the dirty memory cost of installing a dylib root\n"
+ " -prewarming_data print VM prewarming ranges\n");
}
static void checkMode(Mode mode) {
@@ -185,12 +202,134 @@
}
}
+struct SymbolicatedCache
+{
+ struct Range
+ {
+ uint64_t startAddr;
+ uint64_t endAddr;
+ std::optional<size_t> imageIndex;
+ std::string_view segmentName;
+ std::string_view sectName;
+
+ bool operator<(const Range& other) const
+ {
+ return startAddr < other.startAddr;
+ }
+ };
+
+ SymbolicatedCache(const DyldSharedCache* cache, bool isCacheOnDisk);
+
+ std::optional<size_t> findClosestRange(uint64_t addr) const;
+ SymbolicatedImage::SymbolLoc findClosestSymbol(uint64_t addr, const SymbolicatedImage*& image) const;
+
+ std::string symbolNameAt(uint64_t addr) const;
+
+ std::vector<Range> ranges;
+ std::vector<Image> machoImages;
+ std::vector<SymbolicatedImage> images;
+ uint64_t cacheBaseAddr;
+};
+
+SymbolicatedCache::SymbolicatedCache(const DyldSharedCache* cache, bool isCacheOnDisk)
+{
+ cacheBaseAddr = cache->unslidLoadAddress();
+
+ machoImages.reserve(cache->imagesCount());
+ images.reserve(cache->imagesCount());
+ cache->forEachImage(^(const Header* hdr, const char* installName) {
+ machoImages.emplace_back((void*)hdr, (size_t)-1, isCacheOnDisk ? Image::MappingKind::dyldLoadedPreFixups : Image::MappingKind::dyldLoadedPostFixups);
+ });
+
+ for ( const Image& image : machoImages )
+ images.emplace_back(image);
+
+ for ( size_t i = 0; i < images.size(); ++i ) {
+ const SymbolicatedImage& im = images[i];
+ im.image().header()->forEachSection(^(const Header::SectionInfo& sectInfo, bool &stop) {
+ if ( sectInfo.size == 0 )
+ return;
+ ranges.push_back({ .imageIndex = i, .startAddr = sectInfo.address, .endAddr = sectInfo.address + sectInfo.size, .segmentName = sectInfo.segmentName, .sectName = sectInfo.sectionName });
+ });
+ }
+
+ std::sort(ranges.begin(), ranges.end());
+ for ( size_t i = 1; i < ranges.size(); ++i ) {
+ if ( ranges[i-1].endAddr > ranges[i].startAddr ) {
+ assert(false && "overlapping image ranges");
+ }
+ }
+}
+
+std::string SymbolicatedCache::symbolNameAt(uint64_t addr) const
+{
+ const SymbolicatedImage* image = nullptr;
+ SymbolicatedImage::SymbolLoc loc = findClosestSymbol(addr, image);
+ if ( loc.name.empty() ) {
+ if ( image ) {
+ return std::string(image->image().header()->installName()) + "+" + json::hex(loc.inSymbolOffset);
+ }
+ return json::hex( addr );
+ }
+
+ std::string nameWithImage = std::string(image->image().header()->installName()) + "`" + std::string(loc.name);
+ if ( loc.inSymbolOffset != 0 )
+ return nameWithImage + "+" + json::hex(loc.inSymbolOffset);
+ return nameWithImage;
+}
+
+std::optional<size_t> SymbolicatedCache::findClosestRange(uint64_t addr) const
+{
+ auto it = std::lower_bound(ranges.begin(), ranges.end(), addr, [](const Range& range, uint64_t cmpAddr) -> bool {
+ return range.startAddr <= cmpAddr;
+ });
+ // lower_bound returns the range after the one we need
+ if ( (it != ranges.end()) && (it != ranges.begin()) ) {
+ --it;
+ } else {
+ it = ranges.begin();
+ }
+
+ if ( addr < it->startAddr || addr >= it->endAddr )
+ return std::nullopt;
+
+ return std::distance(ranges.begin(), it);
+}
+
+SymbolicatedImage::SymbolLoc SymbolicatedCache::findClosestSymbol(uint64_t addr, const SymbolicatedImage*& image) const
+{
+ SymbolicatedImage::SymbolLoc loc;
+ image = nullptr;
+ if ( ranges.empty() )
+ return loc;
+
+ std::optional<size_t> rangeIndex = findClosestRange(addr);
+ if ( !rangeIndex )
+ return loc;
+
+ const Range& range = ranges[*rangeIndex];
+ if ( range.imageIndex == std::nullopt )
+ return loc;
+
+ size_t imageIndex = *range.imageIndex;
+ assert(imageIndex < images.size());
+ //fprintf(stderr, "debug symbol lookup at offset: %llu, abs: 0x%llX, image: %s\n", runtimeOffset, addr, images[imageIndex].image().header()->installName());
+ image = &images[imageIndex];
+ loc = images[imageIndex].findClosestSymbol(addr);
+
+ if ( loc.name.empty() ) {
+ loc.inSymbolOffset = (uint32_t)(addr - image->prefLoadAddress());
+ }
+ return loc;
+}
+
+
struct SegmentInfo
{
- uint64_t vmAddr;
- uint64_t vmSize;
- const char* installName;
- const char* segName;
+ uint64_t vmAddr;
+ uint64_t vmSize;
+ const char* installName;
+ std::string_view segName;
};
static void sortSegmentInfo(std::vector<SegmentInfo>& segInfos)
@@ -200,21 +339,20 @@
});
}
-static void buildSegmentInfo(const dyld3::MachOAnalyzer* ma, std::vector<SegmentInfo>& segInfos)
+static void buildSegmentInfo(const Header* hdr, std::vector<SegmentInfo>& segInfos)
{
- const char* installName = ma->installName();
- ma->forEachSegment(^(const dyld3::MachOAnalyzer::SegmentInfo& info, bool& stop) {
+ const char* installName = hdr->installName();
+ hdr->forEachSegment(^(const Header::SegmentInfo& info, bool& stop) {
// Note, we subtract 1 from the vmSize so that lower_bound doesn't include the end of the segment
// as being a match for a given address.
- segInfos.push_back({info.vmAddr, info.vmSize - 1, installName, info.segName});
+ segInfos.push_back({info.vmaddr, info.vmsize - 1, installName, info.segmentName});
});
}
static void buildSegmentInfo(const DyldSharedCache* dyldCache, std::vector<SegmentInfo>& segInfos)
{
- dyldCache->forEachImage(^(const mach_header* mh, const char* installName) {
- dyld3::MachOAnalyzer* ma = (dyld3::MachOAnalyzer*)mh;
- buildSegmentInfo(ma, segInfos);
+ dyldCache->forEachImage(^(const Header* hdr, const char* installName) {
+ buildSegmentInfo(hdr, segInfos);
});
sortSegmentInfo(segInfos);
}
@@ -683,7 +821,7 @@
static bool findImageAndSegment(const DyldSharedCache* dyldCache, const std::vector<SegmentInfo>& segInfos, uint64_t cacheOffset, SegmentInfo* found)
{
const uint64_t locVmAddr = dyldCache->unslidLoadAddress() + cacheOffset;
- const SegmentInfo target = { locVmAddr, 0, NULL, NULL };
+ const SegmentInfo target = { locVmAddr, 0, NULL, { } };
const auto lowIt = std::lower_bound(segInfos.begin(), segInfos.end(), target,
[](const SegmentInfo& l, const SegmentInfo& r) -> bool {
return l.vmAddr+l.vmSize < r.vmAddr+r.vmSize;
@@ -703,8 +841,8 @@
static void dumpObjCClassLayout(const DyldSharedCache* dyldCache)
{
- dyldCache->forEachImage(^(const mach_header *mh, const char *installName) {
- const dyld3::MachOAnalyzer* ma = (dyld3::MachOAnalyzer*)mh;
+ dyldCache->forEachImage(^(const Header *hdr, const char *installName) {
+ const dyld3::MachOAnalyzer* ma = (dyld3::MachOAnalyzer*)hdr;
Diagnostics diag;
uint64_t sharedCacheRelativeSelectorBaseVMAddress = dyldCache->sharedCacheRelativeSelectorBaseVMAddress();
@@ -778,8 +916,8 @@
// Map from vmAddr to the category name for that address
__block std::unordered_map<VMAddress, std::string, VMAddressHash, VMAddressEqual> categoryMap;
- dyldCache->forEachImage(^(const mach_header *mh, const char *installName) {
- const dyld3::MachOAnalyzer* ma = (dyld3::MachOAnalyzer*)mh;
+ dyldCache->forEachImage(^(const Header *hdr, const char *installName) {
+ const dyld3::MachOAnalyzer* ma = (dyld3::MachOAnalyzer*)hdr;
Diagnostics diag;
const char* leafName = strrchr(installName, '/');
@@ -831,10 +969,9 @@
});
__block std::map<uint64_t, const char*> dylibVMAddrMap;
- dyldCache->forEachImage(^(const mach_header *mh, const char *installName) {
- const dyld3::MachOAnalyzer* ma = (const dyld3::MachOAnalyzer*)mh;
- if ( ma->hasObjC() )
- dylibVMAddrMap[ma->preferredLoadAddress()] = installName;
+ dyldCache->forEachImage(^(const Header *hdr, const char *installName) {
+ if ( hdr->hasObjC() )
+ dylibVMAddrMap[hdr->preferredLoadAddress()] = installName;
});
#if 0
@@ -883,8 +1020,8 @@
};
__block std::unordered_set<VMAddress, VMAddressHash, VMAddressEqual> seenCategories;
- dyldCache->forEachImage(^(const mach_header *mh, const char *installName) {
- const dyld3::MachOAnalyzer* ma = (dyld3::MachOAnalyzer*)mh;
+ dyldCache->forEachImage(^(const Header *hdr, const char *installName) {
+ const dyld3::MachOAnalyzer* ma = (dyld3::MachOAnalyzer*)hdr;
Diagnostics diag;
printf("--- %s ---\n", installName);
@@ -1110,6 +1247,49 @@
exit(1);
}
+static bool patchKindIsRootOptimized(PatchKind patchKind)
+{
+ return (patchKind == PatchKind::cfObj2) || (patchKind == PatchKind::objcClass);
+}
+
+struct PatchPageMetric
+{
+ std::unordered_set<uint64_t> pages;
+ size_t numUses = 0;
+
+ void addUse(uint64_t cacheOffset)
+ {
+ ++numUses;
+ pages.insert(cacheOffset & ~0x3FFF);
+ }
+};
+
+static void logCostOfRootPerSymbol(const std::unordered_map<CString, PatchPageMetric>& pagesPerSymbol)
+{
+ printf("\n%ld symbols page coverage:\n", pagesPerSymbol.size());
+
+ struct Metric
+ {
+ CString symName;
+ size_t numPages = 0;
+ size_t numUses = 0;
+ };
+
+ std::vector<Metric> metrics;
+ metrics.reserve(pagesPerSymbol.size());
+
+ std::ranges::transform(pagesPerSymbol, std::back_inserter(metrics), [](auto& entry) {
+ return Metric{entry.first, (size_t)entry.second.pages.size(), entry.second.numUses};
+ });
+ std::ranges::sort(metrics, [](auto& l, auto& r) {
+ if ( l.numPages == r.numPages )
+ return l.symName < r.symName;
+ return l.numPages < r.numPages;
+ });
+
+ for ( auto& metric : metrics )
+ printf("%s is on %ld pages, %ld uses\n", metric.symName.c_str(), metric.numPages, metric.numUses);
+}
int main (int argc, const char* argv[]) {
@@ -1267,6 +1447,20 @@
checkMode(options.mode);
options.mode = modeSwiftProtocolConformances;
}
+ else if (strcmp(opt, "-swift-ptrtables") == 0) {
+ checkMode(options.mode);
+ options.mode = modeSwiftPtrTables;
+ }
+ else if (strcmp(opt, "-lookup-va") == 0) {
+ checkMode(options.mode);
+ options.mode = modeLookupVA;
+ options.lookupVA = argv[++i];
+ if ( i >= argc ) {
+ fprintf(stderr, "Error: option -lookup-va requires an address argument\n");
+ usage();
+ exit(1);
+ }
+ }
else if (strcmp(opt, "-extract") == 0) {
checkMode(options.mode);
options.mode = modeExtract;
@@ -1292,6 +1486,12 @@
else if (strcmp(opt, "-patch_table") == 0) {
options.mode = modePatchTable;
}
+ else if (strcmp(opt, "-dump_patch_table") == 0) {
+ options.mode = modeDumpPatchTable;
+ }
+ else if (strcmp(opt, "-function_variants") == 0) {
+ options.mode = modeFunctionVariants;
+ }
else if (strcmp(opt, "-roots_cost") == 0) {
checkMode(options.mode);
options.mode = modeRootsCost;
@@ -1317,8 +1517,7 @@
options.mode = modeMachHeaders;
}
else if (strcmp(opt, "-load_commands") == 0) {
- checkMode(options.mode);
- options.mode = modeLoadCommands;
+ fprintf(stderr, "dyld_shared_cache_util -load_commands is deprecated. Use dyld_info -load_commands instead\n");
}
else if (strcmp(opt, "-cache_header") == 0) {
checkMode(options.mode);
@@ -1330,6 +1529,9 @@
}
else if (strcmp(opt, "-function_starts") == 0) {
options.mode = modeFunctionStarts;
+ }
+ else if (strcmp(opt, "-prewarming_data") == 0) {
+ options.mode = modePrewarmingData;
}
else {
fprintf(stderr, "Error: unrecognized option %s\n", opt);
@@ -1368,12 +1570,14 @@
__block std::vector<const DyldSharedCache*> dyldCaches;
const DyldSharedCache* dyldCache = nullptr;
+ bool cacheOnDisk = false;
if ( sharedCachePath != nullptr ) {
dyldCaches = DyldSharedCache::mapCacheFiles(sharedCachePath);
// mapCacheFile prints an error if something goes wrong, so just return in that case.
if ( dyldCaches.empty() )
return 1;
dyldCache = dyldCaches.front();
+ cacheOnDisk = true;
}
else {
size_t cacheLength;
@@ -1404,6 +1608,7 @@
dyldCache->forEachCache(^(const DyldSharedCache *cache, bool& stopCache) {
dyldCaches.push_back(dyldCache);
});
+ cacheOnDisk = false;
}
if ( options.mode == modeSlideInfo || options.mode == modeVerboseSlideInfo ) {
@@ -1439,10 +1644,10 @@
exit(1);
}
- const auto* ma = (const dyld3::MachOAnalyzer*)dyldCache->getIndexedImageEntry(imageIndex);
+ const Header* hdr = (const Header*)dyldCache->getIndexedImageEntry(imageIndex);
__block std::vector<SegmentInfo> dylibSegInfo;
- buildSegmentInfo(ma, dylibSegInfo);
+ buildSegmentInfo(hdr, dylibSegInfo);
sortSegmentInfo(dylibSegInfo);
__block std::vector<SegmentInfo> cacheSegInfo;
@@ -1471,20 +1676,20 @@
static const char* keyNames[] = {
"IA", "IB", "DA", "DB"
};
- printf("%s(0x%04llX) -> %s(0x%04llX):%s; (PAC: div=%d, addr=%s, key=%s)\n",
- fixupAt.segName, fixupVMAddr - fixupAt.vmAddr,
- targetAt.segName, targetVMAddr - targetAt.vmAddr, targetAt.installName,
+ printf("%.*s(0x%04llX) -> %.*s(0x%04llX):%s; (PAC: div=%d, addr=%s, key=%s)\n",
+ (int)fixupAt.segName.size(), fixupAt.segName.data(), fixupVMAddr - fixupAt.vmAddr,
+ (int)targetAt.segName.size(), targetAt.segName.data(), targetVMAddr - targetAt.vmAddr, targetAt.installName,
pmd.diversity, pmd.usesAddrDiversity ? "true" : "false", keyNames[pmd.key]);
} else {
if ( high8 != 0 ) {
- printf("%s(0x%04llX) -> %s(0x%04llX):%s; (high8: 0x%02llX)\n",
- fixupAt.segName, fixupVMAddr - fixupAt.vmAddr,
- targetAt.segName, targetVMAddr - targetAt.vmAddr, targetAt.installName,
+ printf("%.*s(0x%04llX) -> %.*s(0x%04llX):%s; (high8: 0x%02llX)\n",
+ (int)fixupAt.segName.size(), fixupAt.segName.data(), fixupVMAddr - fixupAt.vmAddr,
+ (int)targetAt.segName.size(), targetAt.segName.data(), targetVMAddr - targetAt.vmAddr, targetAt.installName,
high8);
} else {
- printf("%s(0x%04llX) -> %s(0x%04llX):%s\n",
- fixupAt.segName, fixupVMAddr - fixupAt.vmAddr,
- targetAt.segName, targetVMAddr - targetAt.vmAddr, targetAt.installName);
+ printf("%.*s(0x%04llX) -> %.*s(0x%04llX):%s\n",
+ (int)fixupAt.segName.size(), fixupAt.segName.data(), fixupVMAddr - fixupAt.vmAddr,
+ (int)targetAt.segName.size(), targetAt.segName.data(), targetVMAddr - targetAt.vmAddr, targetAt.installName);
}
}
};
@@ -1503,16 +1708,14 @@
uuid_string_t uuidString;
uuid_unparse_upper(header->uuid, uuidString);
printf("uuid: %s\n", uuidString);
-
- dyld3::Platform platform = dyldCache->platform();
- printf("platform: %s\n", dyld3::MachOFile::platformName(platform));
+ printf("platform: %s\n", dyldCache->platform().name().c_str());
printf("built by: %s\n", header->locallyBuiltCache ? "local machine" : "B&I");
printf("cache type: %s\n", DyldSharedCache::getCacheTypeName(header->cacheType));
if ( header->dylibsExpectedOnDisk )
printf("dylibs expected on disk: true\n");
if ( header->cacheType == kDyldSharedCacheTypeUniversal )
printf("cache sub-type: %s\n", DyldSharedCache::getCacheTypeName(header->cacheSubType));
- if ( header->mappingOffset >= __offsetof(dyld_cache_header, imagesCount) ) {
+ if ( header->mappingOffset >= offsetof(dyld_cache_header, imagesCount) ) {
printf("image count: %u\n", header->imagesCount);
} else {
printf("image count: %u\n", header->imagesCountOld);
@@ -1544,7 +1747,7 @@
printf("%20s %4lluMB, file offset: #%u/0x%08llX -> 0x%08llX, address: 0x%08llX -> 0x%08llX, %s -> %s\n",
mappingName, vmSize / (1024*1024), cacheFileIndex, fileOffset, fileOffset + vmSize,
unslidVMAddr, unslidVMAddr + vmSize, initProtString.c_str(), maxProtString.c_str());
- if (header->mappingOffset >= __offsetof(dyld_cache_header, dynamicDataOffset)) {
+ if (header->mappingOffset >= offsetof(dyld_cache_header, dynamicDataOffset)) {
if ( (unslidVMAddr + vmSize) == (header->sharedRegionStart + header->dynamicDataOffset) ) {
printf(" dynamic config %4lluKB, address: 0x%08llX -> 0x%08llX\n",
header->dynamicDataMaxSize/1024, header->sharedRegionStart + header->dynamicDataOffset,
@@ -1560,7 +1763,7 @@
subCacheHeader->codeSignatureOffset, subCacheHeader->codeSignatureOffset + subCacheHeader->codeSignatureSize);
}
- if ( subCacheHeader->mappingOffset > __offsetof(dyld_cache_header, rosettaReadOnlySize) ) {
+ if ( subCacheHeader->mappingOffset > offsetof(dyld_cache_header, rosettaReadOnlySize) ) {
if ( subCacheHeader->rosettaReadOnlySize != 0 ) {
printf("Rosetta RO: %4lluMB, address: 0x%08llX -> 0x%08llX\n",
subCacheHeader->rosettaReadOnlySize/(1024*1024), subCacheHeader->rosettaReadOnlyAddr,
@@ -1728,26 +1931,20 @@
// The cache has not been slid if we loaded it from disk
bool cacheRebased = (sharedCachePath == nullptr);
dyld3::MachOAnalyzer::VMAddrConverter vmAddrConverter = dyldCache->makeVMAddrConverter(cacheRebased);
- if ( !cacheRebased )
- dyldCache->applyCacheRebases();
uint64_t sharedCacheRelativeSelectorBaseVMAddress = dyldCache->sharedCacheRelativeSelectorBaseVMAddress();
- dyldCache->forEachImage(^(const mach_header *mh, const char *installName) {
+ dyldCache->forEachImage(^(const Header *hdr, const char *installName) {
__block std::unordered_set<std::string_view> seenStrings;
- const dyld3::MachOAnalyzer* ma = (dyld3::MachOAnalyzer*)mh;
+ const dyld3::MachOAnalyzer* ma = (dyld3::MachOAnalyzer*)hdr;
int64_t slide = ma->getSlide();
uint32_t pointerSize = ma->pointerSize();
- ma->forEachSection(^(const dyld3::MachOAnalyzer::SectionInfo& info, bool malformedSectionRange, bool& stop) {
- if ( ( (info.sectFlags & SECTION_TYPE) == S_CSTRING_LITERALS ) ) {
- if ( malformedSectionRange ) {
- stop = true;
- return;
- }
- const uint8_t* content = (uint8_t*)(info.sectAddr + slide);
+ ((const Header*)ma)->forEachSection(^(const Header::SectionInfo& info, bool& stop) {
+ if ( ( (info.flags & SECTION_TYPE) == S_CSTRING_LITERALS ) ) {
+ const uint8_t* content = (uint8_t*)(info.address + slide);
const char* s = (char*)content;
- const char* end = s + info.sectSize;
+ const char* end = s + info.size;
while ( s < end ) {
printf("%s: %s\n", installName, s);
seenStrings.insert(s);
@@ -1823,12 +2020,12 @@
}
if (printExports) {
- dyldCache->forEachImage(^(const mach_header *mh, const char *installName) {
- const dyld3::MachOAnalyzer* ma = (dyld3::MachOAnalyzer*)mh;
+ dyldCache->forEachImage(^(const Header *hdr, const char *installName) {
+ const dyld3::MachOAnalyzer* ma = (dyld3::MachOAnalyzer*)hdr;
uint32_t exportTrieRuntimeOffset;
uint32_t exportTrieSize;
if ( ma->hasExportTrie(exportTrieRuntimeOffset, exportTrieSize) ) {
- const uint8_t* start = (uint8_t*)mh + exportTrieRuntimeOffset;
+ const uint8_t* start = (uint8_t*)hdr + exportTrieRuntimeOffset;
const uint8_t* end = start + exportTrieSize;
std::vector<ExportInfoTrie::Entry> exports;
if ( !ExportInfoTrie::parseTrie(start, end, exports) ) {
@@ -1836,10 +2033,12 @@
}
for (const ExportInfoTrie::Entry& entry: exports) {
- const char* resolver = "";
+ const char* flags = "";
if ( entry.info.flags & EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER )
- resolver = " (resolver)";
- printf("%s: %s%s\n", installName, entry.name.c_str(), resolver);
+ flags = " (resolver)";
+ if ( entry.info.flags & EXPORT_SYMBOL_FLAGS_WEAK_DEFINITION )
+ flags = " (weak-def)";
+ printf("%s: %s%s\n", installName, entry.name.c_str(), flags);
}
}
});
@@ -1847,11 +2046,11 @@
}
else if ( options.mode == modeSectionSizes ) {
__block std::map<std::string, uint64_t> sectionSizes;
- dyldCache->forEachImage(^(const mach_header *mh, const char *installName) {
- const dyld3::MachOAnalyzer* ma = (const dyld3::MachOAnalyzer*)mh;
- ma->forEachSection(^(const dyld3::MachOAnalyzer::SectionInfo §Info, bool malformedSectionRange, bool &stop) {
- std::string section = std::string(sectInfo.segInfo.segName) + " " + sectInfo.sectName;
- sectionSizes[section] += sectInfo.sectSize;
+ dyldCache->forEachImage(^(const Header *hdr, const char *installName) {
+ const dyld3::MachOAnalyzer* ma = (const dyld3::MachOAnalyzer*)hdr;
+ ((const Header*)ma)->forEachSection(^(const Header::SectionInfo §Info, bool &stop) {
+ std::string section = std::string(sectInfo.segmentName) + " " + std::string(sectInfo.sectionName);
+ sectionSizes[section] += sectInfo.size;
});
});
for (const auto& keyAndValue : sectionSizes) {
@@ -1868,12 +2067,18 @@
printf("flags: 0x%08x\n", dyldCache->objcOptFlags());
if ( const objc::SelectorHashTable* selectors = dyldCache->objcSelectorHashTable() ) {
printf("num selectors: %u\n", selectors->occupancy());
+ printf("selectors base address: 0x%llx\n",
+ dyldCache->unslidLoadAddress() + ((uint64_t)selectors - (uint64_t)dyldCache));
}
if ( const objc::ClassHashTable* classes = dyldCache->objcClassHashTable() ) {
printf("num classes: %u\n", classes->occupancy());
+ printf("classes base address: 0x%llx\n",
+ dyldCache->unslidLoadAddress() + ((uint64_t)classes - (uint64_t)dyldCache));
}
if ( const objc::ProtocolHashTable* protocols = dyldCache->objcProtocolHashTable() ) {
printf("num protocols: %u\n", protocols->occupancy());
+ printf("protocols base address: 0x%llx\n",
+ dyldCache->unslidLoadAddress() + ((uint64_t)protocols - (uint64_t)dyldCache));
}
if ( const void* relativeMethodListSelectorBase = dyldCache->objcRelativeMethodListsBaseAddress() ) {
printf("method list selector base address: 0x%llx\n", dyldCache->unslidLoadAddress() + ((uint64_t)relativeMethodListSelectorBase - (uint64_t)dyldCache));
@@ -1883,10 +2088,9 @@
// Dump the objc indices
__block std::map<uint64_t, const char*> dylibVMAddrMap;
- dyldCache->forEachImage(^(const mach_header *mh, const char *installName) {
- const dyld3::MachOAnalyzer* ma = (const dyld3::MachOAnalyzer*)mh;
- if ( ma->hasObjC() )
- dylibVMAddrMap[ma->preferredLoadAddress()] = installName;
+ dyldCache->forEachImage(^(const Header *hdr, const char *installName) {
+ if ( hdr->hasObjC() )
+ dylibVMAddrMap[hdr->preferredLoadAddress()] = installName;
});
std::vector<std::pair<std::string_view, const objc::objc_image_info*>> objcDylibs;
@@ -1963,10 +2167,9 @@
}
__block std::map<uint64_t, const char*> dylibVMAddrMap;
- dyldCache->forEachImage(^(const mach_header *mh, const char *installName) {
- const dyld3::MachOAnalyzer* ma = (const dyld3::MachOAnalyzer*)mh;
- if ( ma->hasObjC() )
- dylibVMAddrMap[ma->preferredLoadAddress()] = installName;
+ dyldCache->forEachImage(^(const Header *hdr, const char *installName) {
+ if ( hdr->hasObjC() )
+ dylibVMAddrMap[hdr->preferredLoadAddress()] = installName;
});
__block std::map<uint16_t, const char*> dylibMap;
@@ -2060,14 +2263,12 @@
else if ( options.mode == modeObjCClasses ) {
// If we are running on macOS against a cache for another device, then we need a root path to find on-disk dylibs/executables
- if ( (dyld3::Platform)dyld_get_active_platform() != dyldCache->platform() ) {
+ if ( Platform(dyld_get_active_platform()) != dyldCache->platform() ) {
if ( options.rootPath == nullptr ) {
fprintf(stderr, "Analyzing cache file requires a root path for on-disk binaries. Rerun with -fs-root *path*\n");
return 1;
}
}
-
- dyldCache->applyCacheRebases();
auto getString = ^const char *(const dyld3::MachOAnalyzer* ma, VMAddress nameVMAddr){
dyld3::MachOAnalyzer::PrintableStringResult result;
@@ -2079,8 +2280,8 @@
uint64_t sharedCacheRelativeSelectorBaseVMAddress = dyldCache->sharedCacheRelativeSelectorBaseVMAddress();
- using dyld3::json::Node;
- using dyld3::json::NodeValueType;
+ using json::Node;
+ using json::NodeValueType;
std::string instancePrefix("-");
std::string classPrefix("+");
@@ -2089,7 +2290,7 @@
// name of the class they are attaching to
__block std::unordered_map<uint64_t, const char*> classVMAddrToName;
__block std::unordered_map<uint64_t, const char*> metaclassVMAddrToName;
- dyldCache->forEachImage(^(const mach_header *mh, const char *installName) {
+ dyldCache->forEachImage(^(const Header *mh, const char *installName) {
const dyld3::MachOAnalyzer* ma = (const dyld3::MachOAnalyzer*)mh;
__block objc_visitor::Visitor visitor(dyldCache, ma, VMAddress(sharedCacheRelativeSelectorBaseVMAddress));
@@ -2240,7 +2441,7 @@
// are exported
std::set<uint64_t> exportedSymbolVMAddrs;
{
- uint64_t loadAddress = ma->preferredLoadAddress();
+ uint64_t loadAddress = ((const Header*)ma)->preferredLoadAddress();
uint32_t exportTrieRuntimeOffset;
uint32_t exportTrieSize;
@@ -2534,9 +2735,9 @@
__block bool needsComma = false;
- dyld3::json::streamArrayBegin(needsComma);
-
- dyldCache->forEachImage(^(const mach_header *mh, const char *installName) {
+ json::streamArrayBegin(needsComma);
+
+ dyldCache->forEachImage(^(const Header *mh, const char *installName) {
const dyld3::MachOAnalyzer* ma = (const dyld3::MachOAnalyzer*)mh;
objc_visitor::Visitor visitor(dyldCache, ma, VMAddress(sharedCacheRelativeSelectorBaseVMAddress));
@@ -2561,7 +2762,7 @@
if (selrefs.has_value())
imageRecord.map["selrefs"] = selrefs.value();
- dyld3::json::streamArrayNode(needsComma, imageRecord);
+ json::streamArrayNode(needsComma, imageRecord);
});
const dyld3::MachOAnalyzer* mainMA = nullptr;
@@ -2582,7 +2783,7 @@
}
KernelArgs kernArgs(mainMA, {"test.exe"}, {}, {});
- Allocator& alloc = Allocator::defaultAllocator();
+ Allocator& alloc = MemoryManager::memoryManager().defaultAllocator();
SyscallDelegate osDelegate;
osDelegate._dyldCache = dyldCache;
osDelegate._rootPath = options.rootPath;
@@ -2595,9 +2796,10 @@
__block Diagnostics diag;
bool checkIfOSBinary = state.config.process.archs->checksOSBinary();
- state.config.syscall.withReadOnlyMappedFile(diag, executableRuntimePath, checkIfOSBinary, ^(const void* mapping, size_t mappedSize, bool isOSBinary, const FileID& fileID, const char* canonicalPath) {
+ state.config.syscall.withReadOnlyMappedFile(diag, executableRuntimePath, checkIfOSBinary, ^(const void* mapping, size_t mappedSize, bool isOSBinary, const FileID& fileID, const char* canonicalPath, const int fileDescriptor) {
+ uint64_t sliceOffset;
uint64_t sliceSize;
- if ( const dyld3::MachOFile* mf = dyld3::MachOFile::compatibleSlice(diag, sliceSize, mapping, mappedSize, executableRuntimePath, state.config.process.platform, isOSBinary, *state.config.process.archs) ) {
+ if ( const dyld3::MachOFile* mf = dyld3::MachOFile::compatibleSlice(diag, sliceOffset, sliceSize, mapping, mappedSize, executableRuntimePath, state.config.process.platform, isOSBinary, *state.config.process.archs) ) {
dyld3::closure::FileSystemPhysical fileSystem;
dyld3::closure::LoadedFileInfo fileInfo = {
.fileContent = (void*)mf,
@@ -2657,12 +2859,12 @@
if (selrefs.has_value())
imageRecord.map["selrefs"] = selrefs.value();
- dyld3::json::streamArrayNode(needsComma, imageRecord);
+ json::streamArrayNode(needsComma, imageRecord);
}
});
});
- dyld3::json::streamArrayEnd(needsComma);
+ json::streamArrayEnd(needsComma);
}
else if ( options.mode == modeObjCClassLayout ) {
dumpObjCClassLayout(dyldCache);
@@ -2692,21 +2894,21 @@
return a < b;
});
- dyld3::json::Node root;
+ json::Node root;
for (const char* selName : selNames) {
- dyld3::json::Node selNode;
- selNode.map["selectorName"] = dyld3::json::Node{selName};
- selNode.map["offset"] = dyld3::json::Node{(int64_t)selName - (int64_t)dyldCache};
+ json::Node selNode;
+ selNode.map["selectorName"] = json::Node{selName};
+ selNode.map["offset"] = json::Node{(int64_t)selName - (int64_t)dyldCache};
root.array.push_back(selNode);
}
- dyld3::json::printJSON(root, 0, std::cout);
+ json::printJSON(root, 0, std::cout);
}
else if ( options.mode == modeSwiftProtocolConformances ) {
#if 0
// This would dump the conformances in each binary, not the table in the shared cache
- dyldCache->forEachImage(^(const mach_header *mh, const char *installName) {
+ dyldCache->forEachImage(^(const Header *mh, const char *installName) {
const dyld3::MachOAnalyzer* ma = (const dyld3::MachOAnalyzer*)mh;
Diagnostics diag;
@@ -2734,7 +2936,7 @@
// Find all the symbols. This maps from VM Addresses to symbol name
__block std::unordered_map<uint64_t, std::string_view> symbols;
__block std::unordered_map<uint64_t, std::string_view> dylibs;
- dyldCache->forEachImage(^(const mach_header *mh, const char *installName) {
+ dyldCache->forEachImage(^(const Header *mh, const char *installName) {
const dyld3::MachOAnalyzer* ma = (const dyld3::MachOAnalyzer*)mh;
Diagnostics diag;
ma->forEachGlobalSymbol(diag, ^(const char *symbolName, uint64_t n_value, uint8_t n_type, uint8_t n_sect, uint16_t n_desc, bool &stop) {
@@ -2798,12 +3000,11 @@
auto getDylibForAddress = ^(uint64_t vmAddress) {
__block std::string_view dylibName;
- dyldCache->forEachImage(^(const mach_header *mh, const char *installName) {
+ dyldCache->forEachImage(^(const Header *mh, const char *installName) {
if ( !dylibName.empty() )
return;
- const dyld3::MachOAnalyzer* ma = (const dyld3::MachOAnalyzer*)mh;
- ma->forEachSegment(^(const dyld3::MachOAnalyzer::SegmentInfo &info, bool &stop) {
- if ( (vmAddress >= info.vmAddr) && (vmAddress < (info.vmAddr+info.vmSize)) ) {
+ ((const Header*)mh)->forEachSegment(^(const Header::SegmentInfo &info, bool &stop) {
+ if ( (vmAddress >= info.vmaddr) && (vmAddress < (info.vmaddr + info.vmsize)) ) {
dylibName = installName;
stop = true;
}
@@ -2820,7 +3021,7 @@
return 0;
}
printf("Swift optimization version: %d\n", swiftOptHeader->version);
- if ( swiftOptHeader->version == 1 || swiftOptHeader->version == 2 ) {
+ if ( swiftOptHeader->version == 1 || swiftOptHeader->version == 2 || swiftOptHeader->version == 3 ) {
printf("Type hash table\n");
const SwiftHashTable* typeHashTable = (const SwiftHashTable*)((uint8_t*)dyldCache + swiftOptHeader->typeConformanceHashTableCacheOffset);
typeHashTable->forEachValue(^(uint32_t bucketIndex, const dyld3::Array<SwiftTypeProtocolConformanceLocation>& impls) {
@@ -2980,6 +3181,79 @@
printf("Unhandled version\n");
}
}
+ else if ( options.mode == modeSwiftPtrTables ) {
+ uint64_t cacheBaseAddr = dyldCache->unslidLoadAddress();
+ const SwiftOptimizationHeader* swiftOptHeader = dyldCache->swiftOpt();
+ if ( swiftOptHeader == nullptr ) {
+ printf("No Swift optimization information present\n");
+ return 0;
+ }
+ printf("Swift optimization version: %d\n", swiftOptHeader->version);
+ if ( swiftOptHeader->version == 3 ) {
+ SymbolicatedCache symbolicatedCache(dyldCache, cacheOnDisk);
+ for ( size_t i = 0; i < SwiftOptimizationHeader::MAX_PRESPECIALIZED_METADATA_TABLES; ++i ) {
+ uint64_t ptrTableOffset = swiftOptHeader->prespecializedMetadataHashTableCacheOffsets[i];
+ if ( ptrTableOffset == 0 )
+ continue;
+
+ printf("Swift prespecialized metadata hash table #%lu\n", i);
+ const SwiftHashTable* ptrTable = (const SwiftHashTable*)((uint8_t*)dyldCache + ptrTableOffset);
+
+ ptrTable->forEachValue(^(uint32_t bucketIndex, const dyld3::Array<PointerHashTableValue>& values) {
+ for ( const PointerHashTableValue& value : values ) {
+ printf(" - k: [ ");
+ const uint64_t* keys = ptrTable->getCacheOffsets(value);
+ for ( size_t numKey = 0; numKey < value.numOffsets; ++numKey ) {
+ if ( numKey > 0 )
+ printf(", ");
+ printf("%s (0x%llx)", symbolicatedCache.symbolNameAt(cacheBaseAddr + keys[numKey]).c_str(), cacheBaseAddr + keys[numKey]);
+ }
+ printf(" ]\n v: %s (0x%llx)\n", symbolicatedCache.symbolNameAt(cacheBaseAddr + value.cacheOffset).c_str(), cacheBaseAddr + value.cacheOffset);
+ }
+ });
+ }
+ } else {
+ printf("Unhandled version\n");
+ }
+ }
+ else if ( options.mode == modeLookupVA ) {
+ CString vaString = options.lookupVA;
+
+ SymbolicatedCache symbolicatedCache(dyldCache, cacheOnDisk);
+
+ while ( !vaString.empty() ) {
+ char* endptr = nullptr;
+ uint64_t addr = strtoull(vaString.c_str(), &endptr, 16);
+ if ( addr == 0 )
+ break;
+
+ if ( endptr )
+ ++endptr;
+ vaString = endptr;
+
+ printf("0x%llx\n", addr);
+ std::optional<size_t> rangeIndexOpt = symbolicatedCache.findClosestRange(addr);
+ if ( !rangeIndexOpt )
+ return 0;
+
+ size_t rangeIndex = *rangeIndexOpt;
+
+ const SymbolicatedCache::Range& range = symbolicatedCache.ranges[rangeIndex];
+ const SymbolicatedImage* image = nullptr;
+ if ( range.imageIndex ) {
+ image = &symbolicatedCache.images[*range.imageIndex];
+ printf(" %15s %s\n", "in:", image->image().header()->installName());
+ printf(" %15s 0x%llx\n", "image base:", image->image().header()->preferredLoadAddress());
+ }
+ if ( !range.segmentName.empty() ) {
+ printf(" %15s %.*s,%.*s\n", "segment name:",
+ (int)range.segmentName.size(), range.segmentName.data(),
+ (int)range.sectName.size(), range.sectName.data());
+ }
+ printf(" %15s 0x%llx - 0x%llx\n", "range:", range.startAddr, range.endAddr);
+ printf(" %15s %s\n", "symbol:", symbolicatedCache.symbolNameAt(addr).c_str());
+ }
+ }
else if ( options.mode == modeExtract ) {
return dyld_shared_cache_extract_dylibs(sharedCachePath, options.extractionDir);
}
@@ -2998,9 +3272,9 @@
__block const void* objcCacheOffsets = nullptr;
__block int impCachesVersion = 1;
__block Diagnostics diag;
- dyldCache->forEachImage(^(const mach_header* mh, const char* installName) {
+ dyldCache->forEachImage(^(const Header* hdr, const char* installName) {
if ( !strcmp(installName, "/usr/lib/libobjc.A.dylib") ) {
- const dyld3::MachOAnalyzer* ma = (const dyld3::MachOAnalyzer*)mh;
+ const dyld3::MachOAnalyzer* ma = (const dyld3::MachOAnalyzer*)hdr;
objcCacheOffsets = ma->findSectionContent("__DATA_CONST", "__objc_scoffs", objcCacheOffsetsSize);
dyld3::MachOAnalyzer::FoundSymbol foundInfo;
if (ma->findExportedSymbol(diag, "_objc_opt_preopt_caches_version", false, foundInfo, nullptr)) {
@@ -3029,7 +3303,7 @@
uint64_t sharedCacheRelativeSelectorBaseVMAddress = dyldCache->sharedCacheRelativeSelectorBaseVMAddress();
- dyldCache->forEachImage(^(const mach_header *mh, const char *installName) {
+ dyldCache->forEachImage(^(const Header *mh, const char *installName) {
if (diag.hasError())
return;
@@ -3075,7 +3349,8 @@
if (diag.hasError())
return 1;
- dyldCache->forEachImage(^(const mach_header *mh, const char *installName) {
+ __block bool anyBadEntry = false;
+ dyldCache->forEachImage(^(const Header *mh, const char *installName) {
if (diag.hasError())
return;
@@ -3100,21 +3375,26 @@
const uint8_t* impCacheBuffer = (const uint8_t*)(objcClass.methodCacheVMAddr + slide);
uint32_t cacheMask = 0;
+ uint32_t cacheShift = 0;
uint32_t sizeOfHeader = 0;
if (impCachesVersion < 3) {
const ImpCacheHeader_v1* impCache = (const ImpCacheHeader_v1*)impCacheBuffer;
- printf("%s (%s): %d buckets\n", className, type, impCache->cache_mask + 1);
+ cacheMask = impCache->cache_mask;
+ cacheShift = impCache->cache_shift;
+ sizeOfHeader = sizeof(ImpCacheHeader_v1);
+
+ printf("%s (%s): %d buckets, 0x%X mask, 0x%X shift\n", className, type, impCache->cache_mask + 1, cacheMask, cacheShift);
if ((classVMAddr + impCache->fallback_class_offset) != objcClass.superclassVMAddr)
printf("Flattening fallback: %s\n", classVMAddrToNameMap[classVMAddr + impCache->fallback_class_offset]);
- cacheMask = impCache->cache_mask;
- sizeOfHeader = sizeof(ImpCacheHeader_v1);
} else {
const ImpCacheHeader_v2* impCache = (const ImpCacheHeader_v2*)impCacheBuffer;
- printf("%s (%s): %d buckets\n", className, type, impCache->cache_mask + 1);
+ cacheMask = impCache->cache_mask;
+ cacheShift = impCache->cache_shift;
+ sizeOfHeader = sizeof(ImpCacheHeader_v2);
+
+ printf("%s (%s): %d buckets, 0x%X mask, 0x%X shift\n", className, type, impCache->cache_mask + 1, cacheMask, cacheShift);
if ((classVMAddr + impCache->fallback_class_offset) != objcClass.superclassVMAddr)
printf("Flattening fallback: %s\n", classVMAddrToNameMap[classVMAddr + impCache->fallback_class_offset]);
- cacheMask = impCache->cache_mask;
- sizeOfHeader = sizeof(ImpCacheHeader_v2);
}
const uint8_t* buckets = impCacheBuffer + sizeOfHeader;
@@ -3123,14 +3403,17 @@
uint64_t sel = 0;
uint64_t imp = 0;
bool empty = false;
+ uint32_t selOff=0;
if (impCachesVersion == 1) {
const ImpCacheEntry_v1* bucket = (ImpCacheEntry_v1*)buckets + i;
+ selOff = bucket->selOffset;
sel = selectorStringVMAddrStart + bucket->selOffset;
imp = classVMAddr - bucket->impOffset;
if (bucket->selOffset == 0xFFFFFFF && bucket->impOffset == 0)
empty = true;
} else {
const ImpCacheEntry_v2* bucket = (ImpCacheEntry_v2*)buckets + i;
+ selOff = bucket->selOffset;
sel = selectorStringVMAddrStart + bucket->selOffset;
imp = classVMAddr - (bucket->impOffset << 2);
if (bucket->selOffset == 0x3FFFFFF && bucket->impOffset == 0)
@@ -3147,12 +3430,21 @@
fprintf(stderr, "Could not find IMP %llx (for %s)\n", imp, (const char*)(sel + slide));
}
assert(it != methodToClassMap.end());
- printf(" - 0x%016llx: %s (from %s)\n", imp, (const char*)(sel + slide), it->second);
+ printf(" - 0x%016llx: %s (from %s) (selOff: 0x%X)\n", imp, (const char*)(sel + slide), it->second, selOff);
+ uint32_t expectedBucket = (selOff >> cacheShift) & cacheMask;
+ if ( expectedBucket != i ) {
+ fprintf(stderr, " [BAD IMP CACHE] - 0x%016llx: %s (from %s) (selOff: 0x%X) (bucket: %d vs expected: %d)\n", imp, (const char*)(sel + slide), it->second, selOff, i, expectedBucket);
+ anyBadEntry = true;
+ }
}
}
};
ma->forEachObjCClass(diag, vmAddrConverter, visitClass);
});
+ if ( anyBadEntry ) {
+ fprintf(stderr, "IMP cache is malformed\n");
+ exit(1);
+ }
} else {
switch ( options.mode ) {
case modeList: {
@@ -3203,10 +3495,9 @@
break;
}
case modeListDylibsWithSection: {
- dyldCache->forEachImage(^(const mach_header* mh, const char* installName) {
- dyld3::MachOFile* mf = (dyld3::MachOFile*)mh;
- mf->forEachSection(^(const dyld3::MachOFile::SectionInfo& sectInfo, bool malformedSectionRange, bool& stop) {
- if ( (strcmp(sectInfo.sectName, options.sectionName) == 0) && (strcmp(sectInfo.segInfo.segName, options.segmentName) == 0) ) {
+ dyldCache->forEachImage(^(const Header* hdr, const char* installName) {
+ hdr->forEachSection(^(const Header::SectionInfo& sectInfo, bool& stop) {
+ if ( (sectInfo.sectionName == options.sectionName) && (sectInfo.segmentName == options.segmentName) ) {
printf("%s\n", installName);
stop = true;
}
@@ -3217,13 +3508,14 @@
case modeMap: {
__block std::map<uint64_t, const char*> dataSegNames;
__block std::map<uint64_t, uint64_t> dataSegEnds;
- dyldCache->forEachImage(^(const mach_header* mh, const char* installName) {
- dyld3::MachOFile* mf = (dyld3::MachOFile*)mh;
- mf->forEachSegment(^(const dyld3::MachOAnalyzer::SegmentInfo &info, bool &stop) {
- printf("0x%08llX - 0x%08llX %s %s\n", info.vmAddr, info.vmAddr + info.vmSize, info.segName, installName);
- if ( strncmp(info.segName, "__DATA", 6) == 0 ) {
- dataSegNames[info.vmAddr] = installName;
- dataSegEnds[info.vmAddr] = info.vmAddr + info.vmSize;
+ dyldCache->forEachImage(^(const Header* hdr, const char* installName) {
+ hdr->forEachSegment(^(const Header::SegmentInfo &info, bool &stop) {
+ printf("0x%08llX - 0x%08llX %.*s %s\n", info.vmaddr, info.vmaddr + info.vmsize,
+ (int)info.segmentName.size(), info.segmentName.data(),
+ installName);
+ if ( info.segmentName.starts_with("__DATA") ) {
+ dataSegNames[info.vmaddr] = installName;
+ dataSegEnds[info.vmaddr] = info.vmaddr + info.vmsize;
}
});
});
@@ -3240,7 +3532,7 @@
}
case modeDependencies: {
__block bool dependentTargetFound = false;
- dyldCache->forEachImage(^(const mach_header* mh, const char* installName) {
+ dyldCache->forEachImage(^(const Header* hdr, const char* installName) {
if ( strcmp(options.dependentsOfPath, installName) != 0 )
return;
dependentTargetFound = true;
@@ -3268,14 +3560,14 @@
}
};
- dyld3::MachOFile* mf = (dyld3::MachOFile*)mh;
+ dyld3::MachOFile* mf = (dyld3::MachOFile*)hdr;
// First print out our dylib and version.
const char* dylibInstallName;
- uint32_t currentVersion;
- uint32_t compatVersion;
- if ( mf->getDylibInstallName(&dylibInstallName, &compatVersion, ¤tVersion) ) {
- printDep(dylibInstallName, compatVersion, currentVersion);
+ Version32 currentVersion;
+ Version32 compatVersion;
+ if ( hdr->getDylibInstallName(&dylibInstallName, &compatVersion, ¤tVersion) ) {
+ printDep(dylibInstallName, compatVersion.value(), currentVersion.value());
}
// Then the dependent dylibs.
@@ -3307,8 +3599,8 @@
}
};
- dyldCache->forEachImage(^(const mach_header* mh, const char* installName) {
- dyld3::MachOAnalyzer* ma = (dyld3::MachOAnalyzer*)mh;
+ dyldCache->forEachImage(^(const Header* hdr, const char* installName) {
+ dyld3::MachOAnalyzer* ma = (dyld3::MachOAnalyzer*)hdr;
Diagnostics diag;
dyld3::MachOAnalyzer::LinkEditInfo leInfo;
ma->getLinkEditPointers(diag, leInfo);
@@ -3373,11 +3665,9 @@
const char* path;
};
__block std::vector<TextInfo> textSegments;
- dyldCache->forEachImage(^(const mach_header* mh, const char* installName) {
-
- dyld3::MachOAnalyzer* ma = (dyld3::MachOAnalyzer*)mh;
- ma->forEachSegment(^(const dyld3::MachOAnalyzer::SegmentInfo &info, bool &stop) {
- if ( strcmp(info.segName, "__TEXT") != 0 )
+ dyldCache->forEachImage(^(const Header* hdr, const char* installName) {
+ hdr->forEachSegment(^(const Header::SegmentInfo &info, bool &stop) {
+ if ( info.segmentName != "__TEXT" )
return;
textSegments.push_back({ info.fileSize, installName });
});
@@ -3390,21 +3680,39 @@
}
break;
}
+ case modeFunctionVariants: {
+ printf("Function Variant table size: %lld bytes\n", dyldCache->header.functionVariantInfoSize);
+ uintptr_t cacheSlide = dyldCache->slide();
+ dyldCache->forEachFunctionVariantPatchLocation(^(const void* loc, PointerMetaData pmd, const mach_o::FunctionVariants& fvs, const mach_o::Header* dylibHdr, int variantIndex, bool& stop) {
+ if ( pmd.authenticated ) {
+ printf(" fixup-loc=%p (key=%d, addr=%d, diversity=0x%04X), header-of-dylib-with-variant=%p, variant-index=%d\n",
+ (void*)((uintptr_t)loc - cacheSlide), pmd.key, pmd.usesAddrDiversity, pmd.diversity, (void*)((uintptr_t)dylibHdr - cacheSlide), variantIndex);
+ }
+ else {
+ printf(" fixup-loc=%p, header-of-dylib-with-variant=%p, variant-index=%d\n", (void*)((uintptr_t)loc - cacheSlide), (void*)((uintptr_t)dylibHdr - cacheSlide), variantIndex);
+ }
+ });
+ break;
+ }
case modePatchTable: {
printf("Patch table size: %lld bytes\n", dyldCache->header.patchInfoSize);
+ uint64_t cacheBaseAddress = dyldCache->unslidLoadAddress();
std::vector<SegmentInfo> segInfos;
buildSegmentInfo(dyldCache, segInfos);
__block uint32_t imageIndex = 0;
- dyldCache->forEachImage(^(const mach_header* mh, const char* installName) {
+ __block std::unordered_map<CString, PatchPageMetric> pagesPerSymbol;
+
+ dyldCache->forEachImage(^(const Header* hdr, const char* installName) {
printf("%s:\n", installName);
- uint64_t cacheBaseAddress = dyldCache->unslidLoadAddress();
- uint64_t dylibBaseAddress = ((dyld3::MachOAnalyzer*)mh)->preferredLoadAddress();
+ uint64_t dylibBaseAddress = hdr->preferredLoadAddress();
dyldCache->forEachPatchableExport(imageIndex, ^(uint32_t dylibVMOffsetOfImpl, const char* exportName,
PatchKind patchKind) {
uint64_t cacheOffsetOfImpl = (dylibBaseAddress + dylibVMOffsetOfImpl) - cacheBaseAddress;
printf(" export: 0x%08llX%s %s\n", cacheOffsetOfImpl,
PatchTable::patchKindName(patchKind), exportName);
+
+ CString exportNameStr(exportName);
dyldCache->forEachPatchableUseOfExport(imageIndex, dylibVMOffsetOfImpl,
^(uint32_t userImageIndex, uint32_t userVMOffset,
dyld3::MachOLoaded::PointerMetaData pmd, uint64_t addend,
@@ -3412,17 +3720,20 @@
// Get the image so that we can convert from dylib offset to cache offset
uint64_t mTime;
uint64_t inode;
- const dyld3::MachOAnalyzer* imageMA = (dyld3::MachOAnalyzer*)(dyldCache->getIndexedImageEntry(userImageIndex, mTime, inode));
- if ( imageMA == nullptr )
+ const Header* imageHdr = (const Header*)(dyldCache->getIndexedImageEntry(userImageIndex, mTime, inode));
+ if ( imageHdr == nullptr )
return;
SegmentInfo usageAt;
- const uint64_t patchLocVmAddr = imageMA->preferredLoadAddress() + userVMOffset;
+ const uint64_t patchLocVmAddr = imageHdr->preferredLoadAddress() + userVMOffset;
const uint64_t patchLocCacheOffset = patchLocVmAddr - cacheBaseAddress;
findImageAndSegment(dyldCache, segInfos, patchLocCacheOffset, &usageAt);
+ if ( !patchKindIsRootOptimized(patchKind) )
+ pagesPerSymbol[exportNameStr].addUse(patchLocVmAddr);
+
// Verify that findImage and the callback image match
- std::string_view userInstallName = imageMA->installName();
+ std::string_view userInstallName = imageHdr->installName();
// FIXME: We can't get this from MachoLoaded without having a fixup location to call
static const char* keyNames[] = {
@@ -3435,21 +3746,27 @@
if ( addend == 0 ) {
if ( pmd.authenticated ) {
- printf(" used by: %s(0x%04llX)%s (PAC: div=%d, addr=%s, key=%s) in %s\n",
- usageAt.segName, sectionOffset, weakImportString,
+ printf(" used by: %.*s(0x%04llX)%s (PAC: div=%d, addr=%s, key=%s) in %s\n",
+ (int)usageAt.segName.size(), usageAt.segName.data(),
+ sectionOffset, weakImportString,
pmd.diversity, pmd.usesAddrDiversity ? "true" : "false", keyNames[pmd.key],
userInstallName.data());
} else {
- printf(" used by: %s(0x%04llX)%s in %s\n", usageAt.segName, sectionOffset, weakImportString, userInstallName.data());
+ printf(" used by: %.*s(0x%04llX)%s in %s\n",
+ (int)usageAt.segName.size(), usageAt.segName.data(),
+ sectionOffset, weakImportString, userInstallName.data());
}
} else {
if ( pmd.authenticated ) {
- printf(" used by: %s(0x%04llX)%s (addend=%lld) (PAC: div=%d, addr=%s, key=%s) in %s\n",
- usageAt.segName, sectionOffset, weakImportString, addend,
+ printf(" used by: %.*s(0x%04llX)%s (addend=%lld) (PAC: div=%d, addr=%s, key=%s) in %s\n",
+ (int)usageAt.segName.size(), usageAt.segName.data(),
+ sectionOffset, weakImportString, addend,
pmd.diversity, pmd.usesAddrDiversity ? "true" : "false", keyNames[pmd.key],
userInstallName.data());
} else {
- printf(" used by: %s(0x%04llX)%s (addend=%lld) in %s\n", usageAt.segName, sectionOffset, weakImportString,
+ printf(" used by: %.*s(0x%04llX)%s (addend=%lld) in %s\n",
+ (int)usageAt.segName.size(), usageAt.segName.data(),
+ sectionOffset, weakImportString,
addend, userInstallName.data());
}
}
@@ -3466,26 +3783,36 @@
"IA", "IB", "DA", "DB"
};
+ if ( !patchKindIsRootOptimized(patchKind) )
+ pagesPerSymbol["GOT"].addUse(cacheBaseAddress + cacheVMOffset);
+
const char* weakImportString = isWeakImport ? " (weak-import)" : "";
if ( addend == 0 ) {
if ( pmd.authenticated ) {
- printf(" used by: GOT%s (PAC: div=%d, addr=%s, key=%s)\n",
- weakImportString, pmd.diversity, pmd.usesAddrDiversity ? "true" : "false", keyNames[pmd.key]);
+ printf(" used by: GOT%s (0x%llx) (PAC: div=%d, addr=%s, key=%s)\n",
+ weakImportString, cacheVMOffset, pmd.diversity, pmd.usesAddrDiversity ? "true" : "false", keyNames[pmd.key]);
} else {
- printf(" used by: GOT%s\n", weakImportString);
+ printf(" used by: GOT%s (0x%llx)\n", weakImportString, cacheVMOffset);
}
} else {
if ( pmd.authenticated ) {
- printf(" used by: GOT%s (addend=%lld) (PAC: div=%d, addr=%s, key=%s)\n",
- weakImportString, addend, pmd.diversity, pmd.usesAddrDiversity ? "true" : "false", keyNames[pmd.key]);
+ printf(" used by: GOT%s (0x%llx) (addend=%lld) (PAC: div=%d, addr=%s, key=%s)\n",
+ weakImportString, cacheVMOffset, addend, pmd.diversity, pmd.usesAddrDiversity ? "true" : "false", keyNames[pmd.key]);
} else {
- printf(" used by: GOT%s (addend=%lld)\n", weakImportString, addend);
+ printf(" used by: GOT%s (0x%llx) (addend=%lld)\n", weakImportString, cacheVMOffset, addend);
}
}
});
});
++imageIndex;
});
+
+ logCostOfRootPerSymbol(pagesPerSymbol);
+ break;
+ }
+ case modeDumpPatchTable: {
+ PatchTable patchTable(dyldCache->patchTable(), dyldCache->header.patchInfoAddr);
+ patchTable.dump();
break;
}
case modeRootsCost: {
@@ -3495,7 +3822,7 @@
__block std::optional<uint32_t> rootImageIndex;
{
__block uint32_t imageIndex = 0;
- dyldCache->forEachImage(^(const mach_header* mh, const char* installName) {
+ dyldCache->forEachImage(^(const Header* hdr, const char* installName) {
if ( strcmp(installName, options.rootsCostOfDylib) == 0 )
rootImageIndex = imageIndex;
++imageIndex;
@@ -3508,15 +3835,18 @@
}
// For each page of the cache, we record if it was dirtied by patching, and by which dylibs
- typedef std::pair<const char*, const char*> InstallNameAndSegment;
+ typedef std::pair<const char*, std::string_view> InstallNameAndSegment;
__block std::map<uint64_t, std::set<InstallNameAndSegment>> pages;
+ __block std::unordered_map<CString, PatchPageMetric> pagesPerSymbol;
uint64_t cacheBaseAddress = dyldCache->unslidLoadAddress();
dyldCache->forEachPatchableExport(rootImageIndex.value(),
^(uint32_t dylibVMOffsetOfImpl, const char* exportName,
PatchKind patchKind) {
- if ( (patchKind == PatchKind::cfObj2) || (patchKind == PatchKind::objcClass) )
+ if ( patchKindIsRootOptimized(patchKind) )
return;
+
+ CString exportNameStr(exportName);
dyldCache->forEachPatchableUseOfExport(rootImageIndex.value(), dylibVMOffsetOfImpl,
^(uint32_t userImageIndex, uint32_t userVMOffset,
dyld3::MachOLoaded::PointerMetaData pmd, uint64_t addend,
@@ -3529,14 +3859,15 @@
return;
SegmentInfo usageAt;
- const uint64_t patchLocVmAddr = imageMA->preferredLoadAddress() + userVMOffset;
+ const uint64_t patchLocVmAddr = ((const Header*)imageMA)->preferredLoadAddress() + userVMOffset;
const uint64_t patchLocCacheOffset = patchLocVmAddr - cacheBaseAddress;
findImageAndSegment(dyldCache, segInfos, patchLocCacheOffset, &usageAt);
// Round to the 16KB page we dirty
//clientUsedPages[userImageIndex].insert(usageAt.vmAddr & ~0x3FFF);
- uint64_t pageAddr = usageAt.vmAddr & ~0x3FFF;
+ uint64_t pageAddr = patchLocVmAddr & ~0x3FFF;
pages[pageAddr].insert({ usageAt.installName, usageAt.segName });
+ pagesPerSymbol[exportNameStr].addUse(pageAddr);
});
// Print GOT uses
@@ -3547,7 +3878,8 @@
// Round to the 16KB page we dirty
//gotUsedPages.insert((cacheBaseAddress + cacheVMOffset) & ~0x3FFF);
uint64_t pageAddr = (cacheBaseAddress + cacheVMOffset) & ~0x3FFF;
- pages[pageAddr].insert({ "GOT", nullptr });
+ pages[pageAddr].insert({ "GOT", "" });
+ pagesPerSymbol["GOT"].addUse(pageAddr);
});
});
@@ -3569,14 +3901,15 @@
else
leafName++;
- if ( installNameAndSegment.second )
- printf("%s(%s)", leafName, installNameAndSegment.second);
+ if ( !installNameAndSegment.second.empty() )
+ printf("%s(%.*s)", leafName, (int)installNameAndSegment.second.size(), installNameAndSegment.second.data());
else
printf("%s", leafName);
}
printf("\n");
}
+ logCostOfRootPerSymbol(pagesPerSymbol);
break;
}
case modeMachHeaders: {
@@ -3588,206 +3921,25 @@
};
printRow("magic", "arch", "filetype", "ncmds", "sizeofcmds", "flags", "installname");
- dyldCache->forEachDylib(^(const dyld3::MachOAnalyzer *ma, const char *installName, uint32_t imageIndex, uint64_t inode, uint64_t mtime, bool &stop) {
+ dyldCache->forEachDylib(^(const Header *mh, const char *installName, uint32_t imageIndex, uint64_t inode, uint64_t mtime, bool &stop) {
+ const dyld3::MachOFile* mf = (const dyld3::MachOFile*)mh;
const char* magic = nullptr;
- if ( ma->magic == MH_MAGIC )
+ if ( mf->magic == MH_MAGIC )
magic = "MH_MAGIC";
- else if ( ma->magic == MH_MAGIC_64 )
+ else if ( mf->magic == MH_MAGIC_64 )
magic = "MH_MAGIC_64";
- else if ( ma->magic == MH_CIGAM )
+ else if ( mf->magic == MH_CIGAM )
magic = "MH_CIGAM";
- else if ( ma->magic == MH_CIGAM_64 )
+ else if ( mf->magic == MH_CIGAM_64 )
magic = "MH_CIGAM_64";
- const char* arch = ma->archName();
- const char* filetype = ma->isDylib() ? "DYLIB" : "UNKNOWN";
- std::string ncmds = dyld3::json::decimal(ma->ncmds);
- std::string sizeofcmds = dyld3::json::decimal(ma->sizeofcmds);
- std::string flags = dyld3::json::hex(ma->flags);
+ const char* arch = mf->archName();
+ const char* filetype = mf->isDylib() ? "DYLIB" : "UNKNOWN";
+ std::string ncmds = json::decimal(mf->ncmds);
+ std::string sizeofcmds = json::decimal(mf->sizeofcmds);
+ std::string flags = json::hex(mf->flags);
printRow(magic, arch, filetype, ncmds.c_str(), sizeofcmds.c_str(), flags.c_str(), installName);
- });
-
- break;
- }
- case modeLoadCommands: {
- dyldCache->forEachDylib(^(const dyld3::MachOAnalyzer *ma, const char *installName, uint32_t imageIndex, uint64_t inode, uint64_t mtime, bool &stop) {
- printf("%s:\n", installName);
-
- Diagnostics diag;
- ma->forEachLoadCommand(diag, ^(const load_command *cmd, bool &stopLC) {
- const char* loadCommandName = "unknown";
- switch (cmd->cmd) {
- case LC_SEGMENT:
- loadCommandName = "LC_SEGMENT";
- break;
- case LC_SYMTAB:
- loadCommandName = "LC_SYMTAB";
- break;
- case LC_SYMSEG:
- loadCommandName = "LC_SYMSEG";
- break;
- case LC_THREAD:
- loadCommandName = "LC_THREAD";
- break;
- case LC_UNIXTHREAD:
- loadCommandName = "LC_UNIXTHREAD";
- break;
- case LC_LOADFVMLIB:
- loadCommandName = "LC_LOADFVMLIB";
- break;
- case LC_IDFVMLIB:
- loadCommandName = "LC_IDFVMLIB";
- break;
- case LC_IDENT:
- loadCommandName = "LC_IDENT";
- break;
- case LC_FVMFILE:
- loadCommandName = "LC_FVMFILE";
- break;
- case LC_PREPAGE:
- loadCommandName = "LC_PREPAGE";
- break;
- case LC_DYSYMTAB:
- loadCommandName = "LC_DYSYMTAB";
- break;
- case LC_LOAD_DYLIB:
- loadCommandName = "LC_LOAD_DYLIB";
- break;
- case LC_ID_DYLIB:
- loadCommandName = "LC_ID_DYLIB";
- break;
- case LC_LOAD_DYLINKER:
- loadCommandName = "LC_LOAD_DYLINKER";
- break;
- case LC_ID_DYLINKER:
- loadCommandName = "LC_ID_DYLINKER";
- break;
- case LC_PREBOUND_DYLIB:
- loadCommandName = "LC_PREBOUND_DYLIB";
- break;
- case LC_ROUTINES:
- loadCommandName = "LC_ROUTINES";
- break;
- case LC_SUB_FRAMEWORK:
- loadCommandName = "LC_SUB_FRAMEWORK";
- break;
- case LC_SUB_UMBRELLA:
- loadCommandName = "LC_SUB_UMBRELLA";
- break;
- case LC_SUB_CLIENT:
- loadCommandName = "LC_SUB_CLIENT";
- break;
- case LC_SUB_LIBRARY:
- loadCommandName = "LC_SUB_LIBRARY";
- break;
- case LC_TWOLEVEL_HINTS:
- loadCommandName = "LC_TWOLEVEL_HINTS";
- break;
- case LC_PREBIND_CKSUM:
- loadCommandName = "LC_PREBIND_CKSUM";
- break;
- case LC_LOAD_WEAK_DYLIB:
- loadCommandName = "LC_LOAD_WEAK_DYLIB";
- break;
- case LC_SEGMENT_64:
- loadCommandName = "LC_SEGMENT_64";
- break;
- case LC_ROUTINES_64:
- loadCommandName = "LC_ROUTINES_64";
- break;
- case LC_UUID:
- loadCommandName = "LC_UUID";
- break;
- case LC_RPATH:
- loadCommandName = "LC_RPATH";
- break;
- case LC_CODE_SIGNATURE:
- loadCommandName = "LC_CODE_SIGNATURE";
- break;
- case LC_SEGMENT_SPLIT_INFO:
- loadCommandName = "LC_SEGMENT_SPLIT_INFO";
- break;
- case LC_REEXPORT_DYLIB:
- loadCommandName = "LC_REEXPORT_DYLIB";
- break;
- case LC_LAZY_LOAD_DYLIB:
- loadCommandName = "LC_LAZY_LOAD_DYLIB";
- break;
- case LC_ENCRYPTION_INFO:
- loadCommandName = "LC_ENCRYPTION_INFO";
- break;
- case LC_DYLD_INFO:
- loadCommandName = "LC_DYLD_INFO";
- break;
- case LC_DYLD_INFO_ONLY:
- loadCommandName = "LC_DYLD_INFO_ONLY";
- break;
- case LC_LOAD_UPWARD_DYLIB:
- loadCommandName = "LC_LOAD_UPWARD_DYLIB";
- break;
- case LC_VERSION_MIN_MACOSX:
- loadCommandName = "LC_VERSION_MIN_MACOSX";
- break;
- case LC_VERSION_MIN_IPHONEOS:
- loadCommandName = "LC_VERSION_MIN_IPHONEOS";
- break;
- case LC_FUNCTION_STARTS:
- loadCommandName = "LC_FUNCTION_STARTS";
- break;
- case LC_DYLD_ENVIRONMENT:
- loadCommandName = "LC_DYLD_ENVIRONMENT";
- break;
- case LC_MAIN:
- loadCommandName = "LC_MAIN";
- break;
- case LC_DATA_IN_CODE:
- loadCommandName = "LC_DATA_IN_CODE";
- break;
- case LC_SOURCE_VERSION:
- loadCommandName = "LC_SOURCE_VERSION";
- break;
- case LC_DYLIB_CODE_SIGN_DRS:
- loadCommandName = "LC_DYLIB_CODE_SIGN_DRS";
- break;
- case LC_ENCRYPTION_INFO_64:
- loadCommandName = "LC_ENCRYPTION_INFO_64";
- break;
- case LC_LINKER_OPTION:
- loadCommandName = "LC_LINKER_OPTION";
- break;
- case LC_LINKER_OPTIMIZATION_HINT:
- loadCommandName = "LC_LINKER_OPTIMIZATION_HINT";
- break;
- case LC_VERSION_MIN_TVOS:
- loadCommandName = "LC_VERSION_MIN_TVOS";
- break;
- case LC_VERSION_MIN_WATCHOS:
- loadCommandName = "LC_VERSION_MIN_WATCHOS";
- break;
- case LC_NOTE:
- loadCommandName = "LC_NOTE";
- break;
- case LC_BUILD_VERSION:
- loadCommandName = "LC_BUILD_VERSION";
- break;
- case LC_DYLD_EXPORTS_TRIE:
- loadCommandName = "LC_DYLD_EXPORTS_TRIE";
- break;
- case LC_DYLD_CHAINED_FIXUPS:
- loadCommandName = "LC_DYLD_CHAINED_FIXUPS";
- break;
- case LC_FILESET_ENTRY:
- loadCommandName = "LC_FILESET_ENTRY";
- break;
- default:
- break;
- }
-
- printf(" %s\n", loadCommandName);
- });
-
- diag.assertNoError();
});
break;
@@ -3873,16 +4025,22 @@
printf(" - imagesCount: 0x%llx\n", (uint64_t)dyldCache->header.imagesCount);
printf(" - cacheSubType: 0x%llx\n", (uint64_t)dyldCache->header.cacheSubType);
printf(" - objcOptsOffset: 0x%llx\n", (uint64_t)dyldCache->header.objcOptsOffset);
- printf(" - objcOptsSize: 0x%llx\n", (uint64_t)dyldCache->header.objcOptsSize);
-
+ printf(" - cacheAtlasOffset: 0x%llx\n", (uint64_t)dyldCache->header.cacheAtlasOffset);
+ printf(" - cacheAtlasSize: 0x%llx\n", (uint64_t)dyldCache->header.cacheAtlasSize);
+ printf(" - dynamicDataOffset: 0x%llx\n", (uint64_t)dyldCache->header.dynamicDataOffset);
+ printf(" - dynamicDataMaxSize: 0x%llx\n", (uint64_t)dyldCache->header.dynamicDataMaxSize);
+ printf(" - tproMappingsOffset: 0x%llx\n", (uint64_t)dyldCache->header.tproMappingsOffset);
+ printf(" - tproMappingsCount: 0x%llx\n", (uint64_t)dyldCache->header.tproMappingsCount);
+ printf(" - functionVariantInfoAddr: 0x%llx\n", (uint64_t)dyldCache->header.functionVariantInfoAddr);
+ printf(" - functionVariantInfoSize: 0x%llx\n", (uint64_t)dyldCache->header.functionVariantInfoSize);
++cacheIndex;
});
break;
}
case modeDylibSymbols:
{
- dyldCache->forEachImage(^(const mach_header* mh, const char* installName) {
- const dyld3::MachOAnalyzer* ma = (dyld3::MachOAnalyzer*)mh;
+ dyldCache->forEachImage(^(const Header* hdr, const char* installName) {
+ const dyld3::MachOAnalyzer* ma = (dyld3::MachOAnalyzer*)hdr;
Diagnostics diag;
printf("%s globals:\n", installName);
@@ -3901,12 +4059,11 @@
break;
}
case modeFunctionStarts: {
- dyldCache->forEachImage(^(const mach_header* mh, const char* installName) {
+ dyldCache->forEachImage(^(const Header* hdr, const char* installName) {
printf("%s:\n", installName);
-
- const dyld3::MachOAnalyzer* ma = (dyld3::MachOAnalyzer*)mh;
- uint64_t loadAddress = ma->preferredLoadAddress();
+ uint64_t loadAddress = hdr->preferredLoadAddress();
Diagnostics diag;
+ const dyld3::MachOAnalyzer* ma = (dyld3::MachOAnalyzer*)hdr;
ma->forEachFunctionStart(^(uint64_t runtimeOffset) {
uint64_t targetVMAddr = loadAddress + runtimeOffset;
printf(" 0x%08llX\n", targetVMAddr);
@@ -3914,17 +4071,24 @@
});
break;
}
+ case modePrewarmingData: {
+ printf("prewarming_data:\n");
+ dyldCache->forEachPrewarmingEntry(^(const void *content, uint64_t unslidVMAddr, uint64_t vmSize) {
+ printf("0x%08llx -> 0x%08llx\n", unslidVMAddr, unslidVMAddr + vmSize);
+ });
+ break;
+ }
case modeDuplicates:
case modeDuplicatesSummary:
{
__block std::map<std::string, std::vector<const char*>> symbolsToInstallNames;
__block std::set<std::string> weakDefSymbols;
- dyldCache->forEachImage(^(const mach_header* mh, const char* installName) {
- const dyld3::MachOAnalyzer* ma = (dyld3::MachOAnalyzer*)mh;
+ dyldCache->forEachImage(^(const Header* hdr, const char* installName) {
+ const dyld3::MachOAnalyzer* ma = (dyld3::MachOAnalyzer*)hdr;
uint32_t exportTrieRuntimeOffset;
uint32_t exportTrieSize;
if ( ma->hasExportTrie(exportTrieRuntimeOffset, exportTrieSize) ) {
- const uint8_t* start = (uint8_t*)mh + exportTrieRuntimeOffset;
+ const uint8_t* start = (uint8_t*)hdr + exportTrieRuntimeOffset;
const uint8_t* end = start + exportTrieSize;
std::vector<ExportInfoTrie::Entry> exports;
if ( ExportInfoTrie::parseTrie(start, end, exports) ) {
@@ -4017,7 +4181,9 @@
case modeObjCClassHashTable:
case modeObjCSelectors:
case modeSwiftProtocolConformances:
+ case modeSwiftPtrTables:
case modeExtract:
+ case modeLookupVA:
break;
}
}