ReactOS 0.4.15-dev-7788-g1ad9096
coff.c File Reference
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "winternl.h"
#include "wine/exception.h"
#include "wine/debug.h"
#include "dbghelp_private.h"
#include "wine/mscvpdb.h"
Include dependency graph for coff.c:

Go to the source code of this file.

Classes

struct  CoffFile
 
struct  CoffFileSet
 

Functions

 WINE_DEFAULT_DEBUG_CHANNEL (dbghelp_coff)
 
static const charcoff_get_name (const IMAGE_SYMBOL *coff_sym, const char *coff_strtab)
 
static int coff_add_file (struct CoffFileSet *coff_files, struct module *module, const char *filename)
 
static void coff_add_symbol (struct CoffFile *coff_file, struct symt *sym)
 
DECLSPEC_HIDDEN BOOL coff_process_info (const struct msc_debug_info *msc_dbg)
 

Function Documentation

◆ coff_add_file()

static int coff_add_file ( struct CoffFileSet coff_files,
struct module module,
const char filename 
)
static

Definition at line 95 of file coff.c.

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}
unsigned source_new(struct module *module, const char *basedir, const char *source) DECLSPEC_HIDDEN
Definition: source.c:66
struct symt_compiland * symt_new_compiland(struct module *module, ULONG_PTR address, unsigned src_idx) DECLSPEC_HIDDEN
Definition: symbol.c:207
#define NULL
Definition: types.h:112
#define GetProcessHeap()
Definition: compat.h:736
#define HeapAlloc
Definition: compat.h:733
#define HeapReAlloc
Definition: compat.h:734
const char * filename
Definition: ioapi.h:137
struct CoffFile * files
Definition: coff.c:69
int nfiles
Definition: coff.c:70
int nfiles_alloc
Definition: coff.c:71
Definition: coff.c:56
Definition: fci.c:127

Referenced by coff_process_info().

◆ coff_add_symbol()

static void coff_add_symbol ( struct CoffFile coff_file,
struct symt sym 
)
static

Definition at line 128 of file coff.c.

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}
struct symt ** entries
Definition: coff.c:62
int neps_alloc
Definition: coff.c:64
int neps
Definition: coff.c:63

Referenced by coff_process_info().

◆ coff_get_name()

static const char * coff_get_name ( const IMAGE_SYMBOL coff_sym,
const char coff_strtab 
)
static

Definition at line 74 of file coff.c.

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}
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
union _IMAGE_SYMBOL::@2286 N
struct _IMAGE_SYMBOL::@2286::@2287 Name
BYTE ShortName[8]
Definition: pecoff.h:245

Referenced by coff_process_info().

◆ coff_process_info()

DECLSPEC_HIDDEN BOOL coff_process_info ( const struct msc_debug_info msc_dbg)

Definition at line 148 of file coff.c.

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}
r l[0]
Definition: byte_order.h:168
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
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
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
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 TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
@ SymCoff
Definition: compat.h:1057
#define IMAGE_SYM_CLASS_EXTERNAL
Definition: compat.h:149
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
static const WCHAR aux[]
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
union _IMAGE_LINENUMBER::@4186 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
SHORT SectionNumber
Definition: pecoff.h:253
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:644
#define ISFCN(x)
Definition: winnt_old.h:1064
#define IMAGE_SIZEOF_LINENUMBER
Definition: winnt_old.h:648
#define IMAGE_SYM_CLASS_STATIC
Definition: winnt_old.h:750

Referenced by pe_load_debug_directory().

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( dbghelp_coff  )