CDClassDump.m

   1 // -*- mode: ObjC -*-
   2
   3 //  This file is part of class-dump, a utility for examining the Objective-C segment of Mach-O files.
   4 //  Copyright (C) 1997-1998, 2000-2001, 2004-2010 Steve Nygard.
   5
   6 #import "CDClassDump.h"
   7
   8 #import "NSArray-Extensions.h"
   9 #import "NSString-Extensions.h"
  10 #import "CDFatArch.h"
  11 #import "CDFatFile.h"
  12 #import "CDLCDylib.h"
  13 #import "CDMachOFile.h"
  14 #import "CDObjectiveCProcessor.h"
  15 #import "CDStructureTable.h"
  16 #import "CDSymbolReferences.h"
  17 #import "CDType.h"
  18 #import "CDTypeFormatter.h"
  19 #import "CDTypeParser.h"
  20 #import "CDVisitor.h"
  21 #import "CDLCSegment.h"
  22 #import "CDTypeController.h"
  23
  24 @implementation CDClassDump
  25
  26 - (id)init;
  27 {
  28     if ([super init] == nil)
  29         return nil;
  30
  31     executablePath = nil;
  32
  33     machOFiles = [[NSMutableArray alloc] init];
  34     machOFilesByID = [[NSMutableDictionary alloc] init];
  35     objcProcessors = [[NSMutableArray alloc] init];
  36
  37     typeController = [[CDTypeController alloc] init];
  38     [typeController setClassDump:self];
  39
  40     // These can be ppc, ppc7400, ppc64, i386, x86_64
  41     targetArch.cputype = CPU_TYPE_ANY;
  42     targetArch.cpusubtype = 0;
  43
  44     flags.shouldShowHeader = YES;
  45
  46     return self;
  47 }
  48
  49 - (void)dealloc;
  50 {
  51     [executablePath release];
  52
  53     [machOFiles release];
  54     [machOFilesByID release];
  55     [objcProcessors release];
  56
  57     [typeController release];
  58
  59     if (flags.shouldMatchRegex)
  60         regfree(&compiledRegex);
  61
  62     [super dealloc];
  63 }
  64
  65 @synthesize executablePath;
  66
  67 - (BOOL)shouldProcessRecursively;
  68 {
  69     return flags.shouldProcessRecursively;
  70 }
  71
  72 - (void)setShouldProcessRecursively:(BOOL)newFlag;
  73 {
  74     flags.shouldProcessRecursively = newFlag;
  75 }
  76
  77 - (BOOL)shouldSortClasses;
  78 {
  79     return flags.shouldSortClasses;
  80 }
  81
  82 - (void)setShouldSortClasses:(BOOL)newFlag;
  83 {
  84     flags.shouldSortClasses = newFlag;
  85 }
  86
  87 - (BOOL)shouldSortClassesByInheritance;
  88 {
  89     return flags.shouldSortClassesByInheritance;
  90 }
  91
  92 - (void)setShouldSortClassesByInheritance:(BOOL)newFlag;
  93 {
  94     flags.shouldSortClassesByInheritance = newFlag;
  95 }
  96
  97 - (BOOL)shouldSortMethods;
  98 {
  99     return flags.shouldSortMethods;
 100 }
 101
 102 - (void)setShouldSortMethods:(BOOL)newFlag;
 103 {
 104     flags.shouldSortMethods = newFlag;
 105 }
 106
 107 - (BOOL)shouldShowIvarOffsets;
 108 {
 109     return flags.shouldShowIvarOffsets;
 110 }
 111
 112 - (void)setShouldShowIvarOffsets:(BOOL)newFlag;
 113 {
 114     flags.shouldShowIvarOffsets = newFlag;
 115 }
 116
 117 - (BOOL)shouldShowMethodAddresses;
 118 {
 119     return flags.shouldShowMethodAddresses;
 120 }
 121
 122 - (void)setShouldShowMethodAddresses:(BOOL)newFlag;
 123 {
 124     flags.shouldShowMethodAddresses = newFlag;
 125 }
 126
 127 - (BOOL)shouldMatchRegex;
 128 {
 129     return flags.shouldMatchRegex;
 130 }
 131
 132 - (void)setShouldMatchRegex:(BOOL)newFlag;
 133 {
 134     if (flags.shouldMatchRegex && newFlag == NO)
 135         regfree(&compiledRegex);
 136
 137     flags.shouldMatchRegex = newFlag;
 138 }
 139
 140 - (BOOL)shouldShowHeader;
 141 {
 142     return flags.shouldShowHeader;
 143 }
 144
 145 - (void)setShouldShowHeader:(BOOL)newFlag;
 146 {
 147     flags.shouldShowHeader = newFlag;
 148 }
 149
 150 - (BOOL)setRegex:(char *)regexCString errorMessage:(NSString **)errorMessagePointer;
 151 {
 152     int result;
 153
 154     if (flags.shouldMatchRegex)
 155         regfree(&compiledRegex);
 156
 157     result = regcomp(&compiledRegex, regexCString, REG_EXTENDED);
 158     if (result != 0) {
 159         char regex_error_buffer[256];
 160
 161         if (regerror(result, &compiledRegex, regex_error_buffer, 256) > 0) {
 162             if (errorMessagePointer != NULL) {
 163                 *errorMessagePointer = [NSString stringWithUTF8String:regex_error_buffer];
 164             }
 165         } else {
 166             if (errorMessagePointer != NULL)
 167                 *errorMessagePointer = nil;
 168         }
 169
 170         return NO;
 171     }
 172
 173     [self setShouldMatchRegex:YES];
 174
 175     return YES;
 176 }
 177
 178 - (BOOL)regexMatchesString:(NSString *)aString;
 179 {
 180     int result;
 181
 182     result = regexec(&compiledRegex, [aString UTF8String], 0, NULL, 0);
 183     if (result != 0) {
 184         if (result != REG_NOMATCH) {
 185             char regex_error_buffer[256];
 186
 187             if (regerror(result, &compiledRegex, regex_error_buffer, 256) > 0)
 188                 NSLog(@"Error with regex matching string, %@", [NSString stringWithUTF8String:regex_error_buffer]);
 189         }
 190
 191         return NO;
 192     }
 193
 194     return YES;
 195 }
 196
 197 - (NSArray *)machOFiles;
 198 {
 199     return machOFiles;
 200 }
 201
 202 - (NSArray *)objcProcessors;
 203 {
 204     return objcProcessors;
 205 }
 206
 207 @synthesize targetArch;
 208
 209 - (BOOL)containsObjectiveCData;
 210 {
 211     for (CDObjectiveCProcessor *processor in objcProcessors) {
 212         if ([processor hasObjectiveCData])
 213             return YES;
 214     }
 215
 216     return NO;
 217 }
 218
 219 - (BOOL)hasEncryptedFiles;
 220 {
 221     for (CDMachOFile *machOFile in machOFiles) {
 222         if ([machOFile isEncrypted]) {
 223             return YES;
 224         }
 225     }
 226
 227     return NO;
 228 }
 229
 230 - (CDTypeController *)typeController;
 231 {
 232     return typeController;
 233 }
 234
 235 // Return YES if successful, NO if there was an error.
 236 - (BOOL)_loadFilename:(NSString *)aFilename;
 237 {
 238     NSData *data;
 239     CDFile *aFile;
 240
 241     data = [[NSData alloc] initWithContentsOfMappedFile:aFilename];
 242
 243     aFile = [CDFile fileWithData:data];
 244     [aFile setFilename:aFilename];
 245
 246     [data release];
 247
 248     if (aFile == nil)
 249         return NO;
 250
 251     return [self loadFile:aFile];
 252 }
 253
 254 - (BOOL)loadFile:(CDFile *)aFile;
 255 {
 256     CDMachOFile *aMachOFile;
 257
 258     //NSLog(@"targetArch: (%08x, %08x)", targetArch.cputype, targetArch.cpusubtype);
 259     aMachOFile = [aFile machOFileWithArch:targetArch];
 260     //NSLog(@"aMachOFile: %@", aMachOFile);
 261     if (aMachOFile == nil) {
 262         fprintf(stderr, "Error: file doesn't contain the specified arch.\n\n");
 263         return NO;
 264     }
 265
 266     // Set before processing recursively.  This was getting caught on CoreUI on 10.6
 267     assert([aMachOFile filename] != nil);
 268     [machOFiles addObject:aMachOFile];
 269     [machOFilesByID setObject:aMachOFile forKey:[aMachOFile filename]];
 270
 271     if ([self shouldProcessRecursively]) {
 272         @try {
 273             for (CDLoadCommand *loadCommand in [aMachOFile loadCommands]) {
 274                 if ([loadCommand isKindOfClass:[CDLCDylib class]]) {
 275                     CDLCDylib *aDylibCommand;
 276
 277                     aDylibCommand = (CDLCDylib *)loadCommand;
 278                     if ([aDylibCommand cmd] == LC_LOAD_DYLIB)
 279                         [self machOFileWithID:[aDylibCommand name]]; // Loads as a side effect
 280                 }
 281             }
 282         }
 283         @catch (NSException *exception) {
 284             [aMachOFile release];
 285             return NO;
 286         }
 287     }
 288
 289     return YES;
 290 }
 291
 292 - (void)processObjectiveCData;
 293 {
 294     for (CDMachOFile *machOFile in machOFiles) {
 295         CDObjectiveCProcessor *aProcessor;
 296
 297         aProcessor = [[[machOFile processorClass] alloc] initWithMachOFile:machOFile];
 298         [aProcessor process];
 299         [objcProcessors addObject:aProcessor];
 300         [aProcessor release];
 301     }
 302 }
 303
 304 // This visits everything segment processors, classes, categories.  It skips over modules.  Need something to visit modules so we can generate separate headers.
 305 - (void)recursivelyVisit:(CDVisitor *)aVisitor;
 306 {
 307     [aVisitor willBeginVisiting];
 308
 309     if ([self containsObjectiveCData] || [self hasEncryptedFiles]) {
 310         for (CDObjectiveCProcessor *processor in objcProcessors) {
 311             [processor recursivelyVisit:aVisitor];
 312         }
 313     }
 314
 315     [aVisitor didEndVisiting];
 316 }
 317
 318 - (CDMachOFile *)machOFileWithID:(NSString *)anID;
 319 {
 320     NSString *adjustedID;
 321     CDMachOFile *aMachOFile;
 322     NSString *replacementString = @"@executable_path";
 323
 324     if ([anID hasPrefix:replacementString]) {
 325         adjustedID = [executablePath stringByAppendingString:[anID substringFromIndex:[replacementString length]]];
 326     } else {
 327         adjustedID = anID;
 328     }
 329
 330     aMachOFile = [machOFilesByID objectForKey:adjustedID];
 331     if (aMachOFile == nil) {
 332         if ([self _loadFilename:adjustedID] == NO)
 333             NSLog(@"Warning: Failed to load: %@", adjustedID);
 334         aMachOFile = [machOFilesByID objectForKey:adjustedID];
 335         if (aMachOFile == nil) {
 336             NSLog(@"Warning: Couldn't load MachOFile with ID: %@, adjustedID: %@", anID, adjustedID);
 337         }
 338     }
 339
 340     return aMachOFile;
 341 }
 342
 343 - (void)appendHeaderToString:(NSMutableString *)resultString;
 344 {
 345     // Since this changes each version, for regression testing it'll be better to be able to not show it.
 346     if (flags.shouldShowHeader == NO)
 347         return;
 348
 349     [resultString appendString:@"/*\n"];
 350     [resultString appendFormat:@" *     Generated by class-dump %s.\n", CLASS_DUMP_VERSION];
 351     [resultString appendString:@" *\n"];
 352     [resultString appendString:@" *     class-dump is Copyright (C) 1997-1998, 2000-2001, 2004-2010 by Steve Nygard.\n"];
 353     [resultString appendString:@" */\n\n"];
 354 }
 355
 356 - (void)registerTypes;
 357 {
 358     for (CDObjectiveCProcessor *processor in objcProcessors) {
 359         [processor registerTypesWithObject:typeController phase:0];
 360     }
 361     [typeController endPhase:0];
 362
 363     [typeController workSomeMagic];
 364 }
 365
 366 - (void)showHeader;
 367 {
 368     if ([machOFiles count] > 0) {
 369         [[[machOFiles lastObject] headerString:YES] print];
 370     }
 371 }
 372
 373 - (void)showLoadCommands;
 374 {
 375     if ([machOFiles count] > 0) {
 376         [[[machOFiles lastObject] loadCommandString:YES] print];
 377     }
 378 }
 379
 380 @end