![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cv.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 / symedit|
Return to cv.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / sdktools / image / symedit |
1.1 root 1: /*++
2:
3:
4: Copyright (c) 1992 Microsoft Corporation
5:
6: Module Name:
7:
8: cv.c
9:
10: Abstract:
11:
12: This module handles the conversion activities requires for converting
13: COFF debug data to CODEVIEW debug data.
14:
15: Author:
16:
17: Wesley A. Witt (wesw) 19-April-1993
18:
19: Environment:
20:
21: Win32, User Mode
22:
23: --*/
24:
25: #include <windows.h>
26: #include <stdlib.h>
27: #include <stdio.h>
28: #include <string.h>
29:
30: #include "cv.h"
31: #include "symcvt.h"
32: #include "cvcommon.h"
33:
34: typedef struct tagOFFSETSORT {
35: DWORD dwOffset; // offset for the symbol
36: DWORD dwSection; // section number of the symbol
37: DATASYM32 *dataSym; // pointer to the symbol info
38: } OFFSETSORT;
39:
40:
41: #define n_name N.ShortName
42: #define n_zeroes N.Name.Short
43: #define n_nptr N.LongName[1]
44: #define n_offset N.Name.Long
45:
46: static VOID GetSymName( PIMAGE_SYMBOL Symbol, PUCHAR StringTable, char *s );
47: DWORD CreateModulesFromCoff( PPOINTERS p );
48: DWORD CreatePublicsFromCoff( PPOINTERS p );
49: DWORD CreateSegMapFromCoff( PPOINTERS p );
50:
51: BOOL
52: ConvertCoffToCv( PPOINTERS p )
53:
54: /*++
55:
56: Routine Description:
57:
58: This is the control function for the conversion of COFF to CODEVIEW
59: debug data. It calls individual functions for the conversion of
60: specific types of debug data.
61:
62:
63: Arguments:
64:
65: p - pointer to a POINTERS structure (see cofftocv.h)
66:
67:
68: Return Value:
69:
70: TRUE - conversion succeded
71: FALSE - conversion failed
72:
73: --*/
74:
75: {
76: p->pCvCurr = p->pCvStart.ptr = malloc( p->iptrs.fsize );
77: if (p->pCvStart.ptr == NULL) {
78: return FALSE;
79: }
80: memset( p->pCvStart.ptr, 0, p->iptrs.fsize );
81:
82: try {
83: CreateSignature( p );
84: CreateModulesFromCoff( p );
85: CreatePublicsFromCoff( p );
86: CreateSymbolHashTable( p );
87: CreateAddressSortTable( p );
88: CreateSegMapFromCoff( p );
89: CreateDirectories( p );
90: } except (EXCEPTION_EXECUTE_HANDLER) {
91: free( p->pCvStart.ptr );
92: p->pCvStart.ptr = NULL;
93: return FALSE;
94: }
95:
96: p->pCvStart.ptr = realloc( p->pCvStart.ptr, p->pCvStart.size );
97:
98: return TRUE;
99: }
100:
101:
102: DWORD
103: CreateModulesFromCoff( PPOINTERS p )
104:
105: /*++
106:
107: Routine Description:
108:
109: Creates the individual CV module records. There is one CV module
110: record for each .FILE record in the COFF debug data. This is true
111: even if the COFF size is zero.
112:
113:
114: Arguments:
115:
116: p - pointer to a POINTERS structure (see cofftocv.h)
117:
118:
119: Return Value:
120:
121: The number of modules that were created.
122:
123: --*/
124:
125: {
126: int i;
127: DWORD numaux;
128: DWORD nummods = 0;
129: char szSymName[256];
130: PIMAGE_SYMBOL Symbol;
131: PIMAGE_AUX_SYMBOL AuxSymbol;
132: OMFModule *m;
133: int cSeg;
134: char * pb;
135: BOOLEAN rgfCode[100];
136:
137: memset(rgfCode, 2, sizeof(rgfCode));
138:
139: m = NULL;
140:
141: for (i= 0, Symbol = p->iptrs.AllSymbols;
142: i < (int) p->iptrs.numberOfSymbols;
143: i += numaux + 1, Symbol += numaux + 1) {
144:
145: /*
146: * Get the number of aux symbol records for this symbol
147: */
148:
149: numaux = Symbol->NumberOfAuxSymbols;
150: AuxSymbol = (PIMAGE_AUX_SYMBOL) (Symbol+1);
151:
152: /*
153: * If this is a FILE record -- then we need to create a
154: * module item to correspond to this file record.
155: */
156:
157: if (Symbol->StorageClass == IMAGE_SYM_CLASS_FILE) {
158: if (m == NULL) {
159: m = (OMFModule *) p->pCvCurr;
160: } else {
161: /*
162: * Clean up the last item, if we saw any
163: * section records then drop them in here
164: */
165:
166: if (cSeg > 0) {
167: m->cSeg = cSeg;
168: pb = (char *) &m->SegInfo[cSeg];
169: *pb = strlen(szSymName);
170: memcpy(pb+1, szSymName, *pb);
171:
172: m = NextMod(m);
173: nummods++;
174: }
175: }
176:
177: cSeg = 0;
178: m->ovlNumber = 0;
179: m->iLib = 0;
180: m->Style[0] = 'C';
181: m->Style[1] = 'V';
182:
183: /*
184: * Save off the file name to use when we have finished
185: * processing this module
186: */
187:
188: memcpy(szSymName, (char *)AuxSymbol, numaux*sizeof(IMAGE_AUX_SYMBOL));
189: szSymName[numaux*sizeof(IMAGE_AUX_SYMBOL)] = 0;
190:
191: }
192: /*
193: * We have found a "SECTION" record. Add the info to the
194: * module record
195: */
196: else if ((Symbol->SectionNumber & 0xffff) > 0xfff0) {
197: continue;
198: } else if (Symbol->SectionNumber > sizeof(rgfCode)/sizeof(rgfCode[0])) {
199: return 0;
200: } else if ((m != NULL) &&
201: (rgfCode[Symbol->SectionNumber] != 0) &&
202: (Symbol->StorageClass == IMAGE_SYM_CLASS_STATIC) &&
203: ((*Symbol->n_name == '.') ||
204: (Symbol->Type == IMAGE_SYM_TYPE_NULL)) &&
205: (Symbol->NumberOfAuxSymbols == 1) &&
206: (AuxSymbol->Section.Length != 0)) {
207:
208: if (rgfCode[Symbol->SectionNumber] == 2) {
209: if ((p->iptrs.sectionHdrs[Symbol->SectionNumber - 1].
210: Characteristics & IMAGE_SCN_CNT_CODE) == 0) {
211: rgfCode[Symbol->SectionNumber] = 0;
212: continue;
213: }
214: rgfCode[Symbol->SectionNumber] = 1;
215: }
216:
217: m->SegInfo[cSeg].Seg = Symbol->SectionNumber;
218: m->SegInfo[cSeg].cbSeg = AuxSymbol->Section.Length;
219: m->SegInfo[cSeg].Off = Symbol->Value -
220: p->iptrs.sectionHdrs[Symbol->SectionNumber-1].
221: VirtualAddress;
222: cSeg += 1;
223: }
224: }
225:
226: /*
227: * Wrap up the last possible open module record
228: */
229:
230: if (m != NULL) {
231: if (cSeg > 0) {
232: m->cSeg = cSeg;
233: pb = (char *) &m->SegInfo[cSeg];
234: *pb = strlen(szSymName);
235: memcpy(pb+1, szSymName, *pb);
236:
237: m = NextMod(m);
238: nummods++;
239: }
240: }
241:
242: UpdatePtrs( p, &p->pCvModules, (LPVOID)m, nummods );
243:
244: return nummods;
245: }
246:
247:
248: DWORD
249: CreatePublicsFromCoff( PPOINTERS p )
250:
251: /*++
252:
253: Routine Description:
254:
255: Creates the individual CV public symbol records. There is one CV
256: public record created for each COFF symbol that is marked as EXTERNAL
257: and has a section number greater than zero. The resulting CV publics
258: are sorted by section and offset.
259:
260:
261: Arguments:
262:
263: p - pointer to a POINTERS structure (see cofftocv.h)
264:
265:
266: Return Value:
267:
268: The number of publics created.
269:
270: --*/
271:
272: {
273: int i;
274: DWORD numaux;
275: DWORD numsyms = 0;
276: char szSymName[256];
277: PIMAGE_SYMBOL Symbol;
278: OMFSymHash *omfSymHash;
279: DATASYM32 *dataSym;
280: DATASYM32 *dataSym2;
281:
282: omfSymHash = (OMFSymHash *) p->pCvCurr;
283: dataSym = (DATASYM32 *) (PUCHAR)((DWORD)omfSymHash + sizeof(OMFSymHash));
284:
285: for (i= 0, Symbol = p->iptrs.AllSymbols;
286: i < p->iptrs.numberOfSymbols;
287: i += numaux + 1, Symbol += numaux + 1) {
288:
289: if ((Symbol->StorageClass == IMAGE_SYM_CLASS_EXTERNAL) &&
290: (Symbol->SectionNumber > 0)) {
291:
292: GetSymName( Symbol, p->iptrs.stringTable, szSymName );
293: dataSym->rectyp = S_PUB32;
294: dataSym->seg = Symbol->SectionNumber;
295: dataSym->off = Symbol->Value -
296: p->iptrs.sectionHdrs[Symbol->SectionNumber-1].VirtualAddress;
297: dataSym->typind = 0;
298: dataSym->name[0] = strlen( szSymName );
299: strcpy( &dataSym->name[1], szSymName );
300: dataSym2 = NextSym32( dataSym );
301: dataSym->reclen = (USHORT) ((DWORD)dataSym2 - (DWORD)dataSym) - 2;
302: dataSym = dataSym2;
303: numsyms += 1;
304: }
305: numaux = Symbol->NumberOfAuxSymbols;
306: }
307:
308: UpdatePtrs( p, &p->pCvPublics, (LPVOID)dataSym, numsyms );
309:
310: omfSymHash->cbSymbol = p->pCvPublics.size - sizeof(OMFSymHash);
311: omfSymHash->symhash = 0;
312: omfSymHash->addrhash = 0;
313: omfSymHash->cbHSym = 0;
314: omfSymHash->cbHAddr = 0;
315:
316: return numsyms;
317: } /* CreatePublisFromCoff() */
318:
319:
320: DWORD
321: CreateSegMapFromCoff( PPOINTERS p )
322:
323: /*++
324:
325: Routine Description:
326:
327: Creates the CV segment map. The segment map is used by debuggers
328: to aid in address lookups. One segment is created for each COFF
329: section in the image.
330:
331: Arguments:
332:
333: p - pointer to a POINTERS structure (see cofftocv.h)
334:
335:
336: Return Value:
337:
338: The number of segments in the map.
339:
340: --*/
341:
342: {
343: int i;
344: SGM *sgm;
345: SGI *sgi;
346: PIMAGE_SECTION_HEADER sh;
347:
348:
349: sgm = (SGM *) p->pCvCurr;
350: sgi = (SGI *) ((DWORD)p->pCvCurr + sizeof(SGM));
351:
352: sgm->cSeg = p->iptrs.numberOfSections;
353: sgm->cSegLog = p->iptrs.numberOfSections;
354:
355: sh = p->iptrs.sectionHdrs;
356:
357: for (i=0; i<p->iptrs.numberOfSections; i++, sh++) {
358: sgi->sgf.fRead = (USHORT) (sh->Characteristics & IMAGE_SCN_MEM_READ) == IMAGE_SCN_MEM_READ;
359: sgi->sgf.fWrite = (USHORT) (sh->Characteristics & IMAGE_SCN_MEM_WRITE) == IMAGE_SCN_MEM_WRITE;
360: sgi->sgf.fExecute = (USHORT) (sh->Characteristics & IMAGE_SCN_MEM_EXECUTE) == IMAGE_SCN_MEM_EXECUTE;
361: sgi->sgf.f32Bit = 1;
362: sgi->sgf.fSel = 0;
363: sgi->sgf.fAbs = 0;
364: sgi->sgf.fGroup = 1;
365: sgi->iovl = 0;
366: sgi->igr = 0;
367: sgi->isgPhy = (USHORT) i + 1;
368: sgi->isegName = 0;
369: sgi->iclassName = 0;
370: sgi->doffseg = 0;
371: sgi->cbSeg = sh->SizeOfRawData;
372: sgi++;
373: }
374:
375: UpdatePtrs( p, &p->pCvSegMap, (LPVOID)sgi, i );
376:
377: return i;
378: }
379:
380:
381: void
382: GetSymName( PIMAGE_SYMBOL Symbol, PUCHAR StringTable, char *s )
383:
384: /*++
385:
386: Routine Description:
387:
388: Extracts the COFF symbol from the image symbol pointer and puts
389: the ascii text in the character pointer passed in.
390:
391:
392: Arguments:
393:
394: Symbol - COFF Symbol Record
395: StringTable - COFF string table
396: s - buffer for the symbol string
397:
398:
399: Return Value:
400:
401: void
402:
403: --*/
404:
405: {
406: DWORD i;
407:
408: if (Symbol->n_zeroes) {
409: for (i=0; i<8; i++) {
410: if ((Symbol->n_name[i]>0x1f) && (Symbol->n_name[i]<0x7f)) {
411: *s++ = Symbol->n_name[i];
412: }
413: }
414: *s = 0;
415: }
416: else {
417: strcpy( s, &StringTable[Symbol->n_offset] );
418: }
419: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.