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 #include "ntstatus.h"
  28 #define WIN32_NO_STATUS
  29 #define WIN32_LEAN_AND_MEAN
  30 #include "windef.h"
  31 #include "winbase.h"
  32 #include "winver.h"
  33 #include "winternl.h"
  34 #include "dbghelp.h"
  35 #include "cvconst.h"
  36 #include "objbase.h"
  37 #include "oaidl.h"
  38 #include <wine/list.h>
  39
  40 #define ADDRSIZE        ((int)(dbg_curr_process ? dbg_curr_process->be_cpu->pointer_size : sizeof(void*)))
  41 #define ADDRWIDTH       (ADDRSIZE * 2)
  42
  43 /* the debugger uses these exceptions for its internal use */
  44 #define DEBUG_STATUS_OFFSET             0x80003000
  45 #define DEBUG_STATUS_INTERNAL_ERROR     (DEBUG_STATUS_OFFSET+0) /* something went wrong */
  46 #define DEBUG_STATUS_NO_SYMBOL          (DEBUG_STATUS_OFFSET+1) /* no symbol found in lookup */
  47 #define DEBUG_STATUS_DIV_BY_ZERO        (DEBUG_STATUS_OFFSET+2)
  48 #define DEBUG_STATUS_BAD_TYPE           (DEBUG_STATUS_OFFSET+3) /* no type found, when type was expected */
  49 #define DEBUG_STATUS_NO_FIELD           (DEBUG_STATUS_OFFSET+4) /* when dereferencing a struct, the field was not found */
  50 #define DEBUG_STATUS_ABORT              (DEBUG_STATUS_OFFSET+5) /* user aborted on going action */
  51 #define DEBUG_STATUS_CANT_DEREF         (DEBUG_STATUS_OFFSET+6) /* either not deref:able, or index out of bounds */
  52 #define DEBUG_STATUS_NOT_AN_INTEGER     (DEBUG_STATUS_OFFSET+7) /* requiring an integral value */
  53
  54 /*
  55  * Return values for symbol_get_function_line_status.  Used to determine
  56  * what to do when the 'step' command is given.
  57  */
  58 enum dbg_line_status
  59 {
  60     dbg_no_line_info,
  61     dbg_not_on_a_line_number,
  62     dbg_on_a_line_number,
  63     dbg_in_a_thunk,
  64 };
  65
  66 enum dbg_internal_types
  67 {
  68     /* types that we synthetize inside the debugger */
  69     dbg_itype_synthetized       = 0xf0000000,
  70     /* order here must match types.c:basic_types_details table */
  71     dbg_itype_first             = 0xffffff00,
  72     dbg_itype_void              = dbg_itype_first,
  73     dbg_itype_bool,
  74     dbg_itype_char,
  75     dbg_itype_wchar,
  76     dbg_itype_char8,
  77     dbg_itype_char16,
  78     dbg_itype_char32,
  79
  80     dbg_itype_unsigned_int8,
  81     dbg_itype_unsigned_int16,
  82     dbg_itype_unsigned_int32,
  83     dbg_itype_unsigned_int64,
  84     dbg_itype_unsigned_int128,
  85     dbg_itype_unsigned_long32,
  86     dbg_itype_unsigned_long64,
  87
  88     dbg_itype_signed_int8,
  89     dbg_itype_signed_int16,
  90     dbg_itype_signed_int32,
  91     dbg_itype_signed_int64,
  92     dbg_itype_signed_int128,
  93     dbg_itype_signed_long32,
  94     dbg_itype_signed_long64,
  95
  96     dbg_itype_short_real, /* aka float */
  97     dbg_itype_real,       /* aka double */
  98     dbg_itype_long_real,  /* aka long double */
  99
 100     dbg_itype_last,
 101
 102     /* they represent the dbg_lg(u)int_t types */
 103     dbg_itype_lgint,
 104     dbg_itype_lguint,
 105
 106     dbg_itype_astring,
 107     dbg_itype_ustring,
 108     dbg_itype_segptr,     /* hack for segmented pointers */
 109     dbg_itype_m128a,      /* 128-bit (XMM) registers */
 110     dbg_itype_none              = 0xffffffff
 111 };
 112
 113 /* Largest integers the debugger's compiler can support.
 114  * It's large enough to store a pointer (in debuggee or debugger's address space).
 115  * It can be smaller than the largest integer(s) of the debuggee.
 116  * (eg. 64 bit on PE build of debugger, vs 128 int in ELF build of a library)
 117  */
 118 typedef LONG64  dbg_lgint_t;
 119 typedef ULONG64 dbg_lguint_t;
 120
 121 /* type description (in the following order):
 122  * - if 'id' is dbg_itype_none (whatever 'module' value), the type isn't known
 123  * - if 'module' is 0, it's an internal type (id is one of dbg_itype...)
 124  * - if 'module' is non 0, then 'id' is a type ID referring to module (loaded in
 125  *   dbghelp) which (linear) contains address 'module'.
 126  */
 127 struct dbg_type
 128 {
 129     ULONG               id;
 130     DWORD_PTR           module;
 131 };
 132
 133 struct dbg_lvalue       /* structure to hold left-values... */
 134 {
 135     unsigned            in_debuggee : 1, /* 1 = debuggee address space, 0 = debugger address space */
 136                         bitstart : 8, /* in fact, 7 should be sufficient for underlying 128bit integers */
 137                         bitlen;
 138     ADDRESS64           addr;
 139     struct dbg_type     type;
 140 };
 141
 142 static inline void init_lvalue(struct dbg_lvalue* lv, BOOL in_debuggee, void* addr)
 143 {
 144     lv->in_debuggee = !!in_debuggee;
 145     lv->bitstart = 0;
 146     lv->bitlen = 0;
 147     lv->addr.Mode = AddrModeFlat;
 148     lv->addr.Offset = (DWORD_PTR)addr;
 149     lv->type.module = 0;
 150     lv->type.id = dbg_itype_none;
 151 }
 152
 153 static inline void init_lvalue_in_debugger(struct dbg_lvalue* lv, DWORD_PTR module,
 154                                            enum dbg_internal_types it, void* addr)
 155 {
 156     lv->in_debuggee = 0;
 157     lv->bitstart = 0;
 158     lv->bitlen = 0;
 159     lv->addr.Mode = AddrModeFlat;
 160     lv->addr.Offset = (DWORD_PTR)addr;
 161     lv->type.module = module;
 162     lv->type.id = it;
 163 }
 164
 165 enum dbg_exec_mode
 166 {
 167     dbg_exec_cont,                      /* Continue execution */
 168     dbg_exec_step_over_line,            /* Stepping over a call to next source line */
 169     dbg_exec_step_into_line,            /* Step to next source line, stepping in if needed */
 170     dbg_exec_step_over_insn,            /* Stepping over a call */
 171     dbg_exec_step_into_insn,            /* Single-stepping an instruction */
 172     dbg_exec_finish,                    /* Single-step until we exit current frame */
 173 #if 0
 174     EXEC_STEP_OVER_TRAMPOLINE,  /* Step over trampoline.  Requires that we dig the real
 175                                  * return value off the stack and set breakpoint there -
 176                                  * not at the instr just after the call.
 177                                  */
 178 #endif
 179 };
 180
 181 struct dbg_breakpoint
 182 {
 183     ADDRESS64           addr;
 184     unsigned int        enabled : 1,
 185                         xpoint_type : 2,
 186                         refcount : 13,
 187                         skipcount : 16;
 188     unsigned int        info;
 189     struct              /* only used for watchpoints */
 190     {
 191         BYTE            len : 2;
 192         DWORD64         oldval;
 193     } w;
 194     struct expr*        condition;
 195 };
 196
 197 /* Helper structure */
 198 typedef struct tagTHREADNAME_INFO
 199 {
 200    DWORD   dwType;     /* Must be 0x1000 */
 201    LPCSTR  szName;     /* Pointer to name - limited to 9 bytes (8 characters + terminator) */
 202    DWORD   dwThreadID; /* Thread ID (-1 = caller thread) */
 203    DWORD   dwFlags;    /* Reserved for future use.  Must be zero. */
 204 } THREADNAME_INFO;
 205
 206 typedef union dbg_ctx
 207 {
 208     CONTEXT ctx;
 209     WOW64_CONTEXT x86;
 210 } dbg_ctx_t;
 211
 212 struct dbg_thread
 213 {
 214     struct list                 entry;
 215     struct dbg_process*         process;
 216     HANDLE                      handle;
 217     DWORD                       tid;
 218     void*                       teb;
 219     enum dbg_exec_mode          exec_mode;      /* mode the thread is run (step/run...) */
 220     int                         exec_count;     /* count of mode operations */
 221     ADDRESS_MODE                addr_mode;      /* mode */
 222     int                         stopped_xpoint; /* xpoint on which the thread has stopped (-1 if none) */
 223     struct dbg_breakpoint       step_over_bp;
 224     char                        name[9];
 225     BOOL                        in_exception;   /* TRUE if thread stopped with an exception */
 226     BOOL                        first_chance;   /* TRUE if thread stopped with a first chance exception
 227                                                  *      - only valid when in_exception is TRUE
 228                                                  */
 229     EXCEPTION_RECORD            excpt_record;   /* only valid when in_exception is TRUE */
 230     struct dbg_frame
 231     {
 232         ADDRESS64               addr_pc;
 233         ADDRESS64               addr_frame;
 234         ADDRESS64               addr_stack;
 235         DWORD_PTR               linear_pc;
 236         DWORD_PTR               linear_frame;
 237         DWORD_PTR               linear_stack;
 238         dbg_ctx_t               context;        /* context we got out of stackwalk for this frame */
 239         DWORD                   inline_ctx;
 240         BOOL                    is_ctx_valid;   /* is the context above valid */
 241     }*                          frames;
 242     int                         num_frames;
 243     int                         curr_frame;
 244     BOOL                        suspended;
 245 };
 246
 247 struct dbg_module
 248 {
 249     struct list                 entry;
 250     DWORD_PTR                   base;
 251     DWORD_PTR                   tls_index_offset;
 252 };
 253
 254 struct dbg_delayed_bp
 255 {
 256     BOOL                        is_symbol;
 257     BOOL                        software_bp;
 258     union
 259     {
 260         struct
 261         {
 262             int                         lineno;
 263             char*                       name;
 264         } symbol;
 265         ADDRESS64               addr;
 266     } u;
 267 };
 268
 269 #define MAX_BREAKPOINTS 100
 270 struct dbg_process
 271 {
 272     struct list                 entry;
 273     HANDLE                      handle;
 274     DWORD                       pid;
 275     const struct be_process_io* process_io;
 276     void*                       pio_data;
 277     const WCHAR*                imageName;
 278     struct list                 threads;
 279     struct list                 modules;
 280     struct backend_cpu*         be_cpu;
 281     HANDLE                      event_on_first_exception;
 282     BOOL                        active_debuggee;
 283     BOOL                        is_wow64;
 284     struct dbg_breakpoint       bp[MAX_BREAKPOINTS];
 285     unsigned                    next_bp;
 286     struct dbg_delayed_bp*      delayed_bp;
 287     int                         num_delayed_bp;
 288     struct open_file_list*      source_ofiles;
 289     char*                       search_path;
 290     char                        source_current_file[MAX_PATH];
 291     int                         source_start_line;
 292     int                         source_end_line;
 293     const struct data_model*    data_model;
 294     struct dbg_type*            synthetized_types;
 295     unsigned                    num_synthetized_types;
 296 };
 297
 298 /* describes the way the debugger interacts with a given process */
 299 struct be_process_io
 300 {
 301     BOOL        (*close_process)(struct dbg_process*, BOOL);
 302     BOOL        (*read)(HANDLE, const void*, void*, SIZE_T, SIZE_T*);
 303     BOOL        (*write)(HANDLE, void*, const void*, SIZE_T, SIZE_T*);
 304     BOOL        (*get_selector)(HANDLE, DWORD, LDT_ENTRY*);
 305 };
 306
 307 extern  struct dbg_process*     dbg_curr_process;
 308 extern  DWORD                   dbg_curr_pid;
 309 extern  struct dbg_thread*      dbg_curr_thread;
 310 extern  DWORD                   dbg_curr_tid;
 311 extern  dbg_ctx_t               dbg_context;
 312 extern  BOOL                    dbg_interactiveP;
 313 extern  HANDLE                  dbg_houtput;
 314
 315 struct dbg_internal_var
 316 {
 317     DWORD                       val;
 318     const char*                 name;
 319     void*                       pval;
 320     ULONG                       typeid; /* always internal type */
 321 };
 322
 323 enum sym_get_lval {sglv_found, sglv_unknown, sglv_aborted};
 324
 325 enum dbg_start {start_ok, start_error_parse, start_error_init};
 326
 327   /* break.c */
 328 extern void             break_set_xpoints(BOOL set);
 329 extern BOOL             break_add_break(const ADDRESS64* addr, BOOL verbose, BOOL swbp);
 330 extern BOOL             break_add_break_from_lvalue(const struct dbg_lvalue* value, BOOL swbp);
 331 extern void             break_add_break_from_id(const char* name, int lineno, BOOL swbp);
 332 extern void             break_add_break_from_lineno(const char *filename, int lineno, BOOL swbp);
 333 extern void             break_add_watch(const struct dbg_lvalue* value, BOOL is_write);
 334 extern void             break_check_delayed_bp(void);
 335 extern void             break_delete_xpoint(int num);
 336 extern void             break_delete_xpoints_from_module(DWORD64 base);
 337 extern void             break_enable_xpoint(int num, BOOL enable);
 338 extern void             break_info(void);
 339 extern void             break_adjust_pc(ADDRESS64* addr, DWORD code, BOOL first_chance, BOOL* is_break);
 340 extern BOOL             break_should_continue(ADDRESS64* addr, DWORD code);
 341 extern void             break_suspend_execution(void);
 342 extern void             break_restart_execution(int count);
 343 extern int              break_add_condition(int bpnum, struct expr* exp);
 344
 345   /* crashdlg.c */
 346 extern int              display_crash_dialog(void);
 347 extern HANDLE           display_crash_details(HANDLE event);
 348 extern int              msgbox_res_id(HWND hwnd, UINT textId, UINT captionId, UINT uType);
 349
 350   /* dbg.y */
 351 extern void             parser_handle(const char*, HANDLE);
 352 extern int              input_read_line(const char* pfx, char* buffer, int size);
 353 extern size_t           input_lex_read_buffer(char* pfx, int size);
 354 extern HANDLE           WINAPIV parser_generate_command_file(const char*, ...);
 355
 356   /* debug.l */
 357 extern void             lexeme_flush(void);
 358 extern char*            lexeme_alloc_size(int);
 359
 360   /* display.c */
 361 extern BOOL             display_print(void);
 362 extern BOOL             display_add(struct expr* exp, int count, char format);
 363 extern BOOL             display_delete(int displaynum);
 364 extern BOOL             display_info(void);
 365 extern BOOL             display_enable(int displaynum, int enable);
 366
 367   /* expr.c */
 368 extern void             expr_free_all(void);
 369 extern struct expr*     expr_alloc_internal_var(const char* name);
 370 extern struct expr*     expr_alloc_symbol(const char* name);
 371 extern struct expr*     expr_alloc_sconstant(dbg_lgint_t val);
 372 extern struct expr*     expr_alloc_uconstant(dbg_lguint_t val);
 373 extern struct expr*     expr_alloc_string(const char* str);
 374 extern struct expr*     expr_alloc_binary_op(int oper, struct expr*, struct expr*);
 375 extern struct expr*     expr_alloc_unary_op(int oper, struct expr*);
 376 extern struct expr*     expr_alloc_pstruct(struct expr*, const char* element);
 377 extern struct expr*     expr_alloc_struct(struct expr*, const char* element);
 378 extern struct expr*     WINAPIV expr_alloc_func_call(const char*, int nargs, ...);
 379 extern struct expr*     expr_alloc_typecast(struct dbg_type*, struct expr*);
 380 extern struct dbg_lvalue expr_eval(struct expr*);
 381 extern struct expr*     expr_clone(const struct expr* exp, BOOL *local_binding);
 382 extern BOOL             expr_free(struct expr* exp);
 383 extern BOOL             expr_print(const struct expr* exp);
 384
 385   /* info.c */
 386 extern void             print_help(void);
 387 extern void             info_help(void);
 388 extern void             info_win32_module(DWORD64 mod, BOOL multi_machine);
 389 extern void             info_win32_class(HWND hWnd, const char* clsName);
 390 extern void             info_win32_window(HWND hWnd, BOOL detailed);
 391 extern void             info_win32_processes(void);
 392 extern void             info_win32_threads(void);
 393 extern void             info_win32_frame_exceptions(DWORD tid);
 394 extern void             info_win32_virtual(DWORD pid);
 395 extern void             info_win32_segments(DWORD start, int length);
 396 extern void             info_win32_exception(void);
 397 extern void             info_win32_system(void);
 398 extern void             info_wine_dbg_channel(BOOL add, const char* chnl, const char* name);
 399 extern WCHAR*           fetch_thread_description(DWORD tid);
 400
 401   /* memory.c */
 402 extern BOOL             memory_read_value(const struct dbg_lvalue* lvalue, DWORD size, void* result);
 403 extern BOOL             memory_write_value(const struct dbg_lvalue* val, DWORD size, void* value);
 404 extern BOOL             memory_transfer_value(const struct dbg_lvalue* to, const struct dbg_lvalue* from);
 405 extern BOOL             memory_fetch_integer(const struct dbg_lvalue* lvalue, unsigned size,
 406                                              BOOL is_signed, dbg_lgint_t* ret);
 407 extern BOOL             memory_store_integer(const struct dbg_lvalue* lvalue, dbg_lgint_t val);
 408 extern BOOL             memory_fetch_float(const struct dbg_lvalue* lvalue, double *ret);
 409 extern BOOL             memory_store_float(const struct dbg_lvalue* lvalue, double *ret);
 410 extern void             memory_examine(const struct dbg_lvalue *lvalue, int count, char format);
 411 extern void*            memory_to_linear_addr(const ADDRESS64* address);
 412 extern BOOL             memory_get_current_pc(ADDRESS64* address);
 413 extern BOOL             memory_get_current_stack(ADDRESS64* address);
 414 extern BOOL             memory_get_string(struct dbg_process* pcs, void* addr, BOOL in_debuggee, BOOL unicode, char* buffer, int size);
 415 extern BOOL             memory_get_string_indirect(struct dbg_process* pcs, void* addr, BOOL unicode, WCHAR* buffer, int size);
 416 extern BOOL             memory_get_register(DWORD regno, struct dbg_lvalue* value, char* buffer, int len);
 417 extern void             memory_disassemble(const struct dbg_lvalue*, const struct dbg_lvalue*, int instruction_count);
 418 extern void             memory_disasm_one_x86_insn(ADDRESS64 *addr, int display);
 419 extern BOOL             memory_disasm_one_insn(ADDRESS64* addr);
 420 #define MAX_OFFSET_TO_STR_LEN 19
 421 extern char*            memory_offset_to_string(char *str, DWORD64 offset, unsigned mode);
 422 extern void             print_bare_address(const ADDRESS64* addr);
 423 extern void             print_address(const ADDRESS64* addr, BOOLEAN with_line);
 424 extern void             print_basic(const struct dbg_lvalue* value, char format);
 425
 426   /* source.c */
 427 extern void             source_list(IMAGEHLP_LINE64* src1, IMAGEHLP_LINE64* src2, int delta);
 428 extern void             source_list_from_addr(const ADDRESS64* addr, int nlines);
 429 extern void             source_show_path(void);
 430 extern void             source_add_path(const char* path);
 431 extern void             source_nuke_path(struct dbg_process* p);
 432 extern void             source_free_files(struct dbg_process* p);
 433
 434   /* stack.c */
 435 extern void             stack_info(int len);
 436 extern void             stack_backtrace(DWORD threadID);
 437 extern BOOL             stack_set_frame(int newframe);
 438 extern BOOL             stack_get_register_frame(const struct dbg_internal_var* div, struct dbg_lvalue* lvalue);
 439 extern unsigned         stack_fetch_frames(const dbg_ctx_t *ctx);
 440 extern BOOL             stack_get_current_symbol(SYMBOL_INFO* sym);
 441 static inline struct dbg_frame*
 442                         stack_get_thread_frame(struct dbg_thread* thd, unsigned nf)
 443 {
 444     if (!thd->frames || nf >= thd->num_frames) return NULL;
 445     return &thd->frames[nf];
 446 }
 447 static inline struct dbg_frame*
 448                         stack_get_curr_frame(void)
 449 {
 450     return stack_get_thread_frame(dbg_curr_thread, dbg_curr_thread->curr_frame);
 451 }
 452
 453   /* symbol.c */
 454 extern enum sym_get_lval symbol_get_lvalue(const char* name, const int lineno, struct dbg_lvalue* addr, BOOL bp_disp);
 455 extern void             symbol_read_symtable(const char* filename, ULONG_PTR offset);
 456 extern enum dbg_line_status symbol_get_function_line_status(const ADDRESS64* addr);
 457 extern BOOL             symbol_get_line(const char* filename, const char* func, IMAGEHLP_LINE64* ret);
 458 extern void             symbol_info(const char* str);
 459 extern void             symbol_print_localvalue(const SYMBOL_INFO* sym, DWORD_PTR base, BOOL detailed);
 460 extern BOOL             symbol_info_locals(void);
 461 extern BOOL             symbol_is_local(const char* name);
 462 struct sgv_data;
 463 typedef enum sym_get_lval (*symbol_picker_t)(const char* name, const struct sgv_data* sgv,
 464                                              struct dbg_lvalue* rtn);
 465 extern symbol_picker_t symbol_current_picker;
 466 extern enum sym_get_lval symbol_picker_interactive(const char* name, const struct sgv_data* sgv,
 467                                                    struct dbg_lvalue* rtn);
 468 extern enum sym_get_lval symbol_picker_scoped(const char* name, const struct sgv_data* sgv,
 469                                               struct dbg_lvalue* rtn);
 470
 471   /* tgt_active.c */
 472 struct list_string
 473 {
 474     char* string;
 475     struct list_string* next;
 476 };
 477 extern void             dbg_run_debuggee(struct list_string* ls);
 478 extern void             dbg_wait_next_exception(DWORD cont, int count, int mode);
 479 extern enum dbg_start   dbg_active_attach(int argc, char* argv[]);
 480 extern BOOL             dbg_set_curr_thread(DWORD tid);
 481 extern enum dbg_start   dbg_active_launch(int argc, char* argv[]);
 482 extern enum dbg_start   dbg_active_auto(int argc, char* argv[]);
 483 extern enum dbg_start   dbg_active_minidump(int argc, char* argv[]);
 484 extern void             dbg_active_wait_for_first_exception(void);
 485 extern BOOL             dbg_attach_debuggee(DWORD pid);
 486 extern void             fetch_module_name(void* name_addr, void* mod_addr, WCHAR* buffer, size_t bufsz);
 487
 488   /* tgt_minidump.c */
 489 extern void             minidump_write(const char*, const EXCEPTION_RECORD*);
 490 extern enum dbg_start   minidump_reload(int argc, char* argv[]);
 491
 492   /* tgt_module.c */
 493 extern enum dbg_start   tgt_module_load(const char* name, BOOL keep);
 494
 495   /* types.c */
 496 extern void             print_value(const struct dbg_lvalue* addr, char format, int level);
 497 extern BOOL             types_print_type(const struct dbg_type*, BOOL details, const WCHAR* varname);
 498 extern BOOL             print_types(void);
 499 extern dbg_lgint_t      types_extract_as_integer(const struct dbg_lvalue*);
 500 extern dbg_lgint_t      types_extract_as_lgint(const struct dbg_lvalue*, unsigned* psize, BOOL *pissigned);
 501 extern void             types_extract_as_address(const struct dbg_lvalue*, ADDRESS64*);
 502 extern BOOL             types_store_value(struct dbg_lvalue* lvalue_to, const struct dbg_lvalue* lvalue_from);
 503 extern BOOL             types_udt_find_element(struct dbg_lvalue* value, const char* name);
 504 extern BOOL             types_array_index(const struct dbg_lvalue* value, int index, struct dbg_lvalue* result);
 505 extern BOOL             types_get_info(const struct dbg_type*, IMAGEHLP_SYMBOL_TYPE_INFO, void*);
 506 extern BOOL             types_get_real_type(struct dbg_type* type, DWORD* tag);
 507 extern BOOL             types_find_pointer(const struct dbg_type* type, struct dbg_type* outtype);
 508 extern BOOL             types_find_type(const char* name, enum SymTagEnum tag, struct dbg_type* outtype);
 509 extern BOOL             types_compare(const struct dbg_type, const struct dbg_type, BOOL* equal);
 510 extern BOOL             types_is_integral_type(const struct dbg_lvalue*);
 511 extern BOOL             types_is_float_type(const struct dbg_lvalue*);
 512 extern BOOL             types_is_pointer_type(const struct dbg_lvalue*);
 513 extern BOOL             types_find_basic(const WCHAR*, const char*, struct dbg_type* type);
 514 extern BOOL             types_unload_module(struct dbg_process* pcs, DWORD_PTR linear);
 515
 516   /* winedbg.c */
 517 #ifdef __GNUC__
 518 extern int WINAPIV      dbg_printf(const char* format, ...) __attribute__((format (printf,1,2)));
 519 #else
 520 extern int WINAPIV      dbg_printf(const char* format, ...);
 521 #endif
 522 extern const struct dbg_internal_var* dbg_get_internal_var(const char*);
 523 extern BOOL             dbg_interrupt_debuggee(void);
 524 extern unsigned         dbg_num_processes(void);
 525 extern struct dbg_process* dbg_add_process(const struct be_process_io* pio, DWORD pid, HANDLE h);
 526 extern void             dbg_set_process_name(struct dbg_process* p, const WCHAR* name);
 527 extern struct dbg_process* dbg_get_process(DWORD pid);
 528 extern struct dbg_process* dbg_get_process_h(HANDLE handle);
 529 extern void             dbg_del_process(struct dbg_process* p);
 530 struct dbg_thread*      dbg_add_thread(struct dbg_process* p, DWORD tid, HANDLE h, void* teb);
 531 extern struct dbg_thread* dbg_get_thread(struct dbg_process* p, DWORD tid);
 532 extern void             dbg_del_thread(struct dbg_thread* t);
 533 extern BOOL             dbg_init(HANDLE hProc, const WCHAR* in, BOOL invade);
 534 extern BOOL             dbg_load_module(HANDLE hProc, HANDLE hFile, const WCHAR* name, DWORD_PTR base, DWORD size);
 535 extern struct dbg_module* dbg_get_module(struct dbg_process* pcs, DWORD_PTR base);
 536 extern void             dbg_del_module(struct dbg_module* mod);
 537 extern BOOL             dbg_unload_module(struct dbg_process* pcs, DWORD_PTR base);
 538 extern void             dbg_set_option(const char*, const char*);
 539 extern void             dbg_start_interactive(const char*, HANDLE hFile);
 540 extern void             dbg_init_console(void);
 541
 542   /* gdbproxy.c */
 543 extern int              gdb_main(int argc, char* argv[]);
 544
 545 static inline BOOL dbg_read_memory(const void* addr, void* buffer, size_t len)
 546 {
 547     SIZE_T rlen;
 548     return dbg_curr_process->process_io->read(dbg_curr_process->handle, addr, buffer, len, &rlen) && len == rlen;
 549 }
 550
 551 static inline BOOL dbg_write_memory(void* addr, const void* buffer, size_t len)
 552 {
 553     SIZE_T wlen;
 554     return dbg_curr_process->process_io->write(dbg_curr_process->handle, addr, buffer, len, &wlen) && len == wlen;
 555 }
 556
 557 struct data_model
 558 {
 559     enum dbg_internal_types     itype;
 560     const WCHAR*                name;
 561 };
 562
 563 extern const struct data_model ilp32_data_model[];
 564 extern const struct data_model lp64_data_model[];
 565 extern const struct data_model llp64_data_model[];
 566
 567 extern struct dbg_internal_var          dbg_internal_vars[];
 568
 569 #define  DBG_IVARNAME(_var)     dbg_internal_var_##_var
 570 #define  DBG_IVARSTRUCT(_var)   dbg_internal_vars[DBG_IVARNAME(_var)]
 571 #define  DBG_IVAR(_var)         (DBG_IVARSTRUCT(_var).val)
 572 #define  INTERNAL_VAR(_var,_val,_ref,itype) DBG_IVARNAME(_var),
 573 enum debug_int_var
 574 {
 575 #include "intvar.h"
 576    DBG_IV_LAST
 577 };
 578 #undef   INTERNAL_VAR
 579
 580 /* include CPU dependent bits */
 581 #include "be_cpu.h"
 582
 583 #endif  /* __WINE_DEBUGGER_H */