ReactOS 0.4.15-dev-5669-g09dde2c
coff.c
Go to the documentation of this file.
1/*
2 * Read VC++ debug information from COFF and eventually
3 * from PDB files.
4 *
5 * Copyright (C) 1996, Eric Youngdale.
6 * Copyright (C) 1999-2000, Ulrich Weigand.
7 * Copyright (C) 2004, Eric Pouech.
8 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 */
23
24/*
25 * Note - this handles reading debug information for 32 bit applications
26 * that run under Windows-NT for example. I doubt that this would work well
27 * for 16 bit applications, but I don't think it really matters since the
28 * file format is different, and we should never get in here in such cases.
29 *
30 * TODO:
31 * Get 16 bit CV stuff working.
32 * Add symbol size to internal symbol table.
33 */
34
35#include <assert.h>
36#include <stdlib.h>
37#include <string.h>
38
39#include <stdarg.h>
40#include "windef.h"
41#include "winbase.h"
42#include "winternl.h"
43
44#include "wine/exception.h"
45#include "wine/debug.h"
46#include "dbghelp_private.h"
47#include "wine/mscvpdb.h"
48
50
51/*========================================================================
52 * Process COFF debug information.
53 */
54
56{
57 unsigned int startaddr;
58 unsigned int endaddr;
62 struct symt** entries;
63 int neps;
65};
66
68{
69 struct CoffFile* files;
70 int nfiles;
72};
73
74static const char* coff_get_name(const IMAGE_SYMBOL* coff_sym,
75 const char* coff_strtab)
76{
77 static char namebuff[9];
78 const char* nampnt;
79
80 if (coff_sym->N.Name.Short)
81 {
82 memcpy(namebuff, coff_sym->N.ShortName, 8);
83 namebuff[8] = '\0';
84 nampnt = &namebuff[0];
85 }
86 else
87 {
88 nampnt = coff_strtab + coff_sym->N.Name.Long;
89 }
90
91 if (nampnt[0] == '_') nampnt++;
92 return nampnt;
93}
94
95static int coff_add_file(struct CoffFileSet* coff_files, struct module* module,
96 const char* filename)
97{
98 struct CoffFile* file;
99
100 if (coff_files->nfiles + 1 >= coff_files->nfiles_alloc)
101 {
102 if (coff_files->files)
103 {
104 coff_files->nfiles_alloc *= 2;
105 coff_files->files = HeapReAlloc(GetProcessHeap(), 0, coff_files->files,
106 coff_files->nfiles_alloc * sizeof(struct CoffFile));
107 }
108 else
109 {
110 coff_files->nfiles_alloc = 16;
111 coff_files->files = HeapAlloc(GetProcessHeap(), 0,
112 coff_files->nfiles_alloc * sizeof(struct CoffFile));
113 }
114 }
115 file = coff_files->files + coff_files->nfiles;
116 file->startaddr = 0xffffffff;
117 file->endaddr = 0;
118 file->compiland = symt_new_compiland(module, 0,
120 file->linetab_offset = -1;
121 file->linecnt = 0;
122 file->entries = NULL;
123 file->neps = file->neps_alloc = 0;
124
125 return coff_files->nfiles++;
126}
127
128static void coff_add_symbol(struct CoffFile* coff_file, struct symt* sym)
129{
130 if (coff_file->neps + 1 >= coff_file->neps_alloc)
131 {
132 if (coff_file->entries)
133 {
134 coff_file->neps_alloc *= 2;
135 coff_file->entries = HeapReAlloc(GetProcessHeap(), 0, coff_file->entries,
136 coff_file->neps_alloc * sizeof(struct symt*));
137 }
138 else
139 {
140 coff_file->neps_alloc = 32;
141 coff_file->entries = HeapAlloc(GetProcessHeap(), 0,
142 coff_file->neps_alloc * sizeof(struct symt*));
143 }
144 }
145 coff_file->entries[coff_file->neps++] = sym;
146}
147
149{
150 const IMAGE_AUX_SYMBOL* aux;
151 const IMAGE_COFF_SYMBOLS_HEADER* coff;
152 const IMAGE_LINENUMBER* coff_linetab;
153 const IMAGE_LINENUMBER* linepnt;
154 const char* coff_strtab;
155 const IMAGE_SYMBOL* coff_sym;
156 const IMAGE_SYMBOL* coff_symbols;
157 struct CoffFileSet coff_files;
158 int curr_file_idx = -1;
159 unsigned int i;
160 int j;
161 int k;
162 int l;
163 int linetab_indx;
164 const char* nampnt;
165 int naux;
166 BOOL ret = FALSE;
168
169 TRACE("Processing COFF symbols...\n");
170
173
174 coff_files.files = NULL;
175 coff_files.nfiles = coff_files.nfiles_alloc = 0;
176
177 coff = (const IMAGE_COFF_SYMBOLS_HEADER*)msc_dbg->root;
178
179 coff_symbols = (const IMAGE_SYMBOL*)((const char *)coff + coff->LvaToFirstSymbol);
180 coff_linetab = (const IMAGE_LINENUMBER*)((const char *)coff + coff->LvaToFirstLinenumber);
181 coff_strtab = (const char*)(coff_symbols + coff->NumberOfSymbols);
182
183 linetab_indx = 0;
184
185 for (i = 0; i < coff->NumberOfSymbols; i++)
186 {
187 coff_sym = coff_symbols + i;
188 naux = coff_sym->NumberOfAuxSymbols;
189
190 if (coff_sym->StorageClass == IMAGE_SYM_CLASS_FILE)
191 {
192 curr_file_idx = coff_add_file(&coff_files, msc_dbg->module,
193 (const char*)(coff_sym + 1));
194 TRACE("New file %s\n", (const char*)(coff_sym + 1));
195 i += naux;
196 continue;
197 }
198
199 if (curr_file_idx < 0)
200 {
201 assert(coff_files.nfiles == 0 && coff_files.nfiles_alloc == 0);
202 curr_file_idx = coff_add_file(&coff_files, msc_dbg->module, "<none>");
203 TRACE("New file <none>\n");
204 }
205
206 /*
207 * This guy marks the size and location of the text section
208 * for the current file. We need to keep track of this so
209 * we can figure out what file the different global functions
210 * go with.
211 */
212 if (coff_sym->StorageClass == IMAGE_SYM_CLASS_STATIC &&
213 naux != 0 && coff_sym->Type == 0 && coff_sym->SectionNumber == 1)
214 {
215 aux = (const IMAGE_AUX_SYMBOL*) (coff_sym + 1);
216
217 if (coff_files.files[curr_file_idx].linetab_offset != -1)
218 {
219 /*
220 * Save this so we can still get the old name.
221 */
222 const char* fn;
223
224 fn = source_get(msc_dbg->module,
225 coff_files.files[curr_file_idx].compiland->source);
226
227 TRACE("Duplicating sect from %s: %x %x %x %d %d\n",
228 fn, aux->Section.Length,
229 aux->Section.NumberOfRelocations,
230 aux->Section.NumberOfLinenumbers,
231 aux->Section.Number, aux->Section.Selection);
232 TRACE("More sect %d %s %08x %d %d %d\n",
233 coff_sym->SectionNumber,
234 coff_get_name(coff_sym, coff_strtab),
235 coff_sym->Value, coff_sym->Type,
236 coff_sym->StorageClass, coff_sym->NumberOfAuxSymbols);
237
238 /*
239 * Duplicate the file entry. We have no way to describe
240 * multiple text sections in our current way of handling things.
241 */
242 coff_add_file(&coff_files, msc_dbg->module, fn);
243 }
244 else
245 {
246 TRACE("New text sect from %s: %x %x %x %d %d\n",
247 source_get(msc_dbg->module, coff_files.files[curr_file_idx].compiland->source),
248 aux->Section.Length,
249 aux->Section.NumberOfRelocations,
250 aux->Section.NumberOfLinenumbers,
251 aux->Section.Number, aux->Section.Selection);
252 }
253
254 if (coff_files.files[curr_file_idx].startaddr > coff_sym->Value)
255 {
256 coff_files.files[curr_file_idx].startaddr = coff_sym->Value;
257 }
258
259 if (coff_files.files[curr_file_idx].endaddr < coff_sym->Value + aux->Section.Length)
260 {
261 coff_files.files[curr_file_idx].endaddr = coff_sym->Value + aux->Section.Length;
262 }
263
264 coff_files.files[curr_file_idx].linetab_offset = linetab_indx;
265 coff_files.files[curr_file_idx].linecnt = aux->Section.NumberOfLinenumbers;
266 linetab_indx += aux->Section.NumberOfLinenumbers;
267 i += naux;
268 continue;
269 }
270
271 if (coff_sym->StorageClass == IMAGE_SYM_CLASS_STATIC && naux == 0 &&
272 coff_sym->SectionNumber == 1)
273 {
274 DWORD base = msc_dbg->sectp[coff_sym->SectionNumber - 1].VirtualAddress;
275 /*
276 * This is a normal static function when naux == 0.
277 * Just register it. The current file is the correct
278 * one in this instance.
279 */
280 nampnt = coff_get_name(coff_sym, coff_strtab);
281
282 TRACE("\tAdding static symbol %s\n", nampnt);
283
284 /* FIXME: was adding symbol to this_file ??? */
285 coff_add_symbol(&coff_files.files[curr_file_idx],
286 &symt_new_function(msc_dbg->module,
287 coff_files.files[curr_file_idx].compiland,
288 nampnt,
289 msc_dbg->module->module.BaseOfImage + base + coff_sym->Value,
290 0 /* FIXME */,
291 NULL /* FIXME */)->symt);
292 continue;
293 }
294
295 if (coff_sym->StorageClass == IMAGE_SYM_CLASS_EXTERNAL &&
296 ISFCN(coff_sym->Type) && coff_sym->SectionNumber > 0)
297 {
298 struct symt_compiland* compiland = NULL;
299 DWORD base = msc_dbg->sectp[coff_sym->SectionNumber - 1].VirtualAddress;
300 nampnt = coff_get_name(coff_sym, coff_strtab);
301
302 TRACE("%d: %s %s\n",
303 i, wine_dbgstr_longlong(msc_dbg->module->module.BaseOfImage + base + coff_sym->Value),
304 nampnt);
305 TRACE("\tAdding global symbol %s (sect=%s)\n",
306 nampnt, msc_dbg->sectp[coff_sym->SectionNumber - 1].Name);
307
308 /*
309 * Now we need to figure out which file this guy belongs to.
310 */
311 for (j = 0; j < coff_files.nfiles; j++)
312 {
313 if (coff_files.files[j].startaddr <= base + coff_sym->Value
314 && coff_files.files[j].endaddr > base + coff_sym->Value)
315 {
316 compiland = coff_files.files[j].compiland;
317 break;
318 }
319 }
320 if (j < coff_files.nfiles)
321 {
322 coff_add_symbol(&coff_files.files[j],
323 &symt_new_function(msc_dbg->module, compiland, nampnt,
324 msc_dbg->module->module.BaseOfImage + base + coff_sym->Value,
325 0 /* FIXME */, NULL /* FIXME */)->symt);
326 }
327 else
328 {
329 symt_new_function(msc_dbg->module, NULL, nampnt,
330 msc_dbg->module->module.BaseOfImage + base + coff_sym->Value,
331 0 /* FIXME */, NULL /* FIXME */);
332 }
333 i += naux;
334 continue;
335 }
336
337 if (coff_sym->StorageClass == IMAGE_SYM_CLASS_EXTERNAL &&
338 coff_sym->SectionNumber > 0)
339 {
340 DWORD base = msc_dbg->sectp[coff_sym->SectionNumber - 1].VirtualAddress;
341 struct location loc;
342
343 /*
344 * Similar to above, but for the case of data symbols.
345 * These aren't treated as entrypoints.
346 */
347 nampnt = coff_get_name(coff_sym, coff_strtab);
348
349 TRACE("%d: %s %s\n",
350 i, wine_dbgstr_longlong(msc_dbg->module->module.BaseOfImage + base + coff_sym->Value),
351 nampnt);
352 TRACE("\tAdding global data symbol %s\n", nampnt);
353
354 /*
355 * Now we need to figure out which file this guy belongs to.
356 */
357 loc.kind = loc_absolute;
358 loc.reg = 0;
359 loc.offset = msc_dbg->module->module.BaseOfImage + base + coff_sym->Value;
360 symt_new_global_variable(msc_dbg->module, NULL, nampnt, TRUE /* FIXME */,
361 loc, 0 /* FIXME */, NULL /* FIXME */);
362 i += naux;
363 continue;
364 }
365
366 if (coff_sym->StorageClass == IMAGE_SYM_CLASS_STATIC && naux == 0)
367 {
368 /*
369 * Ignore these. They don't have anything to do with
370 * reality.
371 */
372 continue;
373 }
374
375 TRACE("Skipping unknown entry '%s' %d %d %d\n",
376 coff_get_name(coff_sym, coff_strtab),
377 coff_sym->StorageClass, coff_sym->SectionNumber, naux);
378
379 /*
380 * For now, skip past the aux entries.
381 */
382 i += naux;
383 }
384
385 if (coff_files.files != NULL)
386 {
387 /*
388 * OK, we now should have a list of files, and we should have a list
389 * of entrypoints. We need to sort the entrypoints so that we are
390 * able to tie the line numbers with the given functions within the
391 * file.
392 */
393 for (j = 0; j < coff_files.nfiles; j++)
394 {
395 if (coff_files.files[j].entries != NULL)
396 {
397 qsort(coff_files.files[j].entries, coff_files.files[j].neps,
398 sizeof(struct symt*), symt_cmp_addr);
399 }
400 }
401
402 /*
403 * Now pick apart the line number tables, and attach the entries
404 * to the given functions.
405 */
406 for (j = 0; j < coff_files.nfiles; j++)
407 {
408 l = 0;
409 if (coff_files.files[j].neps != 0)
410 {
411 for (k = 0; k < coff_files.files[j].linecnt; k++)
412 {
413 linepnt = coff_linetab + coff_files.files[j].linetab_offset + k;
414 /*
415 * If we have spilled onto the next entrypoint, then
416 * bump the counter..
417 */
418 for (; l+1 < coff_files.files[j].neps; l++)
419 {
420 if (symt_get_address(coff_files.files[j].entries[l+1], &addr) &&
421 msc_dbg->module->module.BaseOfImage + linepnt->Type.VirtualAddress < addr)
422 {
423 if (coff_files.files[j].entries[l+1]->tag == SymTagFunction)
424 {
425 /*
426 * Add the line number. This is always relative to the
427 * start of the function, so we need to subtract that offset
428 * first.
429 */
430 symt_add_func_line(msc_dbg->module,
431 (struct symt_function*)coff_files.files[j].entries[l+1],
432 coff_files.files[j].compiland->source,
433 linepnt->Linenumber,
434 msc_dbg->module->module.BaseOfImage + linepnt->Type.VirtualAddress - addr);
435 }
436 break;
437 }
438 }
439 }
440 }
441 }
442
443 for (j = 0; j < coff_files.nfiles; j++)
444 {
445 HeapFree(GetProcessHeap(), 0, coff_files.files[j].entries);
446 }
447 HeapFree(GetProcessHeap(), 0, coff_files.files);
448 msc_dbg->module->module.SymType = SymCoff;
449 /* FIXME: we could have a finer grain here */
450 msc_dbg->module->module.LineNumbers = TRUE;
451 msc_dbg->module->module.GlobalSymbols = TRUE;
452 msc_dbg->module->module.TypeInfo = FALSE;
453 msc_dbg->module->module.SourceIndexed = TRUE;
454 msc_dbg->module->module.Publics = TRUE;
455 ret = TRUE;
456 }
457
458 return ret;
459}
#define WINE_DEFAULT_DEBUG_CHANNEL(t)
Definition: precomp.h:23
r l[0]
Definition: byte_order.h:167
static int coff_add_file(struct CoffFileSet *coff_files, struct module *module, const char *filename)
Definition: coff.c:95
static void coff_add_symbol(struct CoffFile *coff_file, struct symt *sym)
Definition: coff.c:128
DECLSPEC_HIDDEN BOOL coff_process_info(const struct msc_debug_info *msc_dbg)
Definition: coff.c:148
static const char * coff_get_name(const IMAGE_SYMBOL *coff_sym, const char *coff_strtab)
Definition: coff.c:74
struct symt_function * symt_new_function(struct module *module, struct symt_compiland *parent, const char *name, ULONG_PTR addr, ULONG_PTR size, struct symt *type) DECLSPEC_HIDDEN
Definition: symbol.c:293
int __cdecl symt_cmp_addr(const void *p1, const void *p2) DECLSPEC_HIDDEN
Definition: symbol.c:57
unsigned source_new(struct module *module, const char *basedir, const char *source) DECLSPEC_HIDDEN
Definition: source.c:66
struct symt_data * symt_new_global_variable(struct module *module, struct symt_compiland *parent, const char *name, unsigned is_static, struct location loc, ULONG_PTR size, struct symt *type) DECLSPEC_HIDDEN
Definition: symbol.c:256
BOOL symt_get_address(const struct symt *type, ULONG64 *addr) DECLSPEC_HIDDEN
Definition: type.c:119
struct symt_compiland * symt_new_compiland(struct module *module, ULONG_PTR address, unsigned src_idx) DECLSPEC_HIDDEN
Definition: symbol.c:207
const char * source_get(const struct module *module, unsigned idx) DECLSPEC_HIDDEN
Definition: source.c:130
@ loc_absolute
void symt_add_func_line(struct module *module, struct symt_function *func, unsigned source_idx, int line_num, ULONG_PTR offset) DECLSPEC_HIDDEN
Definition: symbol.c:326
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
#define DECLSPEC_HIDDEN
Definition: precomp.h:8
#define GetProcessHeap()
Definition: compat.h:736
@ SymCoff
Definition: compat.h:1057
#define IMAGE_SYM_CLASS_EXTERNAL
Definition: compat.h:149
#define HeapAlloc
Definition: compat.h:733
#define HeapReAlloc
Definition: compat.h:734
static __inline const char * wine_dbgstr_longlong(ULONGLONG ll)
Definition: compat.h:49
@ SymTagFunction
Definition: compat.h:1586
#define HeapFree(x, y, z)
Definition: compat.h:735
#define IMAGE_SYM_CLASS_FILE
Definition: compat.h:150
#define assert(x)
Definition: debug.h:53
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
GLenum const GLvoid * addr
Definition: glext.h:9621
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
const char * filename
Definition: ioapi.h:137
static const WCHAR aux[]
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
unsigned __int64 ULONG64
Definition: imports.h:198
int k
Definition: mpi.c:3369
void __cdecl qsort(_Inout_updates_bytes_(_NumOfElements *_SizeOfElements) void *_Base, _In_ size_t _NumOfElements, _In_ size_t _SizeOfElements, _In_ int(__cdecl *_PtFuncCompare)(const void *, const void *))
#define TRACE(s)
Definition: solgame.cpp:4
struct CoffFile * files
Definition: coff.c:69
int nfiles
Definition: coff.c:70
int nfiles_alloc
Definition: coff.c:71
Definition: coff.c:56
struct symt_compiland * compiland
Definition: coff.c:59
unsigned int startaddr
Definition: coff.c:57
int linecnt
Definition: coff.c:61
struct symt ** entries
Definition: coff.c:62
int neps_alloc
Definition: coff.c:64
int neps
Definition: coff.c:63
int linetab_offset
Definition: coff.c:60
unsigned int endaddr
Definition: coff.c:58
union _IMAGE_LINENUMBER::@3981 Type
BYTE Name[IMAGE_SIZEOF_SHORT_NAME]
Definition: pedump.c:281
WORD Type
Definition: pecoff.h:254
BYTE NumberOfAuxSymbols
Definition: pecoff.h:256
DWORD Value
Definition: pecoff.h:252
BYTE StorageClass
Definition: pecoff.h:255
BYTE ShortName[8]
Definition: pecoff.h:245
union _IMAGE_SYMBOL::@2264 N
struct _IMAGE_SYMBOL::@2264::@2265 Name
SHORT SectionNumber
Definition: pecoff.h:253
Definition: fci.c:127
ULONG_PTR offset
unsigned reg
unsigned kind
const BYTE * root
Definition: mscvpdb.h:2139
const IMAGE_SECTION_HEADER * sectp
Definition: mscvpdb.h:2136
struct module * module
Definition: mscvpdb.h:2134
int ret
static GLenum _GLUfuncptr fn
Definition: wgl_font.c:159
#define IMAGE_SIZEOF_SYMBOL
Definition: winnt_old.h:678
#define ISFCN(x)
Definition: winnt_old.h:1098
#define IMAGE_SIZEOF_LINENUMBER
Definition: winnt_old.h:682
#define IMAGE_SYM_CLASS_STATIC
Definition: winnt_old.h:784