ReactOS  0.4.15-dev-1070-ge1a01de
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 }
int nfiles_alloc
Definition: coff.c:71
const char * filename
Definition: ioapi.h:135
Definition: coff.c:55
struct CoffFile * files
Definition: coff.c:69
smooth NULL
Definition: ftsmooth.c:416
#define GetProcessHeap()
Definition: compat.h:484
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
int nfiles
Definition: coff.c:70
const char file[]
Definition: icontest.c:11
#define HeapReAlloc
Definition: compat.h:482
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
Definition: fci.c:126

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 }
int neps
Definition: coff.c:63
#define GetProcessHeap()
Definition: compat.h:484
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
struct symt ** entries
Definition: coff.c:62
int neps_alloc
Definition: coff.c:64
#define HeapReAlloc
Definition: compat.h:482

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::@2256 N
BYTE ShortName[8]
Definition: pecoff.h:228
struct _IMAGE_SYMBOL::@2256::@2257 Name

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;
167  ULONG64 addr;
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 }
BOOL symt_get_address(const struct symt *type, ULONG64 *addr) DECLSPEC_HIDDEN
Definition: type.c:119
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
#define ISFCN(x)
Definition: winnt_old.h:1097
int __cdecl symt_cmp_addr(const void *p1, const void *p2) DECLSPEC_HIDDEN
Definition: symbol.c:57
static void coff_add_symbol(struct CoffFile *coff_file, struct symt *sym)
Definition: coff.c:128
static GLenum _GLUfuncptr fn
Definition: wgl_font.c:159
union _IMAGE_LINENUMBER::@3917 Type
#define TRUE
Definition: types.h:120
BYTE StorageClass
Definition: pecoff.h:238
static const char * coff_get_name(const IMAGE_SYMBOL *coff_sym, const char *coff_strtab)
Definition: coff.c:74
static int coff_add_file(struct CoffFileSet *coff_files, struct module *module, const char *filename)
Definition: coff.c:95
#define assert(x)
Definition: debug.h:53
const char * source_get(const struct module *module, unsigned idx) DECLSPEC_HIDDEN
Definition: source.c:130
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
DWORD Value
Definition: pecoff.h:235
#define FALSE
Definition: types.h:117
unsigned int BOOL
Definition: ntddk_ex.h:94
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 *))
smooth NULL
Definition: ftsmooth.c:416
#define IMAGE_SIZEOF_SYMBOL
Definition: winnt_old.h:677
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
r l[0]
Definition: byte_order.h:167
#define TRACE(s)
Definition: solgame.cpp:4
#define GetProcessHeap()
Definition: compat.h:484
unsigned long DWORD
Definition: ntddk_ex.h:95
WORD Type
Definition: pecoff.h:237
unsigned __int64 ULONG64
Definition: imports.h:198
int ret
#define IMAGE_SYM_CLASS_FILE
Definition: compat.h:150
GLenum const GLvoid * addr
Definition: glext.h:9621
const BYTE * root
Definition: mscvpdb.h:2139
struct module * module
Definition: mscvpdb.h:2134
SHORT SectionNumber
Definition: pecoff.h:236
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
BYTE Name[IMAGE_SIZEOF_SHORT_NAME]
Definition: pedump.c:281
static const WCHAR aux[]
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
static __inline const char * wine_dbgstr_longlong(ULONGLONG ll)
Definition: compat.h:49
#define IMAGE_SIZEOF_LINENUMBER
Definition: winnt_old.h:681
int k
Definition: mpi.c:3369
#define HeapFree(x, y, z)
Definition: compat.h:483
#define IMAGE_SYM_CLASS_STATIC
Definition: winnt_old.h:783
const IMAGE_SECTION_HEADER * sectp
Definition: mscvpdb.h:2136
#define IMAGE_SYM_CLASS_EXTERNAL
Definition: compat.h:149
BYTE NumberOfAuxSymbols
Definition: pecoff.h:239

Referenced by pe_load_debug_directory().

◆ WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL ( dbghelp_coff  )