![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to symbols.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / sdktools / image / drwatson|
Return to symbols.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / sdktools / image / drwatson |
1.1 root 1: /*++
2:
3: Copyright (c) 1993 Microsoft Corporation
4:
5: Module Name:
6:
7: symbols.c
8:
9: Abstract:
10:
11: This file contains all support for the symbol table.
12:
13: Author:
14:
15: Wesley Witt (wesw) 1-May-1993
16:
17: Environment:
18:
19: User Mode
20:
21: --*/
22:
23: #include <windows.h>
24: #include <stdlib.h>
25: #include <stdio.h>
26: #include <string.h>
27: #include <imagehlp.h>
28:
29: #include "drwatson.h"
30: #include "proto.h"
31: #include "cv.h"
32: #include "messages.h"
33:
34:
35: #define n_name N.ShortName
36: #define n_zeroes N.Name.Short
37: #define n_nptr N.LongName[1]
38: #define n_offset N.Name.Long
39:
40: void GetSymName( PIMAGE_SYMBOL Symbol, PUCHAR StringTable, char *s );
41: PSYMBOL AllocSym( DWORD symSize, PSYMBOL *symHead, PSYMBOL *symTail );
42: int _CRTAPI1 SymbolCompare( const void *arg1, const void *arg2 );
43:
44:
45: PSYMBOL
46: SymbolSearch( DWORD key, PSYMBOL *base, DWORD num )
47: {
48: PSYMBOL *lo = base;
49: PSYMBOL *hi = base + (num - 1);
50: PSYMBOL *mid = NULL;
51: DWORD half = 0;
52:
53: while (lo <= hi) {
54: if (half = num / 2) {
55: mid = lo + (num & 1 ? half : (half - 1));
56: if ((key >= (*mid)->addr) &&
57: (key < ((*mid)->addr + (*mid)->size))) {
58: return *mid;
59: }
60: if (key < (*mid)->addr) {
61: hi = mid - 1;
62: num = num & 1 ? half : half-1;
63: }
64: else {
65: lo = mid + 1;
66: num = half;
67: }
68: }
69: else
70: if (num) {
71: if ((key >= (*lo)->addr) &&
72: (key < ((*lo)->addr + (*lo)->size))) {
73: return *lo;
74: }
75: else {
76: break;
77: }
78: }
79: else {
80: break;
81: }
82: }
83: return NULL;
84: }
85:
86: PSYMBOL
87: GetSymFromAddr( DWORD dwAddr, PDWORD pdwDisplacement, PMODULEINFO mi )
88: {
89: PSYMBOL sym = NULL;
90:
91: if (mi == NULL) {
92: return sym;
93: }
94:
95: sym = SymbolSearch( dwAddr, mi->symbolTable, mi->numsyms );
96: if (sym !=NULL) {
97: *pdwDisplacement = dwAddr - sym->addr;
98: }
99:
100: return sym;
101: }
102:
103: PMODULEINFO
104: GetModuleForPC( PDEBUGPACKET dp, DWORD dwPcAddr )
105: {
106: PMODULEINFO mi = dp->miHead;
107:
108: Assert( mi != NULL );
109: while (mi) {
110: if ((dwPcAddr >= mi->dwLoadAddress) &&
111: (dwPcAddr <= mi->dwLoadAddress + mi->dwImageSize)) {
112: return mi;
113: }
114: mi = mi->next;
115: }
116:
117: return NULL;
118: }
119:
120: PSYMBOL
121: GetSymFromAddrAllContexts( DWORD dwAddr, PDWORD pdwDisplacement, PDEBUGPACKET dp )
122: {
123: PMODULEINFO mi = GetModuleForPC( dp, dwAddr );
124: if (mi == NULL) {
125: return NULL;
126: }
127: return GetSymFromAddr( dwAddr, pdwDisplacement, mi );
128: }
129:
130: void
131: DumpSymbols( PDEBUGPACKET dp )
132: {
133: DWORD i;
134: PSYMBOL *sym;
135: char *szSymName;
136: PMODULEINFO mi;
137:
138:
139: lprintf( MSG_SYMBOL_TABLE );
140:
141: mi = dp->miHead;
142: while (mi) {
143: lprintfs( "%s\r\n", mi->szName );
144: for (i=0,sym=mi->symbolTable; i<mi->numsyms; i++,sym++) {
145: szSymName = UnDName( &(*sym)->szName[1] );
146: lprintfs( "%08x %s\r\n", (*sym)->addr, szSymName );
147: }
148: lprintfs( "\r\n" );
149: mi = mi->next;
150: }
151:
152: return;
153: }
154:
155: PSYMBOL
156: AllocSym( DWORD symSize, PSYMBOL *symHead, PSYMBOL *symTail )
157: {
158: PSYMBOL sym;
159:
160: sym = (PSYMBOL) malloc( sizeof(SYMBOL)+symSize );
161: if (sym == NULL) {
162: return NULL;
163: }
164: memset( sym, 0, sizeof(SYMBOL)+symSize );
165:
166: if (*symHead == NULL) {
167: *symTail = *symHead = sym;
168: return sym;
169: }
170: else {
171: (*symTail)->next = sym;
172: *symTail = sym;
173: return sym;
174: }
175: return NULL;
176: }
177:
178: BOOL
179: LoadFpoData( PMODULEINFO mi, PFPO_DATA start, DWORD size )
180: {
181: mi->pFpoData = (PFPO_DATA) malloc( size );
182:
183: if (mi->pFpoData == NULL) {
184: return FALSE;
185: }
186:
187: memcpy( mi->pFpoData, start, size );
188:
189: mi->dwEntries = size / sizeof(FPO_DATA);
190:
191: return TRUE;
192: }
193:
194: BOOL
195: LoadExceptionData( PMODULEINFO mi, PRUNTIME_FUNCTION start, DWORD size )
196: {
197: DWORD cFunc;
198: DWORD index;
199: PRUNTIME_FUNCTION rf;
200: PRUNTIME_FUNCTION tf;
201:
202:
203: if (size == 0) {
204: return FALSE;
205: }
206:
207: cFunc = size / sizeof(RUNTIME_FUNCTION);
208:
209: //
210: // Find the start of the padded page (end of the real data)
211: //
212: rf = tf = start;
213: for(index=0; index<cFunc && tf->BeginAddress; tf++,index++) {
214: ;
215: }
216:
217: if (index<cFunc) {
218: cFunc = index;
219: size = index * sizeof(RUNTIME_FUNCTION);
220: }
221:
222: mi->pExceptionData = (PRUNTIME_FUNCTION) malloc( size );
223: if (mi->pExceptionData == NULL) {
224: return FALSE;
225: }
226:
227: memcpy( mi->pExceptionData, rf, size );
228:
229: //
230: // if the image has been relocated then the addresses must be fixed up
231: //
232: if (mi->dwLoadAddress != mi->dwBaseOfImage) {
233: long diff = (LONG)mi->dwLoadAddress - mi->dwBaseOfImage;
234:
235: for (index=0; index<cFunc; index++) {
236: mi->pExceptionData[index].BeginAddress += diff;
237: mi->pExceptionData[index].EndAddress += diff;
238: mi->pExceptionData[index].PrologEndAddress += diff;
239: }
240: }
241:
242: mi->dwEntries = cFunc;
243:
244: return TRUE;
245: }
246:
247: BOOL
248: LoadCoffSymbols( PMODULEINFO mi,
249: PUCHAR stringTable,
250: PIMAGE_SYMBOL allSymbols,
251: DWORD numberOfSymbols
252: )
253: {
254: PIMAGE_SYMBOL NextSymbol;
255: PIMAGE_SYMBOL Symbol;
256: PIMAGE_AUX_SYMBOL AuxSymbol;
257: SYMBOL *sym;
258: char szSymName[256];
259: DWORD len;
260: DWORD numaux;
261: DWORD i;
262: DWORD j;
263: DWORD addr;
264: PSYMBOL *symbolTable;
265: PSYMBOL *symbolTable2;
266: PSYMBOL symHead = NULL;
267: PSYMBOL symTail = NULL;
268:
269: Assert( mi != NULL );
270: NextSymbol = allSymbols;
271: for (i= 0; i < numberOfSymbols; i++) {
272: Symbol = NextSymbol++;
273: if (Symbol->StorageClass == IMAGE_SYM_CLASS_EXTERNAL && Symbol->SectionNumber > 0) {
274: GetSymName( Symbol, stringTable, szSymName );
275: addr = Symbol->Value + mi->dwLoadAddress;
276: len = strlen( szSymName );
277: sym = AllocSym ( len+1, &symHead, &symTail );
278: sym->szName[0] = (UCHAR) len;
279: strcpy( &sym->szName[1], szSymName );
280: sym->addr = addr;
281: mi->numsyms++;
282: }
283: if (numaux = Symbol->NumberOfAuxSymbols) {
284: for (j=numaux; j; --j) {
285: AuxSymbol = (PIMAGE_AUX_SYMBOL) NextSymbol;
286: NextSymbol++;
287: ++i;
288: }
289: }
290: }
291:
292: mi->symbolTable = (PSYMBOL*) malloc( mi->numsyms * sizeof(PSYMBOL) );
293: Assert( mi->symbolTable != NULL );
294:
295: sym = symHead;
296: symbolTable = mi->symbolTable;
297: while (sym) {
298: *symbolTable = sym;
299: symbolTable++;
300: sym = sym->next;
301: }
302:
303: qsort( (void*)mi->symbolTable, mi->numsyms, sizeof(PSYMBOL), SymbolCompare );
304:
305: for (i=0,symbolTable=mi->symbolTable; i<mi->numsyms; i++,symbolTable++) {
306: if (i+1 < mi->numsyms) {
307: symbolTable2 = symbolTable+1;
308: (*symbolTable)->size = (*symbolTable2)->addr - (*symbolTable)->addr;
309: }
310: }
311:
312: return TRUE;
313: }
314:
315: BOOL
316: LoadCodeViewSymbols( PMODULEINFO mi,
317: PUCHAR pCvData,
318: PIMAGE_SECTION_HEADER sectionHdrs,
319: DWORD numSections
320: )
321: {
322: OMFSignature *omfSig;
323: OMFDirHeader *omfDirHdr;
324: OMFDirEntry *omfDirEntry;
325: DATASYM32 *dataSym;
326: OMFSymHash *omfSymHash;
327: SYMBOL *sym;
328: DWORD i;
329: DWORD j;
330: DWORD k;
331: DWORD addr;
332: PSYMBOL *symbolTable;
333: PSYMBOL *symbolTable2;
334: PIMAGE_SECTION_HEADER sh;
335: PSYMBOL symHead = NULL;
336: PSYMBOL symTail = NULL;
337:
338:
339: Assert( mi != NULL );
340: omfSig = (OMFSignature*) pCvData;
341: if ((strncmp( omfSig->Signature, "NB08", 4 ) != 0) &&
342: (strncmp( omfSig->Signature, "NB09", 4 ) != 0)) {
343: return FALSE;
344: }
345:
346: omfDirHdr = (OMFDirHeader*) ((DWORD)omfSig + (DWORD)omfSig->filepos);
347: omfDirEntry = (OMFDirEntry*) ((DWORD)omfDirHdr + sizeof(OMFDirHeader));
348:
349: for (i=0; i<omfDirHdr->cDir; i++,omfDirEntry++) {
350: if (omfDirEntry->SubSection == sstGlobalPub) {
351: omfSymHash = (OMFSymHash*) ((DWORD)omfSig + omfDirEntry->lfo);
352: dataSym = (DATASYM32*) ((DWORD)omfSig + omfDirEntry->lfo + sizeof(OMFSymHash));
353: for (j=sizeof(OMFSymHash); j<=omfSymHash->cbSymbol; ) {
354: sym = AllocSym ( dataSym->name[0]+1, &symHead, &symTail );
355: if (sym != NULL) {
356: for (k=0,addr=0,sh=sectionHdrs; k<numSections; k++, sh++) {
357: if (k+1 == dataSym->seg) {
358: addr = sh->VirtualAddress;
359: }
360: }
361: addr += (dataSym->off + mi->dwLoadAddress);
362: memcpy( sym->szName, dataSym->name, dataSym->name[0]+1 );
363: sym->addr = addr;
364: j += dataSym->reclen + 2;
365: dataSym = (DATASYM32*) ((DWORD)dataSym + dataSym->reclen + 2);
366: mi->numsyms++;
367: }
368: }
369: break;
370: }
371: }
372:
373:
374: mi->symbolTable = (PSYMBOL*) malloc( mi->numsyms * sizeof(PSYMBOL) );
375: if (mi->symbolTable == NULL) {
376: return FALSE;
377: }
378:
379: sym = symHead;
380: symbolTable = mi->symbolTable;
381: i = 0;
382: while (sym) {
383: i++;
384: *symbolTable = sym;
385: symbolTable++;
386: sym = sym->next;
387: }
388:
389: qsort( (void*)mi->symbolTable, mi->numsyms, sizeof(PSYMBOL), SymbolCompare );
390:
391: for (i=0,symbolTable=mi->symbolTable; i<mi->numsyms; i++,symbolTable++) {
392: if (i+1 < mi->numsyms) {
393: symbolTable2 = symbolTable+1;
394: (*symbolTable)->size = (*symbolTable2)->addr - (*symbolTable)->addr;
395: }
396: }
397:
398: return TRUE;
399: }
400:
401: void
402: GetSymName( PIMAGE_SYMBOL Symbol, PUCHAR StringTable, char *s )
403: {
404: DWORD i;
405:
406: if (Symbol->n_zeroes) {
407: for (i=0; i<8; i++) {
408: if ((Symbol->n_name[i]>0x1f) && (Symbol->n_name[i]<0x7f)) {
409: *s++ = Symbol->n_name[i];
410: }
411: }
412: *s = 0;
413: }
414: else {
415: strcpy( s, &StringTable[Symbol->n_offset] );
416: }
417: }
418:
419: int
420: _CRTAPI1
421: SymbolCompare( const void *arg1, const void *arg2 )
422: {
423: if ((*(PSYMBOL*)arg1)->addr < (*(PSYMBOL*)arg2)->addr) {
424: return -1;
425: }
426: if ((*(PSYMBOL*)arg1)->addr > (*(PSYMBOL*)arg2)->addr) {
427: return 1;
428: }
429: return 0;
430: }
431:
432: char *
433: UnDName (char * dName)
434: {
435: static char outBuf[512];
436: char *p;
437:
438: if (*dName == '_') {
439: ++dName;
440: strcpy(outBuf, dName);
441: p = strchr(outBuf, '@');
442: if (p) {
443: *p = '\0';
444: }
445: }
446: else
447: if(UnDecorateSymbolName( dName,
448: outBuf,
449: sizeof(outBuf),
450: UNDNAME_COMPLETE ) == 0 ) {
451: return NULL;
452: }
453:
454: return outBuf;
455: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.