Loading...
--- dyld/dyld-1340/other-tools/dyld_shared_cache_util.cpp
+++ dyld/dyld-1235.2/other-tools/dyld_shared_cache_util.cpp
@@ -48,7 +48,6 @@
#include <vector>
#include <iostream>
#include <optional>
-#include <ranges>
#include "ClosureFileSystemPhysical.h"
#include "DyldSharedCache.h"
@@ -62,20 +61,14 @@
#include "PrebuiltLoader.h"
#include "DyldProcessConfig.h"
#include "DyldRuntimeState.h"
-#include "Utilities.h"
+#include "Utils.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"
@@ -113,21 +106,17 @@
modeObjCClassHashTable,
modeObjCSelectors,
modeSwiftProtocolConformances,
- modeSwiftPtrTables,
- modeLookupVA,
modeExtract,
modePatchTable,
- modeDumpPatchTable,
modeRootsCost,
modeListDylibsWithSection,
modeDuplicates,
modeDuplicatesSummary,
modeMachHeaders,
+ modeLoadCommands,
modeCacheHeader,
modeDylibSymbols,
modeFunctionStarts,
- modeFunctionVariants,
- modePrewarmingData,
};
struct Options {
@@ -139,7 +128,6 @@
const char* rootPath = nullptr;
const char* fixupsInDylib;
const char* rootsCostOfDylib = nullptr;
- const char* lookupVA = nullptr;
bool printUUIDs;
bool printVMAddrs;
bool printDylibVersions;
@@ -151,7 +139,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 <dylib-path> list dependents of dylib\n"
+ " -dependents <dylb-path> list dependents of dylib\n"
" -linkedit print linkedit contents\n"
" -info print shared cache info\n"
" -stats print size stats\n"
@@ -179,8 +167,6 @@
" -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"
@@ -188,10 +174,7 @@
" -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_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");
+ " -function_starts print address of beginning of each function\n");
}
static void checkMode(Mode mode) {
@@ -202,134 +185,12 @@
}
}
-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;
- std::string_view segName;
+ uint64_t vmAddr;
+ uint64_t vmSize;
+ const char* installName;
+ const char* segName;
};
static void sortSegmentInfo(std::vector<SegmentInfo>& segInfos)
@@ -339,20 +200,21 @@
});
}
-static void buildSegmentInfo(const Header* hdr, std::vector<SegmentInfo>& segInfos)
+static void buildSegmentInfo(const dyld3::MachOAnalyzer* ma, std::vector<SegmentInfo>& segInfos)
{
- const char* installName = hdr->installName();
- hdr->forEachSegment(^(const Header::SegmentInfo& info, bool& stop) {
+ const char* installName = ma->installName();
+ ma->forEachSegment(^(const dyld3::MachOAnalyzer::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.segmentName});
+ segInfos.push_back({info.vmAddr, info.vmSize - 1, installName, info.segName});
});
}
static void buildSegmentInfo(const DyldSharedCache* dyldCache, std::vector<SegmentInfo>& segInfos)
{
- dyldCache->forEachImage(^(const Header* hdr, const char* installName) {
- buildSegmentInfo(hdr, segInfos);
+ dyldCache->forEachImage(^(const mach_header* mh, const char* installName) {
+ dyld3::MachOAnalyzer* ma = (dyld3::MachOAnalyzer*)mh;
+ buildSegmentInfo(ma, segInfos);
});
sortSegmentInfo(segInfos);
}
@@ -821,7 +683,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, { } };
+ const SegmentInfo target = { locVmAddr, 0, NULL, 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;
@@ -841,8 +703,8 @@
static void dumpObjCClassLayout(const DyldSharedCache* dyldCache)
{
- dyldCache->forEachImage(^(const Header *hdr, const char *installName) {
- const dyld3::MachOAnalyzer* ma = (dyld3::MachOAnalyzer*)hdr;
+ dyldCache->forEachImage(^(const mach_header *mh, const char *installName) {
+ const dyld3::MachOAnalyzer* ma = (dyld3::MachOAnalyzer*)mh;
Diagnostics diag;
uint64_t sharedCacheRelativeSelectorBaseVMAddress = dyldCache->sharedCacheRelativeSelectorBaseVMAddress();
@@ -916,8 +778,8 @@
// Map from vmAddr to the category name for that address
__block std::unordered_map<VMAddress, std::string, VMAddressHash, VMAddressEqual> categoryMap;
- dyldCache->forEachImage(^(const Header *hdr, const char *installName) {
- const dyld3::MachOAnalyzer* ma = (dyld3::MachOAnalyzer*)hdr;
+ dyldCache->forEachImage(^(const mach_header *mh, const char *installName) {
+ const dyld3::MachOAnalyzer* ma = (dyld3::MachOAnalyzer*)mh;
Diagnostics diag;
const char* leafName = strrchr(installName, '/');
@@ -969,9 +831,10 @@
});
__block std::map<uint64_t, const char*> dylibVMAddrMap;
- dyldCache->forEachImage(^(const Header *hdr, const char *installName) {
- if ( hdr->hasObjC() )
- dylibVMAddrMap[hdr->preferredLoadAddress()] = installName;
+ dyldCache->forEachImage(^(const mach_header *mh, const char *installName) {
+ const dyld3::MachOAnalyzer* ma = (const dyld3::MachOAnalyzer*)mh;
+ if ( ma->hasObjC() )
+ dylibVMAddrMap[ma->preferredLoadAddress()] = installName;
});
#if 0
@@ -1020,8 +883,8 @@
};
__block std::unordered_set<VMAddress, VMAddressHash, VMAddressEqual> seenCategories;
- dyldCache->forEachImage(^(const Header *hdr, const char *installName) {
- const dyld3::MachOAnalyzer* ma = (dyld3::MachOAnalyzer*)hdr;
+ dyldCache->forEachImage(^(const mach_header *mh, const char *installName) {
+ const dyld3::MachOAnalyzer* ma = (dyld3::MachOAnalyzer*)mh;
Diagnostics diag;
printf("--- %s ---\n", installName);
@@ -1247,49 +1110,6 @@
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[]) {
@@ -1447,20 +1267,6 @@
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;
@@ -1486,12 +1292,6 @@
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;
@@ -1517,7 +1317,8 @@
options.mode = modeMachHeaders;
}
else if (strcmp(opt, "-load_commands") == 0) {
- fprintf(stderr, "dyld_shared_cache_util -load_commands is deprecated. Use dyld_info -load_commands instead\n");
+ checkMode(options.mode);
+ options.mode = modeLoadCommands;
}
else if (strcmp(opt, "-cache_header") == 0) {
checkMode(options.mode);
@@ -1529,9 +1330,6 @@
}
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);
@@ -1570,14 +1368,12 @@
__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;
@@ -1608,7 +1404,6 @@
dyldCache->forEachCache(^(const DyldSharedCache *cache, bool& stopCache) {
dyldCaches.push_back(dyldCache);
});
- cacheOnDisk = false;
}
if ( options.mode == modeSlideInfo || options.mode == modeVerboseSlideInfo ) {
@@ -1644,10 +1439,10 @@
exit(1);
}
- const Header* hdr = (const Header*)dyldCache->getIndexedImageEntry(imageIndex);
+ const auto* ma = (const dyld3::MachOAnalyzer*)dyldCache->getIndexedImageEntry(imageIndex);
__block std::vector<SegmentInfo> dylibSegInfo;
- buildSegmentInfo(hdr, dylibSegInfo);
+ buildSegmentInfo(ma, dylibSegInfo);
sortSegmentInfo(dylibSegInfo);
__block std::vector<SegmentInfo> cacheSegInfo;
@@ -1676,20 +1471,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",
- (int)fixupAt.segName.size(), fixupAt.segName.data(), fixupVMAddr - fixupAt.vmAddr,
- (int)targetAt.segName.size(), targetAt.segName.data(), targetVMAddr - targetAt.vmAddr, targetAt.installName,
+ 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,
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",
- (int)fixupAt.segName.size(), fixupAt.segName.data(), fixupVMAddr - fixupAt.vmAddr,
- (int)targetAt.segName.size(), targetAt.segName.data(), targetVMAddr - targetAt.vmAddr, targetAt.installName,
+ printf("%s(0x%04llX) -> %s(0x%04llX):%s; (high8: 0x%02llX)\n",
+ fixupAt.segName, fixupVMAddr - fixupAt.vmAddr,
+ targetAt.segName, targetVMAddr - targetAt.vmAddr, targetAt.installName,
high8);
} else {
- 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);
+ printf("%s(0x%04llX) -> %s(0x%04llX):%s\n",
+ fixupAt.segName, fixupVMAddr - fixupAt.vmAddr,
+ targetAt.segName, targetVMAddr - targetAt.vmAddr, targetAt.installName);
}
}
};
@@ -1708,14 +1503,16 @@
uuid_string_t uuidString;
uuid_unparse_upper(header->uuid, uuidString);
printf("uuid: %s\n", uuidString);
- printf("platform: %s\n", dyldCache->platform().name().c_str());
+
+ dyld3::Platform platform = dyldCache->platform();
+ printf("platform: %s\n", dyld3::MachOFile::platformName(platform));
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);
@@ -1747,7 +1544,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,
@@ -1763,7 +1560,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,
@@ -1931,20 +1728,26 @@
// 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 Header *hdr, const char *installName) {
+ dyldCache->forEachImage(^(const mach_header *mh, const char *installName) {
__block std::unordered_set<std::string_view> seenStrings;
- const dyld3::MachOAnalyzer* ma = (dyld3::MachOAnalyzer*)hdr;
+ const dyld3::MachOAnalyzer* ma = (dyld3::MachOAnalyzer*)mh;
int64_t slide = ma->getSlide();
uint32_t pointerSize = ma->pointerSize();
- ((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);
+ 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 char* s = (char*)content;
- const char* end = s + info.size;
+ const char* end = s + info.sectSize;
while ( s < end ) {
printf("%s: %s\n", installName, s);
seenStrings.insert(s);
@@ -2020,12 +1823,12 @@
}
if (printExports) {
- dyldCache->forEachImage(^(const Header *hdr, const char *installName) {
- const dyld3::MachOAnalyzer* ma = (dyld3::MachOAnalyzer*)hdr;
+ dyldCache->forEachImage(^(const mach_header *mh, const char *installName) {
+ const dyld3::MachOAnalyzer* ma = (dyld3::MachOAnalyzer*)mh;
uint32_t exportTrieRuntimeOffset;
uint32_t exportTrieSize;
if ( ma->hasExportTrie(exportTrieRuntimeOffset, exportTrieSize) ) {
- const uint8_t* start = (uint8_t*)hdr + exportTrieRuntimeOffset;
+ const uint8_t* start = (uint8_t*)mh + exportTrieRuntimeOffset;
const uint8_t* end = start + exportTrieSize;
std::vector<ExportInfoTrie::Entry> exports;
if ( !ExportInfoTrie::parseTrie(start, end, exports) ) {
@@ -2033,12 +1836,10 @@
}
for (const ExportInfoTrie::Entry& entry: exports) {
- const char* flags = "";
+ const char* resolver = "";
if ( entry.info.flags & EXPORT_SYMBOL_FLAGS_STUB_AND_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);
+ resolver = " (resolver)";
+ printf("%s: %s%s\n", installName, entry.name.c_str(), resolver);
}
}
});
@@ -2046,11 +1847,11 @@
}
else if ( options.mode == modeSectionSizes ) {
__block std::map<std::string, uint64_t> sectionSizes;
- 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;
+ 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;
});
});
for (const auto& keyAndValue : sectionSizes) {
@@ -2067,18 +1868,12 @@
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));
@@ -2088,9 +1883,10 @@
// Dump the objc indices
__block std::map<uint64_t, const char*> dylibVMAddrMap;
- dyldCache->forEachImage(^(const Header *hdr, const char *installName) {
- if ( hdr->hasObjC() )
- dylibVMAddrMap[hdr->preferredLoadAddress()] = installName;
+ dyldCache->forEachImage(^(const mach_header *mh, const char *installName) {
+ const dyld3::MachOAnalyzer* ma = (const dyld3::MachOAnalyzer*)mh;
+ if ( ma->hasObjC() )
+ dylibVMAddrMap[ma->preferredLoadAddress()] = installName;
});
std::vector<std::pair<std::string_view, const objc::objc_image_info*>> objcDylibs;
@@ -2167,9 +1963,10 @@
}
__block std::map<uint64_t, const char*> dylibVMAddrMap;
- dyldCache->forEachImage(^(const Header *hdr, const char *installName) {
- if ( hdr->hasObjC() )
- dylibVMAddrMap[hdr->preferredLoadAddress()] = installName;
+ dyldCache->forEachImage(^(const mach_header *mh, const char *installName) {
+ const dyld3::MachOAnalyzer* ma = (const dyld3::MachOAnalyzer*)mh;
+ if ( ma->hasObjC() )
+ dylibVMAddrMap[ma->preferredLoadAddress()] = installName;
});
__block std::map<uint16_t, const char*> dylibMap;
@@ -2263,12 +2060,14 @@
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 ( Platform(dyld_get_active_platform()) != dyldCache->platform() ) {
+ if ( (dyld3::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;
@@ -2280,8 +2079,8 @@
uint64_t sharedCacheRelativeSelectorBaseVMAddress = dyldCache->sharedCacheRelativeSelectorBaseVMAddress();
- using json::Node;
- using json::NodeValueType;
+ using dyld3::json::Node;
+ using dyld3::json::NodeValueType;
std::string instancePrefix("-");
std::string classPrefix("+");
@@ -2290,7 +2089,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 Header *mh, const char *installName) {
+ dyldCache->forEachImage(^(const mach_header *mh, const char *installName) {
const dyld3::MachOAnalyzer* ma = (const dyld3::MachOAnalyzer*)mh;
__block objc_visitor::Visitor visitor(dyldCache, ma, VMAddress(sharedCacheRelativeSelectorBaseVMAddress));
@@ -2441,7 +2240,7 @@
// are exported
std::set<uint64_t> exportedSymbolVMAddrs;
{
- uint64_t loadAddress = ((const Header*)ma)->preferredLoadAddress();
+ uint64_t loadAddress = ma->preferredLoadAddress();
uint32_t exportTrieRuntimeOffset;
uint32_t exportTrieSize;
@@ -2735,9 +2534,9 @@
__block bool needsComma = false;
- json::streamArrayBegin(needsComma);
-
- dyldCache->forEachImage(^(const Header *mh, const char *installName) {
+ dyld3::json::streamArrayBegin(needsComma);
+
+ dyldCache->forEachImage(^(const mach_header *mh, const char *installName) {
const dyld3::MachOAnalyzer* ma = (const dyld3::MachOAnalyzer*)mh;
objc_visitor::Visitor visitor(dyldCache, ma, VMAddress(sharedCacheRelativeSelectorBaseVMAddress));
@@ -2762,7 +2561,7 @@
if (selrefs.has_value())
imageRecord.map["selrefs"] = selrefs.value();
- json::streamArrayNode(needsComma, imageRecord);
+ dyld3::json::streamArrayNode(needsComma, imageRecord);
});
const dyld3::MachOAnalyzer* mainMA = nullptr;
@@ -2783,7 +2582,7 @@
}
KernelArgs kernArgs(mainMA, {"test.exe"}, {}, {});
- Allocator& alloc = MemoryManager::memoryManager().defaultAllocator();
+ Allocator& alloc = Allocator::defaultAllocator();
SyscallDelegate osDelegate;
osDelegate._dyldCache = dyldCache;
osDelegate._rootPath = options.rootPath;
@@ -2796,10 +2595,9 @@
__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, const int fileDescriptor) {
- uint64_t sliceOffset;
+ state.config.syscall.withReadOnlyMappedFile(diag, executableRuntimePath, checkIfOSBinary, ^(const void* mapping, size_t mappedSize, bool isOSBinary, const FileID& fileID, const char* canonicalPath) {
uint64_t sliceSize;
- if ( const dyld3::MachOFile* mf = dyld3::MachOFile::compatibleSlice(diag, sliceOffset, sliceSize, mapping, mappedSize, executableRuntimePath, state.config.process.platform, isOSBinary, *state.config.process.archs) ) {
+ if ( const dyld3::MachOFile* mf = dyld3::MachOFile::compatibleSlice(diag, sliceSize, mapping, mappedSize, executableRuntimePath, state.config.process.platform, isOSBinary, *state.config.process.archs) ) {
dyld3::closure::FileSystemPhysical fileSystem;
dyld3::closure::LoadedFileInfo fileInfo = {
.fileContent = (void*)mf,
@@ -2859,12 +2657,12 @@
if (selrefs.has_value())
imageRecord.map["selrefs"] = selrefs.value();
- json::streamArrayNode(needsComma, imageRecord);
+ dyld3::json::streamArrayNode(needsComma, imageRecord);
}
});
});
- json::streamArrayEnd(needsComma);
+ dyld3::json::streamArrayEnd(needsComma);
}
else if ( options.mode == modeObjCClassLayout ) {
dumpObjCClassLayout(dyldCache);
@@ -2894,21 +2692,21 @@
return a < b;
});
- json::Node root;
+ dyld3::json::Node root;
for (const char* selName : selNames) {
- json::Node selNode;
- selNode.map["selectorName"] = json::Node{selName};
- selNode.map["offset"] = json::Node{(int64_t)selName - (int64_t)dyldCache};
+ dyld3::json::Node selNode;
+ selNode.map["selectorName"] = dyld3::json::Node{selName};
+ selNode.map["offset"] = dyld3::json::Node{(int64_t)selName - (int64_t)dyldCache};
root.array.push_back(selNode);
}
- json::printJSON(root, 0, std::cout);
+ dyld3::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 Header *mh, const char *installName) {
+ dyldCache->forEachImage(^(const mach_header *mh, const char *installName) {
const dyld3::MachOAnalyzer* ma = (const dyld3::MachOAnalyzer*)mh;
Diagnostics diag;
@@ -2936,7 +2734,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 Header *mh, const char *installName) {
+ dyldCache->forEachImage(^(const mach_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) {
@@ -3000,11 +2798,12 @@
auto getDylibForAddress = ^(uint64_t vmAddress) {
__block std::string_view dylibName;
- dyldCache->forEachImage(^(const Header *mh, const char *installName) {
+ dyldCache->forEachImage(^(const mach_header *mh, const char *installName) {
if ( !dylibName.empty() )
return;
- ((const Header*)mh)->forEachSegment(^(const Header::SegmentInfo &info, bool &stop) {
- if ( (vmAddress >= info.vmaddr) && (vmAddress < (info.vmaddr + info.vmsize)) ) {
+ 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)) ) {
dylibName = installName;
stop = true;
}
@@ -3021,7 +2820,7 @@
return 0;
}
printf("Swift optimization version: %d\n", swiftOptHeader->version);
- if ( swiftOptHeader->version == 1 || swiftOptHeader->version == 2 || swiftOptHeader->version == 3 ) {
+ if ( swiftOptHeader->version == 1 || swiftOptHeader->version == 2 ) {
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) {
@@ -3181,79 +2980,6 @@
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);
}
@@ -3272,9 +2998,9 @@
__block const void* objcCacheOffsets = nullptr;
__block int impCachesVersion = 1;
__block Diagnostics diag;
- dyldCache->forEachImage(^(const Header* hdr, const char* installName) {
+ dyldCache->forEachImage(^(const mach_header* mh, const char* installName) {
if ( !strcmp(installName, "/usr/lib/libobjc.A.dylib") ) {
- const dyld3::MachOAnalyzer* ma = (const dyld3::MachOAnalyzer*)hdr;
+ const dyld3::MachOAnalyzer* ma = (const dyld3::MachOAnalyzer*)mh;
objcCacheOffsets = ma->findSectionContent("__DATA_CONST", "__objc_scoffs", objcCacheOffsetsSize);
dyld3::MachOAnalyzer::FoundSymbol foundInfo;
if (ma->findExportedSymbol(diag, "_objc_opt_preopt_caches_version", false, foundInfo, nullptr)) {
@@ -3303,7 +3029,7 @@
uint64_t sharedCacheRelativeSelectorBaseVMAddress = dyldCache->sharedCacheRelativeSelectorBaseVMAddress();
- dyldCache->forEachImage(^(const Header *mh, const char *installName) {
+ dyldCache->forEachImage(^(const mach_header *mh, const char *installName) {
if (diag.hasError())
return;
@@ -3349,8 +3075,7 @@
if (diag.hasError())
return 1;
- __block bool anyBadEntry = false;
- dyldCache->forEachImage(^(const Header *mh, const char *installName) {
+ dyldCache->forEachImage(^(const mach_header *mh, const char *installName) {
if (diag.hasError())
return;
@@ -3375,26 +3100,21 @@
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;
- 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);
+ printf("%s (%s): %d buckets\n", className, type, impCache->cache_mask + 1);
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;
- 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);
+ printf("%s (%s): %d buckets\n", className, type, impCache->cache_mask + 1);
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;
@@ -3403,17 +3123,14 @@
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)
@@ -3430,21 +3147,12 @@
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) (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;
- }
+ printf(" - 0x%016llx: %s (from %s)\n", imp, (const char*)(sel + slide), it->second);
}
}
};
ma->forEachObjCClass(diag, vmAddrConverter, visitClass);
});
- if ( anyBadEntry ) {
- fprintf(stderr, "IMP cache is malformed\n");
- exit(1);
- }
} else {
switch ( options.mode ) {
case modeList: {
@@ -3495,9 +3203,10 @@
break;
}
case modeListDylibsWithSection: {
- 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) ) {
+ 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) ) {
printf("%s\n", installName);
stop = true;
}
@@ -3508,14 +3217,13 @@
case modeMap: {
__block std::map<uint64_t, const char*> dataSegNames;
__block std::map<uint64_t, uint64_t> dataSegEnds;
- 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;
+ 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;
}
});
});
@@ -3532,7 +3240,7 @@
}
case modeDependencies: {
__block bool dependentTargetFound = false;
- dyldCache->forEachImage(^(const Header* hdr, const char* installName) {
+ dyldCache->forEachImage(^(const mach_header* mh, const char* installName) {
if ( strcmp(options.dependentsOfPath, installName) != 0 )
return;
dependentTargetFound = true;
@@ -3560,14 +3268,14 @@
}
};
- dyld3::MachOFile* mf = (dyld3::MachOFile*)hdr;
+ dyld3::MachOFile* mf = (dyld3::MachOFile*)mh;
// First print out our dylib and version.
const char* dylibInstallName;
- Version32 currentVersion;
- Version32 compatVersion;
- if ( hdr->getDylibInstallName(&dylibInstallName, &compatVersion, ¤tVersion) ) {
- printDep(dylibInstallName, compatVersion.value(), currentVersion.value());
+ uint32_t currentVersion;
+ uint32_t compatVersion;
+ if ( mf->getDylibInstallName(&dylibInstallName, &compatVersion, ¤tVersion) ) {
+ printDep(dylibInstallName, compatVersion, currentVersion);
}
// Then the dependent dylibs.
@@ -3599,8 +3307,8 @@
}
};
- dyldCache->forEachImage(^(const Header* hdr, const char* installName) {
- dyld3::MachOAnalyzer* ma = (dyld3::MachOAnalyzer*)hdr;
+ dyldCache->forEachImage(^(const mach_header* mh, const char* installName) {
+ dyld3::MachOAnalyzer* ma = (dyld3::MachOAnalyzer*)mh;
Diagnostics diag;
dyld3::MachOAnalyzer::LinkEditInfo leInfo;
ma->getLinkEditPointers(diag, leInfo);
@@ -3665,9 +3373,11 @@
const char* path;
};
__block std::vector<TextInfo> textSegments;
- dyldCache->forEachImage(^(const Header* hdr, const char* installName) {
- hdr->forEachSegment(^(const Header::SegmentInfo &info, bool &stop) {
- if ( info.segmentName != "__TEXT" )
+ 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 )
return;
textSegments.push_back({ info.fileSize, installName });
});
@@ -3680,39 +3390,21 @@
}
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;
- __block std::unordered_map<CString, PatchPageMetric> pagesPerSymbol;
-
- dyldCache->forEachImage(^(const Header* hdr, const char* installName) {
+ dyldCache->forEachImage(^(const mach_header* mh, const char* installName) {
printf("%s:\n", installName);
- uint64_t dylibBaseAddress = hdr->preferredLoadAddress();
+ uint64_t cacheBaseAddress = dyldCache->unslidLoadAddress();
+ uint64_t dylibBaseAddress = ((dyld3::MachOAnalyzer*)mh)->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,
@@ -3720,20 +3412,17 @@
// Get the image so that we can convert from dylib offset to cache offset
uint64_t mTime;
uint64_t inode;
- const Header* imageHdr = (const Header*)(dyldCache->getIndexedImageEntry(userImageIndex, mTime, inode));
- if ( imageHdr == nullptr )
+ const dyld3::MachOAnalyzer* imageMA = (dyld3::MachOAnalyzer*)(dyldCache->getIndexedImageEntry(userImageIndex, mTime, inode));
+ if ( imageMA == nullptr )
return;
SegmentInfo usageAt;
- const uint64_t patchLocVmAddr = imageHdr->preferredLoadAddress() + userVMOffset;
+ const uint64_t patchLocVmAddr = imageMA->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 = imageHdr->installName();
+ std::string_view userInstallName = imageMA->installName();
// FIXME: We can't get this from MachoLoaded without having a fixup location to call
static const char* keyNames[] = {
@@ -3746,27 +3435,21 @@
if ( addend == 0 ) {
if ( pmd.authenticated ) {
- 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,
+ printf(" used by: %s(0x%04llX)%s (PAC: div=%d, addr=%s, key=%s) in %s\n",
+ usageAt.segName, sectionOffset, weakImportString,
pmd.diversity, pmd.usesAddrDiversity ? "true" : "false", keyNames[pmd.key],
userInstallName.data());
} else {
- printf(" used by: %.*s(0x%04llX)%s in %s\n",
- (int)usageAt.segName.size(), usageAt.segName.data(),
- sectionOffset, weakImportString, userInstallName.data());
+ printf(" used by: %s(0x%04llX)%s in %s\n", usageAt.segName, 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",
- (int)usageAt.segName.size(), usageAt.segName.data(),
- sectionOffset, weakImportString, addend,
+ printf(" used by: %s(0x%04llX)%s (addend=%lld) (PAC: div=%d, addr=%s, key=%s) in %s\n",
+ usageAt.segName, 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",
- (int)usageAt.segName.size(), usageAt.segName.data(),
- sectionOffset, weakImportString,
+ printf(" used by: %s(0x%04llX)%s (addend=%lld) in %s\n", usageAt.segName, sectionOffset, weakImportString,
addend, userInstallName.data());
}
}
@@ -3783,36 +3466,26 @@
"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 (0x%llx) (PAC: div=%d, addr=%s, key=%s)\n",
- weakImportString, cacheVMOffset, pmd.diversity, pmd.usesAddrDiversity ? "true" : "false", keyNames[pmd.key]);
+ printf(" used by: GOT%s (PAC: div=%d, addr=%s, key=%s)\n",
+ weakImportString, pmd.diversity, pmd.usesAddrDiversity ? "true" : "false", keyNames[pmd.key]);
} else {
- printf(" used by: GOT%s (0x%llx)\n", weakImportString, cacheVMOffset);
+ printf(" used by: GOT%s\n", weakImportString);
}
} else {
if ( pmd.authenticated ) {
- 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]);
+ 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]);
} else {
- printf(" used by: GOT%s (0x%llx) (addend=%lld)\n", weakImportString, cacheVMOffset, addend);
+ printf(" used by: GOT%s (addend=%lld)\n", weakImportString, addend);
}
}
});
});
++imageIndex;
});
-
- logCostOfRootPerSymbol(pagesPerSymbol);
- break;
- }
- case modeDumpPatchTable: {
- PatchTable patchTable(dyldCache->patchTable(), dyldCache->header.patchInfoAddr);
- patchTable.dump();
break;
}
case modeRootsCost: {
@@ -3822,7 +3495,7 @@
__block std::optional<uint32_t> rootImageIndex;
{
__block uint32_t imageIndex = 0;
- dyldCache->forEachImage(^(const Header* hdr, const char* installName) {
+ dyldCache->forEachImage(^(const mach_header* mh, const char* installName) {
if ( strcmp(installName, options.rootsCostOfDylib) == 0 )
rootImageIndex = imageIndex;
++imageIndex;
@@ -3835,18 +3508,15 @@
}
// For each page of the cache, we record if it was dirtied by patching, and by which dylibs
- typedef std::pair<const char*, std::string_view> InstallNameAndSegment;
+ typedef std::pair<const char*, const char*> 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 ( patchKindIsRootOptimized(patchKind) )
+ if ( (patchKind == PatchKind::cfObj2) || (patchKind == PatchKind::objcClass) )
return;
-
- CString exportNameStr(exportName);
dyldCache->forEachPatchableUseOfExport(rootImageIndex.value(), dylibVMOffsetOfImpl,
^(uint32_t userImageIndex, uint32_t userVMOffset,
dyld3::MachOLoaded::PointerMetaData pmd, uint64_t addend,
@@ -3859,15 +3529,14 @@
return;
SegmentInfo usageAt;
- const uint64_t patchLocVmAddr = ((const Header*)imageMA)->preferredLoadAddress() + userVMOffset;
+ const uint64_t patchLocVmAddr = 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 = patchLocVmAddr & ~0x3FFF;
+ uint64_t pageAddr = usageAt.vmAddr & ~0x3FFF;
pages[pageAddr].insert({ usageAt.installName, usageAt.segName });
- pagesPerSymbol[exportNameStr].addUse(pageAddr);
});
// Print GOT uses
@@ -3878,8 +3547,7 @@
// Round to the 16KB page we dirty
//gotUsedPages.insert((cacheBaseAddress + cacheVMOffset) & ~0x3FFF);
uint64_t pageAddr = (cacheBaseAddress + cacheVMOffset) & ~0x3FFF;
- pages[pageAddr].insert({ "GOT", "" });
- pagesPerSymbol["GOT"].addUse(pageAddr);
+ pages[pageAddr].insert({ "GOT", nullptr });
});
});
@@ -3901,15 +3569,14 @@
else
leafName++;
- if ( !installNameAndSegment.second.empty() )
- printf("%s(%.*s)", leafName, (int)installNameAndSegment.second.size(), installNameAndSegment.second.data());
+ if ( installNameAndSegment.second )
+ printf("%s(%s)", leafName, installNameAndSegment.second);
else
printf("%s", leafName);
}
printf("\n");
}
- logCostOfRootPerSymbol(pagesPerSymbol);
break;
}
case modeMachHeaders: {
@@ -3921,25 +3588,206 @@
};
printRow("magic", "arch", "filetype", "ncmds", "sizeofcmds", "flags", "installname");
- 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;
+ dyldCache->forEachDylib(^(const dyld3::MachOAnalyzer *ma, const char *installName, uint32_t imageIndex, uint64_t inode, uint64_t mtime, bool &stop) {
const char* magic = nullptr;
- if ( mf->magic == MH_MAGIC )
+ if ( ma->magic == MH_MAGIC )
magic = "MH_MAGIC";
- else if ( mf->magic == MH_MAGIC_64 )
+ else if ( ma->magic == MH_MAGIC_64 )
magic = "MH_MAGIC_64";
- else if ( mf->magic == MH_CIGAM )
+ else if ( ma->magic == MH_CIGAM )
magic = "MH_CIGAM";
- else if ( mf->magic == MH_CIGAM_64 )
+ else if ( ma->magic == MH_CIGAM_64 )
magic = "MH_CIGAM_64";
- 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);
+ 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);
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;
@@ -4025,22 +3873,16 @@
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(" - 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);
+ printf(" - objcOptsSize: 0x%llx\n", (uint64_t)dyldCache->header.objcOptsSize);
+
++cacheIndex;
});
break;
}
case modeDylibSymbols:
{
- dyldCache->forEachImage(^(const Header* hdr, const char* installName) {
- const dyld3::MachOAnalyzer* ma = (dyld3::MachOAnalyzer*)hdr;
+ dyldCache->forEachImage(^(const mach_header* mh, const char* installName) {
+ const dyld3::MachOAnalyzer* ma = (dyld3::MachOAnalyzer*)mh;
Diagnostics diag;
printf("%s globals:\n", installName);
@@ -4059,11 +3901,12 @@
break;
}
case modeFunctionStarts: {
- dyldCache->forEachImage(^(const Header* hdr, const char* installName) {
+ dyldCache->forEachImage(^(const mach_header* mh, const char* installName) {
printf("%s:\n", installName);
- uint64_t loadAddress = hdr->preferredLoadAddress();
+
+ const dyld3::MachOAnalyzer* ma = (dyld3::MachOAnalyzer*)mh;
+ uint64_t loadAddress = ma->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);
@@ -4071,24 +3914,17 @@
});
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 Header* hdr, const char* installName) {
- const dyld3::MachOAnalyzer* ma = (dyld3::MachOAnalyzer*)hdr;
+ dyldCache->forEachImage(^(const mach_header* mh, const char* installName) {
+ const dyld3::MachOAnalyzer* ma = (dyld3::MachOAnalyzer*)mh;
uint32_t exportTrieRuntimeOffset;
uint32_t exportTrieSize;
if ( ma->hasExportTrie(exportTrieRuntimeOffset, exportTrieSize) ) {
- const uint8_t* start = (uint8_t*)hdr + exportTrieRuntimeOffset;
+ const uint8_t* start = (uint8_t*)mh + exportTrieRuntimeOffset;
const uint8_t* end = start + exportTrieSize;
std::vector<ExportInfoTrie::Entry> exports;
if ( ExportInfoTrie::parseTrie(start, end, exports) ) {
@@ -4181,9 +4017,7 @@
case modeObjCClassHashTable:
case modeObjCSelectors:
case modeSwiftProtocolConformances:
- case modeSwiftPtrTables:
case modeExtract:
- case modeLookupVA:
break;
}
}