git.oblomov.eu Git - wine/blob - debugger/debugger.h

   1 /*
   2  * Debugger definitions
   3  *
   4  * Copyright 1995 Alexandre Julliard
   5  */
   6
   7 #ifndef __WINE_DEBUGGER_H
   8 #define __WINE_DEBUGGER_H
   9
  10 #include <sys/types.h> /* u_long ... */
  11 #include <assert.h>
  12 #include "windef.h"
  13 #include "winbase.h"
  14 #include "wine/exception.h"
  15
  16 #ifdef __i386__
  17 #define STEP_FLAG 0x00000100 /* single step flag */
  18 #define V86_FLAG  0x00020000
  19 #endif
  20
  21 #define SYM_FUNC         0x0
  22 #define SYM_DATA         0x1
  23 #define SYM_WIN32        0x2
  24 #define SYM_WINE         0x4
  25 #define SYM_INVALID      0x8
  26 #define SYM_TRAMPOLINE   0x10
  27 #define SYM_STEP_THROUGH 0x20
  28
  29 enum    debug_type {DT_BASIC, DT_CONST, DT_POINTER, DT_ARRAY, DT_STRUCT, DT_ENUM, DT_TYPEDEF, DT_FUNC, DT_BITFIELD};
  30
  31
  32 /*
  33  * Return values for DEBUG_CheckLinenoStatus.  Used to determine
  34  * what to do when the 'step' command is given.
  35  */
  36 #define FUNC_HAS_NO_LINES       (0)
  37 #define NOT_ON_LINENUMBER       (1)
  38 #define AT_LINENUMBER           (2)
  39 #define FUNC_IS_TRAMPOLINE      (3)
  40
  41 /*
  42  * For constants generated by the parser, we use this datatype
  43  */
  44 extern struct datatype * DEBUG_TypeShortUInt;
  45 extern struct datatype * DEBUG_TypeInt;
  46 extern struct datatype * DEBUG_TypeIntConst;
  47 extern struct datatype * DEBUG_TypeUSInt;
  48 extern struct datatype * DEBUG_TypeString;
  49
  50 typedef struct
  51 {
  52     DWORD               seg;  /* 0xffffffff means current default segment (cs or ds) */
  53     DWORD               off;
  54 } DBG_ADDR;
  55
  56 typedef struct
  57 {
  58    struct datatype*     type;
  59    int                  cookie; /* DV_??? */
  60 /* DV_TARGET references an address in debugger's address space, whereas DV_HOST
  61  * references the debuggee address space
  62  */
  63 #       define  DV_TARGET       0xF00D
  64 #       define  DV_HOST         0x50DA
  65 #       define  DV_INVALID      0x0000
  66
  67    DBG_ADDR             addr;
  68 } DBG_VALUE;
  69
  70 struct list_id
  71 {
  72     char * sourcefile;
  73     int    line;
  74 };
  75
  76 struct  wine_lines {
  77   unsigned long         line_number;
  78   DBG_ADDR              pc_offset;
  79 };
  80
  81 struct symbol_info
  82 {
  83   struct name_hash * sym;
  84   struct list_id     list;
  85 };
  86
  87 typedef struct wine_lines WineLineNo;
  88
  89 /*
  90  * This structure holds information about stack variables, function
  91  * parameters, and register variables, which are all local to this
  92  * function.
  93  */
  94 struct  wine_locals {
  95   unsigned int          regno:8;        /* For register symbols */
  96   signed int            offset:24;      /* offset from esp/ebp to symbol */
  97   unsigned int          pc_start;       /* For RBRAC/LBRAC */
  98   unsigned int          pc_end;         /* For RBRAC/LBRAC */
  99   char                * name;           /* Name of symbol */
 100   struct datatype     * type;           /* Datatype of symbol */
 101 };
 102
 103 typedef struct wine_locals WineLocals;
 104
 105 enum exec_mode
 106 {
 107     EXEC_CONT,                  /* Continuous execution */
 108     EXEC_PASS,                  /* Continue, passing exception to app */
 109     EXEC_STEP_OVER,             /* Stepping over a call to next source line */
 110     EXEC_STEP_INSTR,            /* Step to next source line, stepping in if needed */
 111     EXEC_STEPI_OVER,            /* Stepping over a call */
 112     EXEC_STEPI_INSTR,           /* Single-stepping an instruction */
 113     EXEC_FINISH,                /* Step until we exit current frame */
 114     EXEC_STEP_OVER_TRAMPOLINE,  /* Step over trampoline.  Requires that
 115                                  * we dig the real return value off the stack
 116                                  * and set breakpoint there - not at the
 117                                  * instr just after the call.
 118                                  */
 119 };
 120
 121 #define DBG_BREAK       0
 122 #define DBG_WATCH       1
 123
 124 typedef struct
 125 {
 126     DBG_ADDR      addr;
 127     WORD          enabled : 1,
 128                   type : 1,
 129                   is32 : 1,
 130                   refcount : 13;
 131     WORD          skipcount;
 132     union {
 133        struct {
 134           BYTE          opcode;
 135           BOOL          (*func)(void);
 136        } b;
 137        struct {
 138           BYTE          rw : 1,
 139                         len : 2;
 140           BYTE          reg;
 141           DWORD         oldval;
 142        } w;
 143     } u;
 144     struct expr * condition;
 145 } DBG_BREAKPOINT;
 146
 147 enum dbg_mode
 148 {
 149     MODE_INVALID, MODE_16, MODE_32, MODE_VM86
 150 };
 151
 152 typedef struct tagDBG_THREAD {
 153     struct tagDBG_PROCESS*      process;
 154     HANDLE                      handle;
 155     DWORD                       tid;
 156     LPVOID                      start;
 157     LPVOID                      teb;
 158     int                         wait_for_first_exception;
 159     enum dbg_mode               dbg_mode;
 160     enum exec_mode              dbg_exec_mode;
 161     int                         dbg_exec_count;
 162     DBG_BREAKPOINT              stepOverBP;
 163     struct tagDBG_THREAD*       next;
 164     struct tagDBG_THREAD*       prev;
 165 } DBG_THREAD;
 166
 167 typedef struct tagDBG_PROCESS {
 168     HANDLE                      handle;
 169     DWORD                       pid;
 170     DBG_THREAD*                 threads;
 171     int                         num_threads;
 172     unsigned                    continue_on_first_exception;
 173     struct tagDBG_MODULE*       modules;
 174     unsigned long               dbg_hdr_addr;
 175     /*
 176      * This is an index we use to keep track of the debug information
 177      * when we have multiple sources.  We use the same database to also
 178      * allow us to do an 'info shared' type of deal, and we use the index
 179      * to eliminate duplicates.
 180      */
 181     int                         next_index;
 182     struct tagDBG_PROCESS*      next;
 183     struct tagDBG_PROCESS*      prev;
 184 } DBG_PROCESS;
 185
 186 extern  DBG_PROCESS*    DEBUG_CurrProcess;
 187 extern  DBG_THREAD*     DEBUG_CurrThread;
 188 extern  DWORD           DEBUG_CurrTid;
 189 extern  DWORD           DEBUG_CurrPid;
 190 extern  CONTEXT         DEBUG_context;
 191
 192 #define DEBUG_READ_MEM(addr, buf, len) \
 193       (ReadProcessMemory(DEBUG_CurrProcess->handle, (addr), (buf), (len), NULL))
 194
 195 #define DEBUG_WRITE_MEM(addr, buf, len) \
 196       (WriteProcessMemory(DEBUG_CurrProcess->handle, (addr), (buf), (len), NULL))
 197
 198 #define DEBUG_READ_MEM_VERBOSE(addr, buf, len) \
 199       (DEBUG_READ_MEM((addr), (buf), (len)) || (DEBUG_InvalLinAddr( addr ),0))
 200
 201 #define DEBUG_WRITE_MEM_VERBOSE(addr, buf, len) \
 202       (DEBUG_WRITE_MEM((addr), (buf), (len)) || (DEBUG_InvalLinAddr( addr ),0))
 203
 204 typedef struct tagDBG_MODULE {
 205    struct tagDBG_MODULE*        next;
 206    void*                        load_addr;
 207    char*                        module_name;
 208    char                         status;
 209    char                         type;
 210    short int                    dbg_index;
 211    HMODULE                      handle;
 212    void*                        extra_info;
 213 } DBG_MODULE;
 214
 215 /* status field */
 216 #define DM_STATUS_NEW           0
 217 #define DM_STATUS_LOADED        1
 218 #define DM_STATUS_ERROR         2
 219
 220 /* type field */
 221 #define DM_TYPE_UNKNOWN         0
 222 #define DM_TYPE_ELF             1
 223 #define DM_TYPE_NE              2
 224 #define DM_TYPE_PE              3
 225
 226 typedef struct {
 227    DWORD                val;
 228    const char*          name;
 229    LPDWORD              pval;
 230    struct datatype*     type;
 231 } DBG_INTVAR;
 232
 233 #define OFFSET_OF(__c,__f)              ((int)(((char*)&(((__c*)0)->__f))-((char*)0)))
 234
 235   /* from winelib.so */
 236 extern void DEBUG_ExternalDebugger(void);
 237
 238   /* debugger/break.c */
 239 extern void DEBUG_SetBreakpoints( BOOL set );
 240 extern void DEBUG_AddBreakpoint( const DBG_VALUE *addr, BOOL (*func)(void) );
 241 extern void DEBUG_AddBreakpointFromId( const char *name, int lineno );
 242 extern void DEBUG_AddBreakpointFromLineno( int lineno );
 243 extern void DEBUG_AddWatchpoint( const DBG_VALUE *addr, int is_write );
 244 extern void DEBUG_AddWatchpointFromId( const char *name, int lineno );
 245 extern void DEBUG_DelBreakpoint( int num );
 246 extern void DEBUG_EnableBreakpoint( int num, BOOL enable );
 247 extern void DEBUG_InfoBreakpoints(void);
 248 extern BOOL DEBUG_HandleTrap(void);
 249 extern BOOL DEBUG_ShouldContinue( DBG_ADDR *addr, DWORD code, enum exec_mode mode, int * count );
 250 extern void DEBUG_SuspendExecution( void );
 251 extern enum exec_mode DEBUG_RestartExecution( enum exec_mode mode, int count );
 252 extern BOOL DEBUG_IsFctReturn(void);
 253 extern int  DEBUG_AddBPCondition(int bpnum, struct expr * exp);
 254
 255   /* debugger/db_disasm.c */
 256 extern void DEBUG_Disasm( DBG_ADDR *addr, int display );
 257
 258   /* debugger/dbg.y */
 259 extern BOOL DEBUG_Parser(void);
 260 extern void DEBUG_Exit( DWORD );
 261
 262   /* debugger/debug.l */
 263 extern void DEBUG_FlushSymbols(void);
 264
 265   /* debugger/display.c */
 266 extern int DEBUG_DoDisplay(void);
 267 extern int DEBUG_AddDisplay(struct expr * exp, int count, char format);
 268 extern int DEBUG_DoDisplay(void);
 269 extern int DEBUG_DelDisplay(int displaynum);
 270 extern int DEBUG_InfoDisplay(void);
 271
 272   /* debugger/editline.c */
 273 extern char * readline(const char *);
 274 extern void add_history(char *);
 275
 276   /* debugger/expr.c */
 277 extern void DEBUG_FreeExprMem(void);
 278 struct expr * DEBUG_IntVarExpr(const char* name);
 279 struct expr * DEBUG_SymbolExpr(const char * name);
 280 struct expr * DEBUG_ConstExpr(int val);
 281 struct expr * DEBUG_StringExpr(const char * str);
 282 struct expr * DEBUG_SegAddr(struct expr *, struct expr *);
 283 struct expr * DEBUG_USConstExpr(unsigned int val);
 284 struct expr * DEBUG_BinopExpr(int oper, struct expr *, struct expr *);
 285 struct expr * DEBUG_UnopExpr(int oper, struct expr *);
 286 struct expr * DEBUG_StructPExpr(struct expr *, const char * element);
 287 struct expr * DEBUG_StructExpr(struct expr *, const char * element);
 288 struct expr * DEBUG_ArrayExpr(struct expr *, struct expr * index);
 289 struct expr * DEBUG_CallExpr(const char *, int nargs, ...);
 290 struct expr * DEBUG_TypeCastExpr(struct datatype *, struct expr *);
 291 extern DBG_VALUE DEBUG_EvalExpr(struct expr *);
 292 extern int DEBUG_DelDisplay(int displaynum);
 293 extern struct expr * DEBUG_CloneExpr(const struct expr * exp);
 294 extern int DEBUG_FreeExpr(struct expr * exp);
 295 extern int DEBUG_DisplayExpr(const struct expr * exp);
 296
 297   /* debugger/hash.c */
 298 extern struct name_hash * DEBUG_AddSymbol( const char *name,
 299                                            const DBG_VALUE *addr,
 300                                            const char *sourcefile,
 301                                            int flags);
 302 extern BOOL DEBUG_GetSymbolValue( const char * name, const int lineno,
 303                                   DBG_VALUE *addr, int );
 304 extern BOOL DEBUG_SetSymbolValue( const char * name, const DBG_VALUE *addr );
 305 extern const char * DEBUG_FindNearestSymbol( const DBG_ADDR *addr, int flag,
 306                                              struct name_hash ** rtn,
 307                                              unsigned int ebp,
 308                                              struct list_id * source);
 309 extern void DEBUG_ReadSymbolTable( const char * filename );
 310 extern void DEBUG_AddLineNumber( struct name_hash * func, int line_num,
 311                                  unsigned long offset );
 312 extern struct wine_locals *
 313             DEBUG_AddLocal( struct name_hash * func, int regno,
 314                             int offset,
 315                             int pc_start,
 316                             int pc_end,
 317                             char * name);
 318 extern int DEBUG_CheckLinenoStatus(const DBG_ADDR *addr);
 319 extern void DEBUG_GetFuncInfo(struct list_id * ret, const char * file,
 320                               const char * func);
 321 extern int DEBUG_SetSymbolSize(struct name_hash * sym, unsigned int len);
 322 extern int DEBUG_SetSymbolBPOff(struct name_hash * sym, unsigned int len);
 323 extern int DEBUG_GetSymbolAddr(struct name_hash * sym, DBG_ADDR * addr);
 324 extern int DEBUG_cmp_sym(const void * p1, const void * p2);
 325 extern BOOL DEBUG_GetLineNumberAddr( struct name_hash *, const int lineno,
 326                                      DBG_ADDR *addr, int bp_flag );
 327
 328 extern int DEBUG_SetLocalSymbolType(struct wine_locals * sym,
 329                                     struct datatype * type);
 330 extern BOOL DEBUG_Normalize(struct name_hash * nh );
 331
 332   /* debugger/info.c */
 333 extern void DEBUG_PrintBasic( const DBG_VALUE* value, int count, char format );
 334 extern struct symbol_info DEBUG_PrintAddress( const DBG_ADDR *addr, enum dbg_mode mode, int flag );
 335 extern void DEBUG_Help(void);
 336 extern void DEBUG_HelpInfo(void);
 337 extern struct symbol_info DEBUG_PrintAddressAndArgs( const DBG_ADDR *addr,
 338                                                      enum dbg_mode mode,
 339                                                      unsigned int ebp,
 340                                                      int flag );
 341 extern void DEBUG_InfoClass(const char* clsName);
 342 extern void DEBUG_WalkClasses(void);
 343 extern void DEBUG_WalkModref(DWORD p);
 344 extern void DEBUG_DumpModule(DWORD mod);
 345 extern void DEBUG_WalkModules(void);
 346 extern void DEBUG_WalkProcess(void);
 347 extern void DEBUG_WalkThreads(void);
 348 extern void DEBUG_DumpQueue(DWORD q);
 349 extern void DEBUG_WalkQueues(void);
 350 extern void DEBUG_InfoSegments(DWORD s, int v);
 351 extern void DEBUG_InfoVirtual(void);
 352 extern void DEBUG_InfoWindow(HWND hWnd);
 353 extern void DEBUG_WalkWindows(HWND hWnd, int indent);
 354
 355   /* debugger/memory.c */
 356 extern int  DEBUG_ReadMemory( const DBG_VALUE* value );
 357 extern void DEBUG_WriteMemory( const DBG_VALUE* val, int value );
 358 extern void DEBUG_ExamineMemory( const DBG_VALUE *addr, int count, char format);
 359 extern void DEBUG_InvalAddr( const DBG_ADDR* addr );
 360 extern void DEBUG_InvalLinAddr( void* addr );
 361 extern DWORD DEBUG_ToLinear( const DBG_ADDR *address );
 362 extern void DEBUG_GetCurrentAddress( DBG_ADDR * );
 363 extern BOOL DEBUG_GrabAddress( DBG_VALUE* value, BOOL fromCode );
 364 extern enum dbg_mode DEBUG_GetSelectorType( WORD sel );
 365 #ifdef __i386__
 366 extern void DEBUG_FixAddress( DBG_ADDR *address, DWORD def );
 367 extern int  DEBUG_IsSelectorSystem( WORD sel );
 368 #endif
 369
 370   /* debugger/module.c */
 371 extern int  DEBUG_LoadEntryPoints( const char * prefix );
 372 extern void DEBUG_LoadModule32( const char* name, HANDLE hFile, DWORD base );
 373 extern DBG_MODULE* DEBUG_AddModule(const char* name, int type,
 374                                    void* mod_addr, HMODULE hmod);
 375 extern DBG_MODULE* DEBUG_FindModuleByName(const char* name, int type);
 376 extern DBG_MODULE* DEBUG_FindModuleByHandle(HANDLE handle, int type);
 377 extern DBG_MODULE* DEBUG_GetProcessMainModule(DBG_PROCESS* process);
 378 extern DBG_MODULE* DEBUG_RegisterPEModule(HMODULE, u_long load_addr, const char* name);
 379 extern DBG_MODULE* DEBUG_RegisterELFModule(u_long load_addr, const char* name);
 380 extern void DEBUG_InfoShare(void);
 381
 382   /* debugger/msc.c */
 383 extern int DEBUG_RegisterMSCDebugInfo(DBG_MODULE* module, HANDLE hFile, void* nth, unsigned long nth_ofs);
 384 extern int DEBUG_RegisterStabsDebugInfo(DBG_MODULE* module, HANDLE hFile, void* nth, unsigned long nth_ofs);
 385 extern void DEBUG_InitCVDataTypes(void);
 386
 387   /* debugger/registers.c */
 388 extern void DEBUG_InfoRegisters(void);
 389 extern BOOL DEBUG_ValidateRegisters(void);
 390
 391   /* debugger/source.c */
 392 extern void DEBUG_ShowDir(void);
 393 extern void DEBUG_AddPath(const char * path);
 394 extern void DEBUG_List(struct list_id * line1, struct list_id * line2,
 395                        int delta);
 396 extern void DEBUG_NukePath(void);
 397 extern void DEBUG_Disassemble(const DBG_VALUE *, const DBG_VALUE*, int offset);
 398 extern BOOL DEBUG_DisassembleInstruction(DBG_ADDR *addr);
 399
 400   /* debugger/stack.c */
 401 extern void DEBUG_InfoStack(void);
 402 extern void DEBUG_BackTrace(BOOL noisy);
 403 extern int  DEBUG_InfoLocals(void);
 404 extern int  DEBUG_SetFrame(int newframe);
 405 extern int  DEBUG_GetCurrentFrame(struct name_hash ** name,
 406                                   unsigned int * eip,
 407                                   unsigned int * ebp);
 408
 409   /* debugger/stabs.c */
 410 extern int DEBUG_ReadExecutableDbgInfo(const char* exe_name);
 411 extern int DEBUG_ParseStabs(char * addr, unsigned int load_offset, unsigned int staboff,
 412                             int stablen, unsigned int strtaboff, int strtablen);
 413
 414   /* debugger/types.c */
 415 extern int DEBUG_nchar;
 416 extern void DEBUG_InitTypes(void);
 417 extern struct datatype * DEBUG_NewDataType(enum debug_type xtype,
 418                                            const char * typename);
 419 extern unsigned int DEBUG_TypeDerefPointer(const DBG_VALUE *value, struct datatype ** newtype);
 420 extern int DEBUG_AddStructElement(struct datatype * dt,
 421                                   char * name, struct datatype * type,
 422                                   int offset, int size);
 423 extern int DEBUG_SetStructSize(struct datatype * dt, int size);
 424 extern int DEBUG_SetPointerType(struct datatype * dt, struct datatype * dt2);
 425 extern int DEBUG_SetArrayParams(struct datatype * dt, int min, int max,
 426                                 struct datatype * dt2);
 427 extern void DEBUG_Print( const DBG_VALUE *addr, int count, char format, int level );
 428 extern unsigned int DEBUG_FindStructElement(DBG_VALUE * addr,
 429                                             const char * ele_name, int * tmpbuf);
 430 extern struct datatype * DEBUG_GetPointerType(struct datatype * dt);
 431 extern int DEBUG_GetObjectSize(struct datatype * dt);
 432 extern unsigned int DEBUG_ArrayIndex(const DBG_VALUE * addr, DBG_VALUE * result, int index);
 433 extern struct datatype * DEBUG_FindOrMakePointerType(struct datatype * reftype);
 434 extern long long int DEBUG_GetExprValue(const DBG_VALUE * addr, char ** format);
 435 extern int DEBUG_SetBitfieldParams(struct datatype * dt, int offset,
 436                                    int nbits, struct datatype * dt2);
 437 extern int DEBUG_CopyFieldlist(struct datatype * dt, struct datatype * dt2);
 438 extern enum debug_type DEBUG_GetType(struct datatype * dt);
 439 extern struct datatype * DEBUG_TypeCast(enum debug_type, const char *);
 440 extern int DEBUG_PrintTypeCast(const struct datatype *);
 441 extern int DEBUG_PrintType( const DBG_VALUE* addr );
 442
 443   /* debugger/winedbg.c */
 444 #define DBG_CHN_MESG    1
 445 #define DBG_CHN_ERR     2
 446 #define DBG_CHN_WARN    4
 447 #define DBG_CHN_FIXME   8
 448 #define DBG_CHN_TRACE   16
 449 extern void     DEBUG_Output(int chn, const char* buffer, int len);
 450 #ifdef __GNUC__
 451 extern int      DEBUG_Printf(int chn, const char* format, ...) __attribute__((format (printf,2,3)));
 452 #else
 453 extern int      DEBUG_Printf(int chn, const char* format, ...);
 454 #endif
 455 extern DBG_INTVAR*      DEBUG_GetIntVar(const char*);
 456 extern BOOL DEBUG_Attach(DWORD pid, BOOL cofe);
 457 extern void DEBUG_Run(const char* args);
 458 extern int curr_frame;
 459
 460 /* Choose your allocator! */
 461 #if 1
 462 /* this one is libc's fast one */
 463 extern void*    DEBUG_XMalloc(size_t size);
 464 extern void*    DEBUG_XReAlloc(void *ptr, size_t size);
 465 extern char*    DEBUG_XStrDup(const char *str);
 466
 467 #define DBG_alloc(x)            DEBUG_XMalloc(x)
 468 #define DBG_realloc(x,y)        DEBUG_XReAlloc(x,y)
 469 #define DBG_free(x)             free(x)
 470 #define DBG_strdup(x)           DEBUG_XStrDup(x)
 471 #else
 472 /* this one is slow (takes 5 minutes to load the debugger on my machine),
 473    but is pretty crash-proof (can step through malloc() without problems,
 474    malloc() arena (and other heaps) can be totally wasted and it'll still
 475    work, etc... if someone could make optimized routines so it wouldn't
 476    take so long to load, it could be made default) */
 477 #include "heap.h"
 478 #define DBG_alloc(x) HeapAlloc(dbg_heap,0,x)
 479 #define DBG_realloc(x,y) HeapRealloc(dbg_heap,0,x,y)
 480 #define DBG_free(x) HeapFree(dbg_heap,0,x)
 481 #define DBG_strdup(x) HEAP_strdupA(dbg_heap,0,x)
 482 #define DBG_need_heap
 483 extern HANDLE dbg_heap;
 484 #endif
 485
 486 #define DEBUG_STATUS_OFFSET             0x80003000
 487 #define DEBUG_STATUS_INTERNAL_ERROR     (DEBUG_STATUS_OFFSET+0)
 488 #define DEBUG_STATUS_NO_SYMBOL          (DEBUG_STATUS_OFFSET+1)
 489 #define DEBUG_STATUS_DIV_BY_ZERO        (DEBUG_STATUS_OFFSET+2)
 490 #define DEBUG_STATUS_BAD_TYPE           (DEBUG_STATUS_OFFSET+3)
 491
 492 extern DBG_INTVAR               DEBUG_IntVars[];
 493
 494 #define  DBG_IVARNAME(_var)     DEBUG_IV_##_var
 495 #define  DBG_IVARSTRUCT(_var)   DEBUG_IntVars[DBG_IVARNAME(_var)]
 496 #define  DBG_IVAR(_var)         (*(DBG_IVARSTRUCT(_var).pval))
 497 #define  INTERNAL_VAR(_var,_val,_ref,_typ) DBG_IVARNAME(_var),
 498 enum debug_int_var {
 499 #include "intvar.h"
 500    DBG_IV_LAST
 501 };
 502 #undef   INTERNAL_VAR
 503
 504 #endif  /* __WINE_DEBUGGER_H */