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

   1 /*
   2  * Debugger definitions
   3  *
   4  * Copyright 1995 Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #ifndef __WINE_DEBUGGER_H
  22 #define __WINE_DEBUGGER_H
  23
  24 #include <assert.h>
  25 #include <stdarg.h>
  26
  27 #define NONAMELESSUNION
  28 #define NONAMELESSSTRUCT
  29 #include "ntstatus.h"
  30 #define WIN32_NO_STATUS
  31 #define WIN32_LEAN_AND_MEAN
  32 #include "windef.h"
  33 #include "winbase.h"
  34 #include "winver.h"
  35 #include "winternl.h"
  36 #include "dbghelp.h"
  37 #include "cvconst.h"
  38 #include "objbase.h"
  39 #include "oaidl.h"
  40
  41 #define ADDRSIZE        ((unsigned)sizeof(void*))
  42 #define ADDRWIDTH       (ADDRSIZE * 2)
  43
  44 /* the debugger uses these exceptions for it's internal use */
  45 #define DEBUG_STATUS_OFFSET             0x80003000
  46 #define DEBUG_STATUS_INTERNAL_ERROR     (DEBUG_STATUS_OFFSET+0) /* something went wrong */
  47 #define DEBUG_STATUS_NO_SYMBOL          (DEBUG_STATUS_OFFSET+1) /* no symbol found in lookup */
  48 #define DEBUG_STATUS_DIV_BY_ZERO        (DEBUG_STATUS_OFFSET+2)
  49 #define DEBUG_STATUS_BAD_TYPE           (DEBUG_STATUS_OFFSET+3) /* no type found, when type was expected */
  50 #define DEBUG_STATUS_NO_FIELD           (DEBUG_STATUS_OFFSET+4) /* when dereferencing a struct, the field was not found */
  51 #define DEBUG_STATUS_ABORT              (DEBUG_STATUS_OFFSET+5) /* user aborted on going action */
  52 #define DEBUG_STATUS_CANT_DEREF         (DEBUG_STATUS_OFFSET+6) /* either not deref:able, or index out of bounds */
  53 #define DEBUG_STATUS_NOT_AN_INTEGER     (DEBUG_STATUS_OFFSET+7) /* requiring an integral value */
  54
  55 /*
  56  * Return values for symbol_get_function_line_status.  Used to determine
  57  * what to do when the 'step' command is given.
  58  */
  59 enum dbg_line_status
  60 {
  61     dbg_no_line_info,
  62     dbg_not_on_a_line_number,
  63     dbg_on_a_line_number,
  64     dbg_in_a_thunk,
  65 };
  66
  67 enum dbg_internal_types
  68 {
  69     dbg_itype_first             = 0xffffff00,
  70     dbg_itype_unsigned_int,
  71     dbg_itype_signed_int,
  72     dbg_itype_signed_char_int,
  73     dbg_itype_unsigned_char_int,
  74     dbg_itype_unsigned_short_int,
  75     dbg_itype_signed_short_int,
  76     dbg_itype_unsigned_long_int,
  77     dbg_itype_signed_long_int,
  78     dbg_itype_unsigned_longlong_int,
  79     dbg_itype_signed_longlong_int,
  80     dbg_itype_char,
  81     dbg_itype_wchar,
  82     dbg_itype_short_real, /* aka float */
  83     dbg_itype_real,       /* aka double */
  84     dbg_itype_long_real,  /* aka long double */
  85     dbg_itype_astring,
  86     dbg_itype_ustring,
  87     dbg_itype_segptr,     /* hack for segmented pointers */
  88     dbg_itype_none              = 0xffffffff
  89 };
  90
  91 /* type description (in the following order):
  92  * - if 'id' is dbg_itype_none (whatever 'module' value), the type isn't known
  93  * - if 'module' is 0, it's an internal type (id is one of dbg_itype...)
  94  * - if 'module' is non 0, then 'id' is a type ID referring to module (loaded in
  95  *   dbghelp) which (linear) contains address 'module'.
  96  */
  97 struct dbg_type
  98 {
  99     unsigned long       id;
 100     DWORD_PTR           module;
 101 };
 102
 103 struct dbg_lvalue       /* structure to hold left-values... */
 104 {
 105     int                 cookie; /* DLV_??? */
 106 /* DLV_TARGET references an address in debuggee's address space, whereas DLV_HOST
 107  * references the winedbg's address space
 108  */
 109 #       define  DLV_TARGET      0xF00D
 110 #       define  DLV_HOST        0x50DA
 111     ADDRESS64           addr;
 112     struct dbg_type     type;
 113 };
 114
 115 enum dbg_exec_mode
 116 {
 117     dbg_exec_cont,                      /* Continue execution */
 118     dbg_exec_step_over_line,            /* Stepping over a call to next source line */
 119     dbg_exec_step_into_line,            /* Step to next source line, stepping in if needed */
 120     dbg_exec_step_over_insn,            /* Stepping over a call */
 121     dbg_exec_step_into_insn,            /* Single-stepping an instruction */
 122     dbg_exec_finish,                    /* Single-step until we exit current frame */
 123 #if 0
 124     EXEC_STEP_OVER_TRAMPOLINE,  /* Step over trampoline.  Requires that we dig the real
 125                                  * return value off the stack and set breakpoint there -
 126                                  * not at the instr just after the call.
 127                                  */
 128 #endif
 129 };
 130
 131 struct dbg_breakpoint
 132 {
 133     ADDRESS64           addr;
 134     unsigned long       enabled : 1,
 135                         xpoint_type : 2,
 136                         refcount : 13,
 137                         skipcount : 16;
 138     unsigned long       info;
 139     struct              /* only used for watchpoints */
 140     {
 141         BYTE            len : 2;
 142         DWORD           oldval;
 143     } w;
 144     struct expr*        condition;
 145 };
 146
 147 /* used for C++ exceptions in msvcrt
 148  * parameters:
 149  * [0] CXX_FRAME_MAGIC
 150  * [1] pointer to exception object
 151  * [2] pointer to type
 152  */
 153 #define CXX_EXCEPTION                       0xe06d7363
 154 #define CXX_FRAME_MAGIC                     0x19930520
 155
 156 /* Wine extension; Windows doesn't have a name for this code.  This is an
 157    undocumented exception understood by MS VC debugger, allowing the program
 158    to name a particular thread.  Search google.com or deja.com for "0x406d1388"
 159    for more info. */
 160 #define EXCEPTION_NAME_THREAD               0x406D1388
 161
 162 /* Helper structure */
 163 typedef struct tagTHREADNAME_INFO
 164 {
 165    DWORD   dwType;     /* Must be 0x1000 */
 166    LPCSTR  szName;     /* Pointer to name - limited to 9 bytes (8 characters + terminator) */
 167    DWORD   dwThreadID; /* Thread ID (-1 = caller thread) */
 168    DWORD   dwFlags;    /* Reserved for future use.  Must be zero. */
 169 } THREADNAME_INFO;
 170
 171 struct dbg_thread
 172 {
 173     struct dbg_process*         process;
 174     HANDLE                      handle;
 175     DWORD                       tid;
 176     void*                       teb;
 177     enum dbg_exec_mode          exec_mode;      /* mode the thread is run (step/run...) */
 178     int                         exec_count;     /* count of mode operations */
 179     ADDRESS_MODE                addr_mode;      /* mode */
 180     int                         stopped_xpoint; /* xpoint on which the thread has stopped (-1 if none) */
 181     struct dbg_breakpoint       step_over_bp;
 182     char                        name[9];
 183     struct dbg_thread*          next;
 184     struct dbg_thread*          prev;
 185     BOOL                        in_exception;   /* TRUE if thread stopped with an exception */
 186     EXCEPTION_RECORD            excpt_record;   /* only valid when in_exception is TRUE */
 187     struct
 188     {
 189         ADDRESS64               addr_pc;
 190         ADDRESS64               addr_frame;
 191         ADDRESS64               addr_stack;
 192         DWORD_PTR               linear_pc;
 193         DWORD_PTR               linear_frame;
 194         DWORD_PTR               linear_stack;
 195         CONTEXT                 context;        /* context we got out of stackwalk for this frame */
 196         BOOL                    is_ctx_valid;   /* is the context above valid */
 197     }*                          frames;
 198     int                         num_frames;
 199     int                         curr_frame;
 200 };
 201
 202 struct dbg_delayed_bp
 203 {
 204     BOOL                        is_symbol;
 205     BOOL                        software_bp;
 206     union
 207     {
 208         struct
 209         {
 210             int                         lineno;
 211             char*                       name;
 212         } symbol;
 213         ADDRESS64               addr;
 214     } u;
 215 };
 216
 217 #define MAX_BREAKPOINTS 100
 218 struct dbg_process
 219 {
 220     HANDLE                      handle;
 221     DWORD                       pid;
 222     const struct be_process_io* process_io;
 223     void*                       pio_data;
 224     const WCHAR*                imageName;
 225     struct dbg_thread*          threads;
 226     unsigned                    continue_on_first_exception : 1,
 227                                 active_debuggee : 1;
 228     struct dbg_breakpoint       bp[MAX_BREAKPOINTS];
 229     unsigned                    next_bp;
 230     struct dbg_delayed_bp*      delayed_bp;
 231     int                         num_delayed_bp;
 232     struct open_file_list*      source_ofiles;
 233     char*                       search_path;
 234     char                        source_current_file[MAX_PATH];
 235     int                         source_start_line;
 236     int                         source_end_line;
 237     struct dbg_process*         next;
 238     struct dbg_process*         prev;
 239 };
 240
 241 /* describes the way the debugger interacts with a given process */
 242 struct be_process_io
 243 {
 244     BOOL        (*close_process)(struct dbg_process*, BOOL);
 245     BOOL        (*read)(HANDLE, const void*, void*, SIZE_T, SIZE_T*);
 246     BOOL        (*write)(HANDLE, void*, const void*, SIZE_T, SIZE_T*);
 247     BOOL        (*get_selector)(HANDLE, DWORD, LDT_ENTRY*);
 248 };
 249
 250 extern  struct dbg_process*     dbg_curr_process;
 251 extern  DWORD_PTR               dbg_curr_pid;
 252 extern  struct dbg_thread*      dbg_curr_thread;
 253 extern  DWORD_PTR               dbg_curr_tid;
 254 extern  CONTEXT                 dbg_context;
 255 extern  BOOL                    dbg_interactiveP;
 256
 257 struct dbg_internal_var
 258 {
 259     DWORD_PTR                   val;
 260     const char*                 name;
 261     DWORD_PTR                   *pval;
 262     unsigned long               typeid; /* always internal type */
 263 };
 264
 265 enum sym_get_lval {sglv_found, sglv_unknown, sglv_aborted};
 266
 267 enum type_expr_e
 268 {
 269     type_expr_type_id,
 270     type_expr_udt_class,
 271     type_expr_udt_struct,
 272     type_expr_udt_union,
 273     type_expr_enumeration
 274 };
 275
 276 struct type_expr_t
 277 {
 278     enum type_expr_e    type;
 279     unsigned            deref_count;
 280     union
 281     {
 282         struct dbg_type type;
 283         const char*     name;
 284     } u;
 285 };
 286
 287 enum dbg_start {start_ok, start_error_parse, start_error_init};
 288
 289   /* break.c */
 290 extern void             break_set_xpoints(BOOL set);
 291 extern BOOL             break_add_break(const ADDRESS64* addr, BOOL verbose, BOOL swbp);
 292 extern BOOL             break_add_break_from_lvalue(const struct dbg_lvalue* value, BOOL swbp);
 293 extern void             break_add_break_from_id(const char* name, int lineno, BOOL swbp);
 294 extern void             break_add_break_from_lineno(int lineno, BOOL swbp);
 295 extern void             break_add_watch_from_lvalue(const struct dbg_lvalue* lvalue);
 296 extern void             break_add_watch_from_id(const char* name);
 297 extern void             break_check_delayed_bp(void);
 298 extern void             break_delete_xpoint(int num);
 299 extern void             break_delete_xpoints_from_module(DWORD64 base);
 300 extern void             break_enable_xpoint(int num, BOOL enable);
 301 extern void             break_info(void);
 302 extern void             break_adjust_pc(ADDRESS64* addr, DWORD code, BOOL first_chance, BOOL* is_break);
 303 extern BOOL             break_should_continue(ADDRESS64* addr, DWORD code);
 304 extern void             break_suspend_execution(void);
 305 extern void             break_restart_execution(int count);
 306 extern int              break_add_condition(int bpnum, struct expr* exp);
 307
 308   /* crashdlg.c */
 309 extern BOOL             display_crash_dialog(void);
 310 extern int              msgbox_res_id(HWND hwnd, UINT textId, UINT captionId, UINT uType);
 311
 312   /* dbg.y */
 313 extern void             parser_handle(HANDLE);
 314 extern int              input_read_line(const char* pfx, char* buffer, int size);
 315 extern int              input_fetch_entire_line(const char* pfx, char** line);
 316 extern HANDLE           parser_generate_command_file(const char*, ...);
 317
 318   /* debug.l */
 319 extern void             lexeme_flush(void);
 320 extern char*            lexeme_alloc_size(int);
 321
 322   /* display.c */
 323 extern int              display_print(void);
 324 extern int              display_add(struct expr* exp, int count, char format);
 325 extern int              display_delete(int displaynum);
 326 extern int              display_info(void);
 327 extern int              display_enable(int displaynum, int enable);
 328
 329   /* expr.c */
 330 extern void             expr_free_all(void);
 331 extern struct expr*     expr_alloc_internal_var(const char* name);
 332 extern struct expr*     expr_alloc_symbol(const char* name);
 333 extern struct expr*     expr_alloc_sconstant(long int val);
 334 extern struct expr*     expr_alloc_uconstant(long unsigned val);
 335 extern struct expr*     expr_alloc_string(const char* str);
 336 extern struct expr*     expr_alloc_binary_op(int oper, struct expr*, struct expr*);
 337 extern struct expr*     expr_alloc_unary_op(int oper, struct expr*);
 338 extern struct expr*     expr_alloc_pstruct(struct expr*, const char* element);
 339 extern struct expr*     expr_alloc_struct(struct expr*, const char* element);
 340 extern struct expr*     expr_alloc_func_call(const char*, int nargs, ...);
 341 extern struct expr*     expr_alloc_typecast(struct type_expr_t*, struct expr*);
 342 extern struct dbg_lvalue expr_eval(struct expr*);
 343 extern struct expr*     expr_clone(const struct expr* exp, BOOL *local_binding);
 344 extern int              expr_free(struct expr* exp);
 345 extern int              expr_print(const struct expr* exp);
 346
 347   /* info.c */
 348 extern void             print_help(void);
 349 extern void             info_help(void);
 350 extern void             info_win32_module(DWORD64 mod);
 351 extern void             info_win32_class(HWND hWnd, const char* clsName);
 352 extern void             info_win32_window(HWND hWnd, BOOL detailed);
 353 extern void             info_win32_processes(void);
 354 extern void             info_win32_threads(void);
 355 extern void             info_win32_exceptions(DWORD tid);
 356 extern void             info_win32_virtual(DWORD pid);
 357 extern void             info_win32_segments(DWORD start, int length);
 358 extern void             info_wine_dbg_channel(BOOL add, const char* chnl, const char* name);
 359
 360   /* memory.c */
 361 extern BOOL             memory_read_value(const struct dbg_lvalue* lvalue, DWORD size, void* result);
 362 extern BOOL             memory_write_value(const struct dbg_lvalue* val, DWORD size, void* value);
 363 extern void             memory_examine(const struct dbg_lvalue *lvalue, int count, char format);
 364 extern void*            memory_to_linear_addr(const ADDRESS64* address);
 365 extern BOOL             memory_get_current_pc(ADDRESS64* address);
 366 extern BOOL             memory_get_current_stack(ADDRESS64* address);
 367 extern BOOL             memory_get_current_frame(ADDRESS64* address);
 368 extern BOOL             memory_get_string(struct dbg_process* pcs, void* addr, BOOL in_debuggee, BOOL unicode, char* buffer, int size);
 369 extern BOOL             memory_get_string_indirect(struct dbg_process* pcs, void* addr, BOOL unicode, WCHAR* buffer, int size);
 370 extern BOOL             memory_get_register(DWORD regno, DWORD_PTR** value, char* buffer, int len);
 371 extern void             memory_disassemble(const struct dbg_lvalue*, const struct dbg_lvalue*, int instruction_count);
 372 extern BOOL             memory_disasm_one_insn(ADDRESS64* addr);
 373 #define MAX_OFFSET_TO_STR_LEN 19
 374 extern char*            memory_offset_to_string(char *str, DWORD64 offset, unsigned mode);
 375 extern void             print_bare_address(const ADDRESS64* addr);
 376 extern void             print_address(const ADDRESS64* addr, BOOLEAN with_line);
 377 extern void             print_basic(const struct dbg_lvalue* value, char format);
 378
 379   /* source.c */
 380 extern void             source_list(IMAGEHLP_LINE64* src1, IMAGEHLP_LINE64* src2, int delta);
 381 extern void             source_list_from_addr(const ADDRESS64* addr, int nlines);
 382 extern void             source_show_path(void);
 383 extern void             source_add_path(const char* path);
 384 extern void             source_nuke_path(struct dbg_process* p);
 385 extern void             source_free_files(struct dbg_process* p);
 386
 387   /* stack.c */
 388 extern void             stack_info(void);
 389 extern void             stack_backtrace(DWORD threadID);
 390 extern BOOL             stack_set_frame(int newframe);
 391 extern BOOL             stack_get_current_frame(IMAGEHLP_STACK_FRAME* ihsf);
 392 extern BOOL             stack_get_register_frame(const struct dbg_internal_var* div, DWORD_PTR** pval);
 393 extern unsigned         stack_fetch_frames(const CONTEXT* ctx);
 394 extern BOOL             stack_get_current_symbol(SYMBOL_INFO* sym);
 395
 396   /* symbol.c */
 397 extern enum sym_get_lval symbol_get_lvalue(const char* name, const int lineno, struct dbg_lvalue* addr, BOOL bp_disp);
 398 extern void             symbol_read_symtable(const char* filename, unsigned long offset);
 399 extern enum dbg_line_status symbol_get_function_line_status(const ADDRESS64* addr);
 400 extern BOOL             symbol_get_line(const char* filename, const char* func, IMAGEHLP_LINE64* ret);
 401 extern void             symbol_info(const char* str);
 402 extern void             symbol_print_local(const SYMBOL_INFO* sym, DWORD_PTR base, BOOL detailed);
 403 extern int              symbol_info_locals(void);
 404 extern BOOL             symbol_is_local(const char* name);
 405 struct sgv_data;
 406 typedef enum sym_get_lval (*symbol_picker_t)(const char* name, const struct sgv_data* sgv,
 407                                              struct dbg_lvalue* rtn);
 408 extern symbol_picker_t symbol_current_picker;
 409 extern enum sym_get_lval symbol_picker_interactive(const char* name, const struct sgv_data* sgv,
 410                                                    struct dbg_lvalue* rtn);
 411 extern enum sym_get_lval symbol_picker_scoped(const char* name, const struct sgv_data* sgv,
 412                                               struct dbg_lvalue* rtn);
 413
 414   /* tgt_active.c */
 415 extern void             dbg_run_debuggee(const char* args);
 416 extern void             dbg_wait_next_exception(DWORD cont, int count, int mode);
 417 extern enum dbg_start   dbg_active_attach(int argc, char* argv[]);
 418 extern enum dbg_start   dbg_active_launch(int argc, char* argv[]);
 419 extern enum dbg_start   dbg_active_auto(int argc, char* argv[]);
 420 extern void             dbg_active_wait_for_first_exception(void);
 421 extern BOOL             dbg_attach_debuggee(DWORD pid, BOOL cofe);
 422
 423   /* tgt_minidump.c */
 424 extern void             minidump_write(const char*, const EXCEPTION_RECORD*);
 425 extern enum dbg_start   minidump_reload(int argc, char* argv[]);
 426
 427   /* tgt_module.c */
 428 extern enum dbg_start   tgt_module_load(const char* name, BOOL keep);
 429
 430   /* types.c */
 431 extern void             print_value(const struct dbg_lvalue* addr, char format, int level);
 432 extern int              types_print_type(const struct dbg_type*, BOOL details);
 433 extern int              print_types(void);
 434 extern long int         types_extract_as_integer(const struct dbg_lvalue*);
 435 extern LONGLONG         types_extract_as_longlong(const struct dbg_lvalue*, unsigned* psize);
 436 extern void             types_extract_as_address(const struct dbg_lvalue*, ADDRESS64*);
 437 extern BOOL             types_deref(const struct dbg_lvalue* value, struct dbg_lvalue* result);
 438 extern BOOL             types_udt_find_element(struct dbg_lvalue* value, const char* name, long int* tmpbuf);
 439 extern BOOL             types_array_index(const struct dbg_lvalue* value, int index, struct dbg_lvalue* result);
 440 extern BOOL             types_get_info(const struct dbg_type*, IMAGEHLP_SYMBOL_TYPE_INFO, void*);
 441 extern BOOL             types_get_real_type(struct dbg_type* type, DWORD* tag);
 442 extern struct dbg_type  types_find_pointer(const struct dbg_type* type);
 443 extern struct dbg_type  types_find_type(unsigned long linear, const char* name, enum SymTagEnum tag);
 444
 445   /* winedbg.c */
 446 extern void             dbg_outputW(const WCHAR* buffer, int len);
 447 extern const char*      dbg_W2A(const WCHAR* buffer, unsigned len);
 448 #ifdef __GNUC__
 449 extern int              dbg_printf(const char* format, ...) __attribute__((format (printf,1,2)));
 450 #else
 451 extern int              dbg_printf(const char* format, ...);
 452 #endif
 453 extern const struct dbg_internal_var* dbg_get_internal_var(const char*);
 454 extern BOOL             dbg_interrupt_debuggee(void);
 455 extern unsigned         dbg_num_processes(void);
 456 extern struct dbg_process* dbg_add_process(const struct be_process_io* pio, DWORD pid, HANDLE h);
 457 extern void             dbg_set_process_name(struct dbg_process* p, const WCHAR* name);
 458 extern struct dbg_process* dbg_get_process(DWORD pid);
 459 extern struct dbg_process* dbg_get_process_h(HANDLE handle);
 460 extern void             dbg_del_process(struct dbg_process* p);
 461 struct dbg_thread*      dbg_add_thread(struct dbg_process* p, DWORD tid, HANDLE h, void* teb);
 462 extern struct dbg_thread* dbg_get_thread(struct dbg_process* p, DWORD tid);
 463 extern void             dbg_del_thread(struct dbg_thread* t);
 464 extern BOOL             dbg_init(HANDLE hProc, const WCHAR* in, BOOL invade);
 465 extern BOOL             dbg_load_module(HANDLE hProc, HANDLE hFile, const WCHAR* name, DWORD_PTR base, DWORD size);
 466 extern BOOL             dbg_get_debuggee_info(HANDLE hProcess, IMAGEHLP_MODULE64* imh_mod);
 467 extern void             dbg_set_option(const char*, const char*);
 468 extern void             dbg_start_interactive(HANDLE hFile);
 469 extern void             dbg_init_console(void);
 470
 471   /* gdbproxy.c */
 472 extern int              gdb_main(int argc, char* argv[]);
 473
 474 static inline BOOL dbg_read_memory(const void* addr, void* buffer, size_t len)
 475 {
 476     SIZE_T rlen;
 477     return dbg_curr_process->process_io->read(dbg_curr_process->handle, addr, buffer, len, &rlen) && len == rlen;
 478 }
 479
 480 static inline BOOL dbg_write_memory(void* addr, const void* buffer, size_t len)
 481 {
 482     SIZE_T wlen;
 483     return dbg_curr_process->process_io->write(dbg_curr_process->handle, addr, buffer, len, &wlen) && len == wlen;
 484 }
 485
 486 static inline void* dbg_heap_realloc(void* buffer, size_t size)
 487 {
 488     return (buffer) ? HeapReAlloc(GetProcessHeap(), 0, buffer, size) :
 489         HeapAlloc(GetProcessHeap(), 0, size);
 490 }
 491
 492 extern struct dbg_internal_var          dbg_internal_vars[];
 493
 494 #define  DBG_IVARNAME(_var)     dbg_internal_var_##_var
 495 #define  DBG_IVARSTRUCT(_var)   dbg_internal_vars[DBG_IVARNAME(_var)]
 496 #define  DBG_IVAR(_var)         (*(DBG_IVARSTRUCT(_var).pval))
 497 #define  INTERNAL_VAR(_var,_val,_ref,itype) DBG_IVARNAME(_var),
 498 enum debug_int_var
 499 {
 500 #include "intvar.h"
 501    DBG_IV_LAST
 502 };
 503 #undef   INTERNAL_VAR
 504
 505 /* include CPU dependent bits */
 506 #include "be_cpu.h"
 507
 508 #endif  /* __WINE_DEBUGGER_H */