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 typedef struct tagDBG_THREAD {
 148     struct tagDBG_PROCESS*      process;
 149     HANDLE                      handle;
 150     DWORD                       tid;
 151     LPVOID                      start;
 152     LPVOID                      teb;
 153     int                         wait_for_first_exception;
 154     int                         dbg_mode;
 155     enum exec_mode              dbg_exec_mode;
 156     int                         dbg_exec_count;
 157     DBG_BREAKPOINT              stepOverBP;
 158     struct tagDBG_THREAD*       next;
 159     struct tagDBG_THREAD*       prev;
 160 } DBG_THREAD;
 161
 162 typedef struct tagDBG_PROCESS {
 163     HANDLE                      handle;
 164     DWORD                       pid;
 165     DBG_THREAD*                 threads;
 166     int                         num_threads;
 167     unsigned                    continue_on_first_exception;
 168     struct tagDBG_MODULE*       modules;
 169     unsigned long               dbg_hdr_addr;
 170     /*
 171      * This is an index we use to keep track of the debug information
 172      * when we have multiple sources.  We use the same database to also
 173      * allow us to do an 'info shared' type of deal, and we use the index
 174      * to eliminate duplicates.
 175      */
 176     int                         next_index;
 177     struct tagDBG_PROCESS*      next;
 178     struct tagDBG_PROCESS*      prev;
 179 } DBG_PROCESS;
 180
 181 extern  DBG_PROCESS*    DEBUG_CurrProcess;
 182 extern  DBG_THREAD*     DEBUG_CurrThread;
 183 extern  DWORD           DEBUG_CurrTid;
 184 extern  DWORD           DEBUG_CurrPid;
 185 extern  CONTEXT         DEBUG_context;
 186
 187 #define DEBUG_READ_MEM(addr, buf, len) \
 188       (ReadProcessMemory(DEBUG_CurrProcess->handle, (addr), (buf), (len), NULL))
 189
 190 #define DEBUG_WRITE_MEM(addr, buf, len) \
 191       (WriteProcessMemory(DEBUG_CurrProcess->handle, (addr), (buf), (len), NULL))
 192
 193 #define DEBUG_READ_MEM_VERBOSE(addr, buf, len) \
 194       (DEBUG_READ_MEM((addr), (buf), (len)) || (DEBUG_InvalLinAddr( addr ),0))
 195
 196 #define DEBUG_WRITE_MEM_VERBOSE(addr, buf, len) \
 197       (DEBUG_WRITE_MEM((addr), (buf), (len)) || (DEBUG_InvalLinAddr( addr ),0))
 198
 199 typedef struct tagDBG_MODULE {
 200    struct tagDBG_MODULE*        next;
 201    void*                        load_addr;
 202    char*                        module_name;
 203    char                         status;
 204    char                         type;
 205    short int                    dbg_index;
 206    HMODULE                      handle;
 207    void*                        extra_info;
 208 } DBG_MODULE;
 209
 210 /* status field */
 211 #define DM_STATUS_NEW           0
 212 #define DM_STATUS_LOADED        1
 213 #define DM_STATUS_ERROR         2
 214
 215 /* type field */
 216 #define DM_TYPE_UNKNOWN         0
 217 #define DM_TYPE_ELF             1
 218 #define DM_TYPE_NE              2
 219 #define DM_TYPE_PE              3
 220
 221 typedef struct {
 222    DWORD                val;
 223    const char*          name;
 224    LPDWORD              pval;
 225    struct datatype*     type;
 226 } DBG_INTVAR;
 227
 228 #define OFFSET_OF(__c,__f)              ((int)(((char*)&(((__c*)0)->__f))-((char*)0)))
 229
 230   /* from winelib.so */
 231 extern void DEBUG_ExternalDebugger(void);
 232
 233   /* debugger/break.c */
 234 extern void DEBUG_SetBreakpoints( BOOL set );
 235 extern void DEBUG_AddBreakpoint( const DBG_VALUE *addr, BOOL (*func)(void) );
 236 extern void DEBUG_AddBreakpointFromId( const char *name, int lineno );
 237 extern void DEBUG_AddBreakpointFromLineno( int lineno );
 238 extern void DEBUG_AddWatchpoint( const DBG_VALUE *addr, int is_write );
 239 extern void DEBUG_AddWatchpointFromId( const char *name, int lineno );
 240 extern void DEBUG_DelBreakpoint( int num );
 241 extern void DEBUG_EnableBreakpoint( int num, BOOL enable );
 242 extern void DEBUG_InfoBreakpoints(void);
 243 extern BOOL DEBUG_HandleTrap(void);
 244 extern BOOL DEBUG_ShouldContinue( DBG_ADDR *addr, DWORD code, enum exec_mode mode, int * count );
 245 extern void DEBUG_SuspendExecution( void );
 246 extern enum exec_mode DEBUG_RestartExecution( enum exec_mode mode, int count );
 247 extern BOOL DEBUG_IsFctReturn(void);
 248 extern int  DEBUG_AddBPCondition(int bpnum, struct expr * exp);
 249
 250   /* debugger/db_disasm.c */
 251 extern void DEBUG_Disasm( DBG_ADDR *addr, int display );
 252
 253   /* debugger/dbg.y */
 254 extern BOOL DEBUG_Parser(void);
 255 extern void DEBUG_Exit( DWORD );
 256
 257   /* debugger/debug.l */
 258 extern void DEBUG_FlushSymbols(void);
 259
 260   /* debugger/display.c */
 261 extern int DEBUG_DoDisplay(void);
 262 extern int DEBUG_AddDisplay(struct expr * exp, int count, char format);
 263 extern int DEBUG_DoDisplay(void);
 264 extern int DEBUG_DelDisplay(int displaynum);
 265 extern int DEBUG_InfoDisplay(void);
 266
 267   /* debugger/editline.c */
 268 extern char * readline(const char *);
 269 extern void add_history(char *);
 270
 271   /* debugger/expr.c */
 272 extern void DEBUG_FreeExprMem(void);
 273 struct expr * DEBUG_IntVarExpr(const char* name);
 274 struct expr * DEBUG_SymbolExpr(const char * name);
 275 struct expr * DEBUG_ConstExpr(int val);
 276 struct expr * DEBUG_StringExpr(const char * str);
 277 struct expr * DEBUG_SegAddr(struct expr *, struct expr *);
 278 struct expr * DEBUG_USConstExpr(unsigned int val);
 279 struct expr * DEBUG_BinopExpr(int oper, struct expr *, struct expr *);
 280 struct expr * DEBUG_UnopExpr(int oper, struct expr *);
 281 struct expr * DEBUG_StructPExpr(struct expr *, const char * element);
 282 struct expr * DEBUG_StructExpr(struct expr *, const char * element);
 283 struct expr * DEBUG_ArrayExpr(struct expr *, struct expr * index);
 284 struct expr * DEBUG_CallExpr(const char *, int nargs, ...);
 285 struct expr * DEBUG_TypeCastExpr(struct datatype *, struct expr *);
 286 extern DBG_VALUE DEBUG_EvalExpr(struct expr *);
 287 extern int DEBUG_DelDisplay(int displaynum);
 288 extern struct expr * DEBUG_CloneExpr(const struct expr * exp);
 289 extern int DEBUG_FreeExpr(struct expr * exp);
 290 extern int DEBUG_DisplayExpr(const struct expr * exp);
 291
 292   /* debugger/hash.c */
 293 extern struct name_hash * DEBUG_AddSymbol( const char *name,
 294                                            const DBG_VALUE *addr,
 295                                            const char *sourcefile,
 296                                            int flags);
 297 extern BOOL DEBUG_GetSymbolValue( const char * name, const int lineno,
 298                                   DBG_VALUE *addr, int );
 299 extern BOOL DEBUG_SetSymbolValue( const char * name, const DBG_VALUE *addr );
 300 extern const char * DEBUG_FindNearestSymbol( const DBG_ADDR *addr, int flag,
 301                                              struct name_hash ** rtn,
 302                                              unsigned int ebp,
 303                                              struct list_id * source);
 304 extern void DEBUG_ReadSymbolTable( const char * filename );
 305 extern void DEBUG_AddLineNumber( struct name_hash * func, int line_num,
 306                                  unsigned long offset );
 307 extern struct wine_locals *
 308             DEBUG_AddLocal( struct name_hash * func, int regno,
 309                             int offset,
 310                             int pc_start,
 311                             int pc_end,
 312                             char * name);
 313 extern int DEBUG_CheckLinenoStatus(const DBG_ADDR *addr);
 314 extern void DEBUG_GetFuncInfo(struct list_id * ret, const char * file,
 315                               const char * func);
 316 extern int DEBUG_SetSymbolSize(struct name_hash * sym, unsigned int len);
 317 extern int DEBUG_SetSymbolBPOff(struct name_hash * sym, unsigned int len);
 318 extern int DEBUG_GetSymbolAddr(struct name_hash * sym, DBG_ADDR * addr);
 319 extern int DEBUG_cmp_sym(const void * p1, const void * p2);
 320 extern BOOL DEBUG_GetLineNumberAddr( struct name_hash *, const int lineno,
 321                                      DBG_ADDR *addr, int bp_flag );
 322
 323 extern int DEBUG_SetLocalSymbolType(struct wine_locals * sym,
 324                                     struct datatype * type);
 325 extern BOOL DEBUG_Normalize(struct name_hash * nh );
 326
 327   /* debugger/info.c */
 328 extern void DEBUG_PrintBasic( const DBG_VALUE* value, int count, char format );
 329 extern struct symbol_info DEBUG_PrintAddress( const DBG_ADDR *addr,
 330                                               int addrlen, int flag );
 331 extern void DEBUG_Help(void);
 332 extern void DEBUG_HelpInfo(void);
 333 extern struct symbol_info DEBUG_PrintAddressAndArgs( const DBG_ADDR *addr,
 334                                                      int addrlen,
 335                                                      unsigned int ebp,
 336                                                      int flag );
 337 extern void DEBUG_InfoClass(const char* clsName);
 338 extern void DEBUG_WalkClasses(void);
 339 extern void DEBUG_WalkModref(DWORD p);
 340 extern void DEBUG_DumpModule(DWORD mod);
 341 extern void DEBUG_WalkModules(void);
 342 extern void DEBUG_WalkProcess(void);
 343 extern void DEBUG_WalkThreads(void);
 344 extern void DEBUG_DumpQueue(DWORD q);
 345 extern void DEBUG_WalkQueues(void);
 346 extern void DEBUG_InfoSegments(DWORD s, int v);
 347 extern void DEBUG_InfoVirtual(void);
 348 extern void DEBUG_InfoWindow(HWND hWnd);
 349 extern void DEBUG_WalkWindows(HWND hWnd, int indent);
 350
 351   /* debugger/memory.c */
 352 extern int  DEBUG_ReadMemory( const DBG_VALUE* value );
 353 extern void DEBUG_WriteMemory( const DBG_VALUE* val, int value );
 354 extern void DEBUG_ExamineMemory( const DBG_VALUE *addr, int count, char format);
 355 extern void DEBUG_InvalAddr( const DBG_ADDR* addr );
 356 extern void DEBUG_InvalLinAddr( void* addr );
 357 extern DWORD DEBUG_ToLinear( const DBG_ADDR *address );
 358 extern void DEBUG_GetCurrentAddress( DBG_ADDR * );
 359 extern BOOL DEBUG_GrabAddress( DBG_VALUE* value, BOOL fromCode );
 360 #ifdef __i386__
 361 extern void DEBUG_FixAddress( DBG_ADDR *address, DWORD def );
 362 extern BOOL DEBUG_FixSegment( DBG_ADDR* addr );
 363 extern int  DEBUG_GetSelectorType( WORD sel );
 364 extern int  DEBUG_IsSelectorSystem( WORD sel );
 365 #endif
 366
 367   /* debugger/module.c */
 368 extern int  DEBUG_LoadEntryPoints( const char * prefix );
 369 extern void DEBUG_LoadModule32( const char* name, HANDLE hFile, DWORD base );
 370 extern DBG_MODULE* DEBUG_AddModule(const char* name, int type,
 371                                    void* mod_addr, HMODULE hmod);
 372 extern DBG_MODULE* DEBUG_FindModuleByName(const char* name, int type);
 373 extern DBG_MODULE* DEBUG_FindModuleByHandle(HANDLE handle, int type);
 374 extern DBG_MODULE* DEBUG_GetProcessMainModule(DBG_PROCESS* process);
 375 extern DBG_MODULE* DEBUG_RegisterPEModule(HMODULE, u_long load_addr, const char* name);
 376 extern DBG_MODULE* DEBUG_RegisterELFModule(u_long load_addr, const char* name);
 377 extern void DEBUG_InfoShare(void);
 378
 379   /* debugger/msc.c */
 380 extern int DEBUG_RegisterMSCDebugInfo(DBG_MODULE* module, HANDLE hFile, void* nth, unsigned long nth_ofs);
 381 extern int DEBUG_RegisterStabsDebugInfo(DBG_MODULE* module, HANDLE hFile, void* nth, unsigned long nth_ofs);
 382 extern void DEBUG_InitCVDataTypes(void);
 383
 384   /* debugger/registers.c */
 385 extern void DEBUG_InfoRegisters(void);
 386 extern BOOL DEBUG_ValidateRegisters(void);
 387
 388   /* debugger/source.c */
 389 extern void DEBUG_ShowDir(void);
 390 extern void DEBUG_AddPath(const char * path);
 391 extern void DEBUG_List(struct list_id * line1, struct list_id * line2,
 392                        int delta);
 393 extern void DEBUG_NukePath(void);
 394 extern void DEBUG_Disassemble(const DBG_VALUE *, const DBG_VALUE*, int offset);
 395 extern BOOL DEBUG_DisassembleInstruction(DBG_ADDR *addr);
 396
 397   /* debugger/stack.c */
 398 extern void DEBUG_InfoStack(void);
 399 extern void DEBUG_BackTrace(BOOL noisy);
 400 extern int  DEBUG_InfoLocals(void);
 401 extern int  DEBUG_SetFrame(int newframe);
 402 extern int  DEBUG_GetCurrentFrame(struct name_hash ** name,
 403                                   unsigned int * eip,
 404                                   unsigned int * ebp);
 405
 406   /* debugger/stabs.c */
 407 extern int DEBUG_ReadExecutableDbgInfo(const char* exe_name);
 408 extern int DEBUG_ParseStabs(char * addr, unsigned int load_offset, unsigned int staboff,
 409                             int stablen, unsigned int strtaboff, int strtablen);
 410
 411   /* debugger/types.c */
 412 extern int DEBUG_nchar;
 413 extern void DEBUG_InitTypes(void);
 414 extern struct datatype * DEBUG_NewDataType(enum debug_type xtype,
 415                                            const char * typename);
 416 extern unsigned int DEBUG_TypeDerefPointer(const DBG_VALUE *value, struct datatype ** newtype);
 417 extern int DEBUG_AddStructElement(struct datatype * dt,
 418                                   char * name, struct datatype * type,
 419                                   int offset, int size);
 420 extern int DEBUG_SetStructSize(struct datatype * dt, int size);
 421 extern int DEBUG_SetPointerType(struct datatype * dt, struct datatype * dt2);
 422 extern int DEBUG_SetArrayParams(struct datatype * dt, int min, int max,
 423                                 struct datatype * dt2);
 424 extern void DEBUG_Print( const DBG_VALUE *addr, int count, char format, int level );
 425 extern unsigned int DEBUG_FindStructElement(DBG_VALUE * addr,
 426                                             const char * ele_name, int * tmpbuf);
 427 extern struct datatype * DEBUG_GetPointerType(struct datatype * dt);
 428 extern int DEBUG_GetObjectSize(struct datatype * dt);
 429 extern unsigned int DEBUG_ArrayIndex(const DBG_VALUE * addr, DBG_VALUE * result, int index);
 430 extern struct datatype * DEBUG_FindOrMakePointerType(struct datatype * reftype);
 431 extern long long int DEBUG_GetExprValue(const DBG_VALUE * addr, char ** format);
 432 extern int DEBUG_SetBitfieldParams(struct datatype * dt, int offset,
 433                                    int nbits, struct datatype * dt2);
 434 extern int DEBUG_CopyFieldlist(struct datatype * dt, struct datatype * dt2);
 435 extern enum debug_type DEBUG_GetType(struct datatype * dt);
 436 extern struct datatype * DEBUG_TypeCast(enum debug_type, const char *);
 437 extern int DEBUG_PrintTypeCast(const struct datatype *);
 438 extern int DEBUG_PrintType( const DBG_VALUE* addr );
 439
 440   /* debugger/winedbg.c */
 441 #define DBG_CHN_MESG    1
 442 #define DBG_CHN_ERR     2
 443 #define DBG_CHN_WARN    4
 444 #define DBG_CHN_FIXME   8
 445 #define DBG_CHN_TRACE   16
 446 extern void     DEBUG_Output(int chn, const char* buffer, int len);
 447 #ifdef __GNUC__
 448 extern int      DEBUG_Printf(int chn, const char* format, ...) __attribute__((format (printf,2,3)));
 449 #else
 450 extern int      DEBUG_Printf(int chn, const char* format, ...);
 451 #endif
 452 extern DBG_INTVAR*      DEBUG_GetIntVar(const char*);
 453 extern BOOL DEBUG_Attach(DWORD pid, BOOL cofe);
 454 extern void DEBUG_Run(const char* args);
 455 extern int curr_frame;
 456
 457 /* Choose your allocator! */
 458 #if 1
 459 /* this one is libc's fast one */
 460 extern void*    DEBUG_XMalloc(size_t size);
 461 extern void*    DEBUG_XReAlloc(void *ptr, size_t size);
 462 extern char*    DEBUG_XStrDup(const char *str);
 463
 464 #define DBG_alloc(x)            DEBUG_XMalloc(x)
 465 #define DBG_realloc(x,y)        DEBUG_XReAlloc(x,y)
 466 #define DBG_free(x)             free(x)
 467 #define DBG_strdup(x)           DEBUG_XStrDup(x)
 468 #else
 469 /* this one is slow (takes 5 minutes to load the debugger on my machine),
 470    but is pretty crash-proof (can step through malloc() without problems,
 471    malloc() arena (and other heaps) can be totally wasted and it'll still
 472    work, etc... if someone could make optimized routines so it wouldn't
 473    take so long to load, it could be made default) */
 474 #include "heap.h"
 475 #define DBG_alloc(x) HeapAlloc(dbg_heap,0,x)
 476 #define DBG_realloc(x,y) HeapRealloc(dbg_heap,0,x,y)
 477 #define DBG_free(x) HeapFree(dbg_heap,0,x)
 478 #define DBG_strdup(x) HEAP_strdupA(dbg_heap,0,x)
 479 #define DBG_need_heap
 480 extern HANDLE dbg_heap;
 481 #endif
 482
 483 #define DEBUG_STATUS_OFFSET             0x80003000
 484 #define DEBUG_STATUS_INTERNAL_ERROR     (DEBUG_STATUS_OFFSET+0)
 485 #define DEBUG_STATUS_NO_SYMBOL          (DEBUG_STATUS_OFFSET+1)
 486 #define DEBUG_STATUS_DIV_BY_ZERO        (DEBUG_STATUS_OFFSET+2)
 487 #define DEBUG_STATUS_BAD_TYPE           (DEBUG_STATUS_OFFSET+3)
 488
 489 extern DBG_INTVAR               DEBUG_IntVars[];
 490
 491 #define  DBG_IVARNAME(_var)     DEBUG_IV_##_var
 492 #define  DBG_IVARSTRUCT(_var)   DEBUG_IntVars[DBG_IVARNAME(_var)]
 493 #define  DBG_IVAR(_var)         (*(DBG_IVARSTRUCT(_var).pval))
 494 #define  INTERNAL_VAR(_var,_val,_ref,_typ) DBG_IVARNAME(_var),
 495 enum debug_int_var {
 496 #include "intvar.h"
 497    DBG_IV_LAST
 498 };
 499 #undef   INTERNAL_VAR
 500
 501 #endif  /* __WINE_DEBUGGER_H */