![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to RelocManager.m CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / debug / Common|
Return to RelocManager.m CVS log | Up to [Apple XNU] / GNUtools / debug / Common |
1.1 root 1: #import "RelocManager.h"
2: #import <stdlib.h>
3: #import <string.h>
4: #import <mach-o/loader.h>
5: #import <libc.h>
6:
7: @implementation RelocManager
8:
9: -init
10: {
11: rmFlags.invalid = YES;
12: rmFlags.shouldSortRelocs = YES;
13: return self;
14: }
15:
16: -free
17: {
18: [self invalidate];
19: return [super free];
20: }
21:
22: int compareRelocsSort(const void *v1, const void *v2)
23: {
24: const Reloc *r1 = v1, *r2 = v2;
25: pointer_t a1 = r1->address, a2 = r2->address;
26: return a1 < a2 ? -1 : (a1 == a2 ? 0 : 1);
27: }
28:
29: int compareRelocsSearch(const void *v1, const void *v2)
30: {
31: const Reloc *r1 = v1, *r2 = v2;
32: pointer_t address = r1->address;
33: return address < r2->address ? -1 : (address >= r2->maxAddress ? 1 : 0);
34: }
35:
36: -(Reloc *)relocFor: (const void *)pointer
37: {
38: Reloc *reloc;
39: int count;
40: BOOL found, tooFar;
41: if (rmFlags.invalid)
42: [self readInAllRelocs];
43: if (lastReloc
44: && (lastReloc->address <= (pointer_t)pointer)
45: && ((pointer_t)pointer < (lastReloc->maxAddress)))
46: return lastReloc;
47: else {
48: #if 1
49: Reloc keyReloc;
50: keyReloc.address = (pointer_t)pointer;
51: if (reloc = bsearch(&keyReloc, relocs, numRelocs, relocSize, compareRelocsSearch))
52: found = YES;
53: else
54: found = NO;
55: #else
56: reloc = relocs;
57: for (count = numRelocs, found = NO, tooFar = NO;
58: count && !found && !tooFar; count--) {
59: if ((pointer_t)pointer < (reloc->maxAddress)) {
60: if (reloc->address <= (pointer_t)pointer)
61: found = YES;
62: else
63: tooFar = YES;
64: } else
65: ((void *)reloc) += relocSize;
66: }
67: #endif
68: if (found && (reloc->rFlags.readIn || [self readInReloc: reloc])) {
69: lastReloc = reloc;
70: return reloc;
71: } else
72: return NULL;
73: }
74: }
75:
76: -(BOOL)readInReloc: (Reloc *)reloc
77: {
78: [self subclassResponsibility: _cmd];
79: return NO;
80: }
81:
82: -(void)_readInAllRelocs
83: {
84: [self subclassResponsibility: _cmd];
85: }
86:
87: -(void)readInAllRelocs
88: {
89: [self _readInAllRelocs];
90: if (rmFlags.shouldSortRelocs)
91: qsort(relocs, numRelocs, relocSize, compareRelocsSort);
92: }
93:
94: -invalidate
95: {
96: if (rmFlags.invalid)
97: return self;
98: else {
99: if (relocs) {
100: free(relocs); relocs = NULL;
101: }
102: numRelocs = 0;
103: lastReloc = NULL;
104: rmFlags.invalid = YES;
105: return self;
106: }
107: }
108:
109: -(Reloc *)oldRelocFor: (const void *)pointer
110: {
111: int count;
112: BOOL found;
113: Reloc *reloc;
114: if (lastReloc
115: && (lastReloc->data <= (pointer_t)pointer)
116: && ((pointer_t)pointer < lastReloc->maxData))
117: return lastReloc;
118: else {
119: reloc = relocs;
120: for (count = numRelocs, found = NO; count && !found; count--) {
121: if (reloc->rFlags.readIn && (reloc->data <= (pointer_t)pointer)
122: && ((pointer_t)pointer < reloc->maxData))
123: found = YES;
124: else
125: ((void *)reloc) += relocSize;
126: }
127: if (found) {
128: lastReloc = reloc;
129: return reloc;
130: } else
131: return NULL;
132: }
133: }
134:
135: -(void *)originalPointerFor: (const void *)pointer
136: {
137: Reloc *reloc = [self oldRelocFor: pointer];
138: if (reloc)
139: return (void *)(reloc->address + (pointer - reloc->data));
140: else
141: return NULL;
142: }
143:
144: -(void *)pointerFor: (const void *)pointer
145: {
146: Reloc *reloc;
147: if (pointer && (reloc = [self relocFor: pointer]))
148: return (void *)((pointer_t)pointer + reloc->displacement);
149: else
150: return NULL;
151: }
152:
153: -(char *)pointerForString: (const char *)pointer isNullTerminated: (BOOL *)isNT
154: {
155: char *retPointer;
156: Reloc *reloc;
157: char *string;
158: if (pointer && (reloc = [self relocFor: pointer])) {
159: retPointer = (char *)((pointer_t)pointer + reloc->displacement);
160: for (string = retPointer;
161: *string && ((pointer_t)string < reloc->maxData);
162: string++);
163: *isNT = *string ? NO : YES;
164: return retPointer;
165: } else{
166: *isNT = NO;
167: return NULL;
168: }
169: }
170:
171: -(char *)pointerForString: (const char *)string
172: {
173: BOOL isNT;
174: char *retPointer;
175: if ((retPointer = [self pointerForString: string isNullTerminated: &isNT])
176: && isNT)
177: return retPointer;
178: else
179: return NULL;
180: }
181:
182: -(void *)pointerFor: (const void *)pointer withSize: (int)size
183: {
184: Reloc *reloc;
185: pointer_t newPointer;
186: if (pointer && (reloc = [self relocFor: pointer])) {
187: newPointer = (pointer_t)pointer + reloc->displacement;
188: if ((newPointer + size) <= reloc->maxData)
189: return (void *)newPointer;
190: else
191: return NULL;
192: } else
193: return NULL;
194: }
195:
196: -(id)pointerForID: (const id)pointer
197: {
198: Class theClass;
199: struct _ObjectID {
200: @defs(Object)
201: } *newID;
202:
203: if (pointer
204: && (newID = [self pointerFor: pointer withSize: sizeof(id)])
205: && (theClass = [self pointerFor: newID->isa
206: withSize: sizeof(Class)])
207: && (newID
208: = [self pointerFor: pointer withSize: theClass->instance_size]))
209: return (id)newID;
210: else
211: return nil;
212: }
213:
214: -(int)getDataAt: (const void *)start for: (int)numBytes into: (void *)data
215: {
216: Reloc *reloc = [self relocFor: start];
217: int numBytesInReloc;
218:
219: if (reloc) {
220: numBytesInReloc = reloc->maxAddress - (int)start;
221: if (numBytes > numBytesInReloc)
222: numBytes = numBytesInReloc;
223: memcpy(data,
224: (void *)(reloc->data + ((pointer_t)start - reloc->address)),
225: numBytes);
226: return numBytes;
227: } else
228: return 0;
229: }
230:
231: -(struct mach_header *)getMachHeader
232: {
233: [self subclassResponsibility: _cmd];
234: return NULL;
235: }
236:
237: -(int)getNumMachHeaders
238: {
239: [self subclassResponsibility: _cmd];
240: return 0;
241: }
242:
243: -(struct mach_header **)getMachHeaders
244: {
245: [self subclassResponsibility: _cmd];
246: return NULL;
247: }
248:
249: -(struct mach_header **)getMachHeadersWithNames: (char ***)names
250: {
251: [self subclassResponsibility: _cmd];
252: return NULL;
253: }
254:
255: -(void *)getSectData: (STR)segName
256: section: (STR)sectName
257: size: (int *)pSize
258: forHeader: (struct mach_header *)header
259: {
260: void *data = getsectdatafromheader(header, segName, sectName, pSize);
261: return [self pointerFor: data withSize: *pSize];
262: }
263:
264: -(void *)getSectData: (STR)segName
265: section: (STR)sectName
266: size: (int *)pSize
267: {
268: return [self getSectData: segName
269: section: sectName
270: size: pSize
271: forHeader: [self getMachHeader]];
272: }
273:
274: -(const struct section *)getSeg: (STR)segName sect: (STR)sectName
275: {
276: return getsectbynamefromheader([self getMachHeader], segName, sectName);
277: }
278:
279: -(const struct section *)firstSection
280: {
281: struct mach_header *header = [self getMachHeader];
282: int i;
283: struct load_command *loadCmd;
284:
285: for (i = 0, loadCmd = (struct load_command *)(header + 1);
286: i < header->ncmds;
287: i++, ((void *)loadCmd) += loadCmd->cmdsize) {
288: if (loadCmd->cmd == LC_SEGMENT) {
289: struct segment_command *segCmd = (struct segment_command *)loadCmd;
290: if (segCmd->nsects)
291: return (struct section *)(segCmd + 1);
292: }
293: }
294: return NULL;
295: }
296:
297: -(unsigned)getMaximumAddressForHeader: (struct mach_header *)header
298: {
299: int i;
300: struct load_command *loadCmd;
301: unsigned maxAddr = 0;
302:
303: for (i = 0, loadCmd = (struct load_command *)(header + 1);
304: i < header->ncmds;
305: i++, ((void *)loadCmd) += loadCmd->cmdsize) {
306: if (loadCmd->cmd == LC_SEGMENT) {
307: struct segment_command *segCmd = (struct segment_command *)loadCmd;
308: if ((segCmd->vmaddr + segCmd->vmsize) > maxAddr)
309: maxAddr = segCmd->vmaddr + segCmd->vmsize;
310: }
311: }
312: return maxAddr;
313: }
314:
315: -(struct segment_command *)getSegment: (const char *)segName
316: {
317: int i;
318: struct load_command *loadCmd;
319: struct segment_command *foundSeg = NULL;
320: struct mach_header *header = [self getMachHeader];
321:
322: for (i = 0, loadCmd = (struct load_command *)(header + 1);
323: i < header->ncmds && !foundSeg;
324: i++, ((void *)loadCmd) += loadCmd->cmdsize) {
325: if (loadCmd->cmd == LC_SEGMENT) {
326: struct segment_command *segCmd = (struct segment_command *)loadCmd;
327: if (strcmp(segName, segCmd->segname) == 0)
328: foundSeg = segCmd;
329: }
330: }
331: return foundSeg;
332: }
333:
334: -(unsigned)getMaximumAddressForSegment: (const char *)segName
335: {
336: int i;
337: struct load_command *loadCmd;
338: unsigned maxAddr = 0;
339: struct mach_header *header = [self getMachHeader];
340:
341: for (i = 0, loadCmd = (struct load_command *)(header + 1);
342: i < header->ncmds;
343: i++, ((void *)loadCmd) += loadCmd->cmdsize) {
344: if (loadCmd->cmd == LC_SEGMENT) {
345: struct segment_command *segCmd = (struct segment_command *)loadCmd;
346: struct section *section;
347: int nSects;
348:
349: for (nSects = segCmd->nsects,
350: section = (struct section *)(segCmd + 1);
351: nSects;
352: nSects--, section++) {
353: if (strcmp(section->segname, segName) == 0) {
354: if ((section->addr + section->size) > maxAddr)
355: maxAddr = (section->addr + section->size);
356: }
357: }
358: }
359: }
360: return maxAddr;
361: }
362:
363: -(unsigned)getMaximumAddress
364: {
365: return [self getMaximumAddressForHeader: [self getMachHeader]];
366: }
367:
368: -(unsigned)getMaximumTextAddress
369: {
370: return [self getMaximumAddressForSegment: "__TEXT"];
371: }
372:
373: -(unsigned)getMaximumDataAddress
374: {
375: return [self getMaximumAddressForSegment: "__DATA"];
376: }
377:
378: @end
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.