mirror of
https://github.com/VibeDarling/class-dump.git
synced 2026-11-15 09:48:10 -10:00
361 lines
13 KiB
Objective-C
361 lines
13 KiB
Objective-C
// -*- mode: ObjC -*-
|
|
|
|
// This file is part of class-dump, a utility for examining the Objective-C segment of Mach-O files.
|
|
// Copyright (C) 1997-2019 Steve Nygard.
|
|
|
|
#import "CDTypeController.h"
|
|
|
|
#import "CDStructureTable.h"
|
|
#import "CDClassDump.h"
|
|
#import "CDTypeFormatter.h"
|
|
#import "CDType.h"
|
|
|
|
static BOOL debug = NO;
|
|
|
|
@interface CDTypeController ()
|
|
@property (weak, readonly) CDClassDump *classDump;
|
|
@property (readonly) CDStructureTable *structureTable;
|
|
@property (readonly) CDStructureTable *unionTable;
|
|
@end
|
|
|
|
#pragma mark -
|
|
|
|
@implementation CDTypeController
|
|
{
|
|
__weak CDClassDump *_classDump; // passed during formatting, to get at options.
|
|
__weak id <CDTypeControllerDelegate> _delegate;
|
|
|
|
CDTypeFormatter *_ivarTypeFormatter;
|
|
CDTypeFormatter *_methodTypeFormatter;
|
|
CDTypeFormatter *_propertyTypeFormatter;
|
|
CDTypeFormatter *_structDeclarationTypeFormatter;
|
|
|
|
CDStructureTable *_structureTable;
|
|
CDStructureTable *_unionTable;
|
|
}
|
|
|
|
- (id)initWithClassDump:(CDClassDump *)classDump;
|
|
{
|
|
if ((self = [super init])) {
|
|
_classDump = classDump;
|
|
|
|
_ivarTypeFormatter = [[CDTypeFormatter alloc] init];
|
|
_ivarTypeFormatter.shouldExpand = NO;
|
|
_ivarTypeFormatter.shouldAutoExpand = YES;
|
|
_ivarTypeFormatter.baseLevel = 1;
|
|
_ivarTypeFormatter.typeController = self;
|
|
|
|
_methodTypeFormatter = [[CDTypeFormatter alloc] init];
|
|
_methodTypeFormatter.shouldExpand = NO;
|
|
_methodTypeFormatter.shouldAutoExpand = NO;
|
|
_methodTypeFormatter.baseLevel = 0;
|
|
_methodTypeFormatter.typeController = self;
|
|
|
|
_propertyTypeFormatter = [[CDTypeFormatter alloc] init];
|
|
_propertyTypeFormatter.shouldExpand = NO;
|
|
_propertyTypeFormatter.shouldAutoExpand = NO;
|
|
_propertyTypeFormatter.baseLevel = 0;
|
|
_propertyTypeFormatter.typeController = self;
|
|
|
|
_structDeclarationTypeFormatter = [[CDTypeFormatter alloc] init];
|
|
_structDeclarationTypeFormatter.shouldExpand = YES; // But don't expand named struct members...
|
|
_structDeclarationTypeFormatter.shouldAutoExpand = YES;
|
|
_structDeclarationTypeFormatter.baseLevel = 0;
|
|
_structDeclarationTypeFormatter.typeController = self; // But need to ignore some things?
|
|
|
|
_structureTable = [[CDStructureTable alloc] init];
|
|
_structureTable.anonymousBaseName = @"CDStruct_";
|
|
_structureTable.identifier = @"Structs";
|
|
_structureTable.typeController = self;
|
|
|
|
_unionTable = [[CDStructureTable alloc] init];
|
|
_unionTable.anonymousBaseName = @"CDUnion_";
|
|
_unionTable.identifier = @"Unions";
|
|
_unionTable.typeController = self;
|
|
|
|
//[structureTable debugName:@"_xmlSAXHandler"];
|
|
//[structureTable debugName:@"UCKeyboardTypeHeader"];
|
|
//[structureTable debugName:@"UCKeyboardLayout"];
|
|
//[structureTable debugName:@"ppd_group_s"];
|
|
//[structureTable debugName:@"stat"];
|
|
//[structureTable debugName:@"timespec"];
|
|
//[structureTable debugName:@"AudioUnitEvent"];
|
|
//[structureTable debugAnon:@"{?=II}"];
|
|
//[structureTable debugName:@"_CommandStackEntry"];
|
|
//[structureTable debugName:@"_flags"];
|
|
}
|
|
|
|
return self;
|
|
}
|
|
|
|
#pragma mark -
|
|
|
|
- (BOOL)shouldShowIvarOffsets;
|
|
{
|
|
return self.classDump.shouldShowIvarOffsets;
|
|
}
|
|
|
|
- (BOOL)shouldShowMethodAddresses;
|
|
{
|
|
return self.classDump.shouldShowMethodAddresses;
|
|
}
|
|
|
|
- (BOOL)targetArchUses64BitABI;
|
|
{
|
|
return CDArchUses64BitABI(self.classDump.targetArch);
|
|
}
|
|
|
|
#pragma mark -
|
|
|
|
- (CDType *)typeFormatter:(CDTypeFormatter *)typeFormatter replacementForType:(CDType *)type;
|
|
{
|
|
#if 0
|
|
if (type.type == '{') return [structureTable replacementForType:type];
|
|
if (type.type == '(') return [unionTable replacementForType:type];
|
|
#endif
|
|
return nil;
|
|
}
|
|
|
|
- (NSString *)typeFormatter:(CDTypeFormatter *)typeFormatter typedefNameForStructure:(CDType *)structureType level:(NSUInteger)level;
|
|
{
|
|
if (level == 0 && typeFormatter == self.structDeclarationTypeFormatter)
|
|
return nil;
|
|
|
|
if ([self shouldExpandType:structureType] == NO)
|
|
return [self typedefNameForType:structureType];
|
|
|
|
return nil;
|
|
}
|
|
|
|
- (void)typeFormatter:(CDTypeFormatter *)typeFormatter didReferenceClassName:(NSString *)name;
|
|
{
|
|
if ([self.delegate respondsToSelector:@selector(typeController:didReferenceClassName:)])
|
|
[self.delegate typeController:self didReferenceClassName:name];
|
|
}
|
|
|
|
- (void)typeFormatter:(CDTypeFormatter *)typeFormatter didReferenceProtocolNames:(NSArray *)names;
|
|
{
|
|
if ([self.delegate respondsToSelector:@selector(typeController:didReferenceProtocolNames:)])
|
|
[self.delegate typeController:self didReferenceProtocolNames:names];
|
|
}
|
|
|
|
#pragma mark -
|
|
|
|
- (void)appendStructuresToString:(NSMutableString *)resultString;
|
|
{
|
|
if (self.hasUnknownFunctionPointers && self.hasUnknownBlocks) {
|
|
[resultString appendString:@"#pragma mark Function Pointers and Blocks\n\n"];
|
|
} else if (self.hasUnknownFunctionPointers) {
|
|
[resultString appendString:@"#pragma mark Function Pointers\n\n"];
|
|
} else if (self.hasUnknownBlocks) {
|
|
[resultString appendString:@"#pragma mark Blocks\n\n"];
|
|
}
|
|
|
|
if (self.hasUnknownFunctionPointers) {
|
|
[resultString appendFormat:@"typedef void (*CDUnknownFunctionPointerType)(void); // return type and parameters are unknown\n\n"];
|
|
}
|
|
|
|
if (self.hasUnknownBlocks) {
|
|
[resultString appendFormat:@"typedef void (^CDUnknownBlockType)(void); // return type and parameters are unknown\n\n"];
|
|
}
|
|
|
|
[self.structureTable appendNamedStructuresToString:resultString formatter:self.structDeclarationTypeFormatter markName:@"Named Structures"];
|
|
[self.structureTable appendTypedefsToString:resultString formatter:self.structDeclarationTypeFormatter markName:@"Typedef'd Structures"];
|
|
|
|
[self.unionTable appendNamedStructuresToString:resultString formatter:self.structDeclarationTypeFormatter markName:@"Named Unions"];
|
|
[self.unionTable appendTypedefsToString:resultString formatter:self.structDeclarationTypeFormatter markName:@"Typedef'd Unions"];
|
|
}
|
|
|
|
// Call this before calling generateMemberNames.
|
|
- (void)generateTypedefNames;
|
|
{
|
|
[self.structureTable generateTypedefNames];
|
|
[self.unionTable generateTypedefNames];
|
|
}
|
|
|
|
- (void)generateMemberNames;
|
|
{
|
|
[self.structureTable generateMemberNames];
|
|
[self.unionTable generateMemberNames];
|
|
}
|
|
|
|
#pragma mark - Run phase 1+
|
|
|
|
- (void)workSomeMagic;
|
|
{
|
|
[self startPhase1];
|
|
[self startPhase2];
|
|
[self startPhase3];
|
|
|
|
[self generateTypedefNames];
|
|
[self generateMemberNames];
|
|
|
|
if (debug) {
|
|
NSMutableString *str = [NSMutableString string];
|
|
[self.structureTable appendNamedStructuresToString:str formatter:self.structDeclarationTypeFormatter markName:@"Named Structures"];
|
|
[self.unionTable appendNamedStructuresToString:str formatter:self.structDeclarationTypeFormatter markName:@"Named Unions"];
|
|
[str writeToFile:@"/tmp/out.struct" atomically:NO encoding:NSUTF8StringEncoding error:NULL];
|
|
|
|
str = [NSMutableString string];
|
|
[self.structureTable appendTypedefsToString:str formatter:self.structDeclarationTypeFormatter markName:@"Typedef'd Structures"];
|
|
[self.unionTable appendTypedefsToString:str formatter:self.structDeclarationTypeFormatter markName:@"Typedef'd Unions"];
|
|
[str writeToFile:@"/tmp/out.typedef" atomically:NO encoding:NSUTF8StringEncoding error:NULL];
|
|
//NSLog(@"str =\n%@", str);
|
|
}
|
|
}
|
|
|
|
#pragma mark - Phase 0
|
|
|
|
- (void)phase0RegisterStructure:(CDType *)structure usedInMethod:(BOOL)isUsedInMethod;
|
|
{
|
|
if (structure.primitiveType == '{') {
|
|
[self.structureTable phase0RegisterStructure:structure usedInMethod:isUsedInMethod];
|
|
} else if (structure.primitiveType == '(') {
|
|
[self.unionTable phase0RegisterStructure:structure usedInMethod:isUsedInMethod];
|
|
} else {
|
|
NSLog(@"%s, unknown structure type: %d", __cmd, structure.primitiveType);
|
|
}
|
|
}
|
|
|
|
- (void)endPhase:(NSUInteger)phase;
|
|
{
|
|
if (phase == 0) {
|
|
[self.structureTable finishPhase0];
|
|
[self.unionTable finishPhase0];
|
|
}
|
|
}
|
|
|
|
#pragma mark - Phase 1
|
|
|
|
// Phase one builds a list of all of the named and unnamed structures.
|
|
// It does this by going through all the top level structures we found in phase 0.
|
|
- (void)startPhase1;
|
|
{
|
|
//NSLog(@" > %s", __cmd);
|
|
// Structures and unions can be nested, so do phase 1 on each table before finishing the phase.
|
|
[self.structureTable runPhase1];
|
|
[self.unionTable runPhase1];
|
|
|
|
[self.structureTable finishPhase1];
|
|
[self.unionTable finishPhase1];
|
|
//NSLog(@"< %s", __cmd);
|
|
}
|
|
|
|
- (void)phase1RegisterStructure:(CDType *)structure;
|
|
{
|
|
if (structure.primitiveType == '{') {
|
|
[self.structureTable phase1RegisterStructure:structure];
|
|
} else if (structure.primitiveType == '(') {
|
|
[self.unionTable phase1RegisterStructure:structure];
|
|
} else {
|
|
NSLog(@"%s, unknown structure type: %d", __cmd, structure.primitiveType);
|
|
}
|
|
}
|
|
|
|
#pragma mark - Phase 2
|
|
|
|
- (void)startPhase2;
|
|
{
|
|
NSUInteger maxDepth = self.structureTable.phase1_maxDepth;
|
|
if (maxDepth < self.unionTable.phase1_maxDepth)
|
|
maxDepth = self.unionTable.phase1_maxDepth;
|
|
|
|
if (debug) NSLog(@"max structure/union depth is: %lu", maxDepth);
|
|
|
|
for (NSUInteger depth = 1; depth <= maxDepth; depth++) {
|
|
[self.structureTable runPhase2AtDepth:depth];
|
|
[self.unionTable runPhase2AtDepth:depth];
|
|
}
|
|
|
|
//[self.structureTable logPhase2Info];
|
|
[self.structureTable finishPhase2];
|
|
[self.unionTable finishPhase2];
|
|
}
|
|
|
|
- (void)startPhase3;
|
|
{
|
|
// do phase2 merge on all the types from phase 0
|
|
[self.structureTable phase2ReplacementOnPhase0];
|
|
[self.unionTable phase2ReplacementOnPhase0];
|
|
|
|
// Any info referenced by a method, or with >1 reference, gets typedef'd.
|
|
// - Generate name hash based on full type string at this point
|
|
// - Then fill in unnamed fields
|
|
|
|
// Print method/>1 ref names and typedefs
|
|
// Go through all updated phase0_structureInfo types
|
|
// - start merging these into a new table
|
|
// - If this is the first time a structure has been added:
|
|
// - add one reference for each subtype
|
|
// - otherwise just merge them.
|
|
// - end result should be CDStructureInfos with counts and method reference flags
|
|
[self.structureTable buildPhase3Exceptions];
|
|
[self.unionTable buildPhase3Exceptions];
|
|
|
|
[self.structureTable runPhase3];
|
|
[self.unionTable runPhase3];
|
|
|
|
[self.structureTable finishPhase3];
|
|
[self.unionTable finishPhase3];
|
|
//[structureTable logPhase3Info];
|
|
|
|
// - All named structures (minus exceptions like struct _flags) get declared at the top level
|
|
// - All anonymous structures (minus exceptions) referenced by a method
|
|
// OR references >1 time gets typedef'd at the top and referenced by typedef subsequently
|
|
// Celebrate!
|
|
|
|
// Then... what do we do when printing ivars/method types?
|
|
// CDTypeController - (BOOL)shouldExpandType:(CDType *)type;
|
|
// CDTypeController - (NSString *)typedefNameForType:(CDType *)type;
|
|
|
|
//NSLog(@"< %s", __cmd);
|
|
}
|
|
|
|
- (CDType *)phase2ReplacementForType:(CDType *)type;
|
|
{
|
|
if (type.primitiveType == '{') return [self.structureTable phase2ReplacementForType:type];
|
|
if (type.primitiveType == '(') return [self.unionTable phase2ReplacementForType:type];
|
|
|
|
return nil;
|
|
}
|
|
|
|
- (void)phase3RegisterStructure:(CDType *)structure;
|
|
{
|
|
//NSLog(@"%s, type= %@", __cmd, [aStructure typeString]);
|
|
if (structure.primitiveType == '{') [self.structureTable phase3RegisterStructure:structure count:1 usedInMethod:NO];
|
|
if (structure.primitiveType == '(') [self.unionTable phase3RegisterStructure:structure count:1 usedInMethod:NO];
|
|
}
|
|
|
|
- (CDType *)phase3ReplacementForType:(CDType *)type;
|
|
{
|
|
if (type.primitiveType == '{') return [self.structureTable phase3ReplacementForType:type];
|
|
if (type.primitiveType == '(') return [self.unionTable phase3ReplacementForType:type];
|
|
|
|
return nil;
|
|
}
|
|
|
|
#pragma mark -
|
|
|
|
- (BOOL)shouldShowName:(NSString *)name;
|
|
{
|
|
return [self.classDump shouldShowName:name];
|
|
}
|
|
|
|
- (BOOL)shouldExpandType:(CDType *)type;
|
|
{
|
|
if (type.primitiveType == '{') return [self.structureTable shouldExpandType:type];
|
|
if (type.primitiveType == '(') return [self.unionTable shouldExpandType:type];
|
|
|
|
return NO;
|
|
}
|
|
|
|
- (NSString *)typedefNameForType:(CDType *)type;
|
|
{
|
|
if (type.primitiveType == '{') return [self.structureTable typedefNameForType:type];
|
|
if (type.primitiveType == '(') return [self.unionTable typedefNameForType:type];
|
|
|
|
return nil;
|
|
}
|
|
|
|
@end
|