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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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 #define WIN32_LEAN_AND_MEAN
  30 #include "windef.h"
  31 #include "winbase.h"
  32 #include "ntstatus.h"
  33 #include "winver.h"
  34 #include "dbghelp.h"
  35 #include "cvconst.h"
  36 #include "objbase.h"
  37 #include "oaidl.h"
  38
  39 /* the debugger uses these exceptions for it's internal use */
  40 #define DEBUG_STATUS_OFFSET             0x80003000
  41 #define DEBUG_STATUS_INTERNAL_ERROR     (DEBUG_STATUS_OFFSET+0) /* something went wrong */
  42 #define DEBUG_STATUS_NO_SYMBOL          (DEBUG_STATUS_OFFSET+1) /* no symbol found in lookup */
  43 #define DEBUG_STATUS_DIV_BY_ZERO        (DEBUG_STATUS_OFFSET+2)
  44 #define DEBUG_STATUS_BAD_TYPE           (DEBUG_STATUS_OFFSET+3) /* no type found, when type was expected */
  45 #define DEBUG_STATUS_NO_FIELD           (DEBUG_STATUS_OFFSET+4) /* when dereferencing a struct, the field was not found */
  46 #define DEBUG_STATUS_ABORT              (DEBUG_STATUS_OFFSET+5) /* user aborted on going action */
  47 #define DEBUG_STATUS_CANT_DEREF         (DEBUG_STATUS_OFFSET+6) /* either not deref:able, or index out of bounds */
  48 #define DEBUG_STATUS_NOT_AN_INTEGER     (DEBUG_STATUS_OFFSET+7) /* requiring an integral value */
  49
  50 /*
  51  * Return values for symbol_get_function_line_status.  Used to determine
  52  * what to do when the 'step' command is given.
  53  */
  54 enum dbg_line_status
  55 {
  56     dbg_no_line_info,
  57     dbg_not_on_a_line_number,
  58     dbg_on_a_line_number,
  59     dbg_in_a_thunk,
  60 };
  61
  62 enum dbg_internal_types
  63 {
  64     dbg_itype_first             = 0xffffff00,
  65     dbg_itype_unsigned_int,
  66     dbg_itype_signed_int,
  67     dbg_itype_signed_char_int,
  68     dbg_itype_unsigned_char_int,
  69     dbg_itype_unsigned_short_int,
  70     dbg_itype_signed_short_int,
  71     dbg_itype_unsigned_long_int,
  72     dbg_itype_signed_long_int,
  73     dbg_itype_unsigned_longlong_int,
  74     dbg_itype_signed_longlong_int,
  75     dbg_itype_char,
  76     dbg_itype_wchar,
  77     dbg_itype_short_real, /* aka float */
  78     dbg_itype_real,       /* aka double */
  79     dbg_itype_long_real,  /* aka long double */
  80     dbg_itype_astring,
  81     dbg_itype_ustring,
  82     dbg_itype_none              = 0xffffffff
  83 };
  84
  85 struct dbg_lvalue       /* structure to hold left-values... */
  86 {
  87     int                 cookie; /* DLV_??? */
  88 /* DLV_TARGET references an address in debuggee's address space, whereas DLV_HOST
  89  * references the winedbg's address space
  90  */
  91 #       define  DLV_TARGET      0xF00D
  92 #       define  DLV_HOST        0x50DA
  93     ADDRESS             addr;
  94     unsigned long       typeid;
  95 };
  96
  97 enum dbg_exec_mode
  98 {
  99     dbg_exec_cont,                      /* Continue execution */
 100     dbg_exec_step_over_line,            /* Stepping over a call to next source line */
 101     dbg_exec_step_into_line,            /* Step to next source line, stepping in if needed */
 102     dbg_exec_step_over_insn,            /* Stepping over a call */
 103     dbg_exec_step_into_insn,            /* Single-stepping an instruction */
 104     dbg_exec_finish,                    /* Single-step until we exit current frame */
 105 #if 0
 106     EXEC_STEP_OVER_TRAMPOLINE,  /* Step over trampoline.  Requires that we dig the real
 107                                  * return value off the stack and set breakpoint there -
 108                                  * not at the instr just after the call.
 109                                  */
 110 #endif
 111 };
 112
 113 extern char *arg_command;
 114
 115 struct dbg_breakpoint
 116 {
 117     ADDRESS             addr;
 118     unsigned long       enabled : 1,
 119                         xpoint_type : 2,
 120                         refcount : 13,
 121                         skipcount : 16;
 122     DWORD               info;
 123     struct              /* only used for watchpoints */
 124     {
 125         BYTE            len : 2;
 126         DWORD           oldval;
 127     } w;
 128     struct expr*        condition;
 129 };
 130
 131 /* Wine extension; Windows doesn't have a name for this code.  This is an
 132    undocumented exception understood by MS VC debugger, allowing the program
 133    to name a particular thread.  Search google.com or deja.com for "0x406d1388"
 134    for more info. */
 135 #define EXCEPTION_NAME_THREAD               0x406D1388
 136
 137 /* Helper structure */
 138 typedef struct tagTHREADNAME_INFO
 139 {
 140    DWORD   dwType;     /* Must be 0x1000 */
 141    LPCTSTR szName;     /* Pointer to name - limited to 9 bytes (8 characters + terminator) */
 142    DWORD   dwThreadID; /* Thread ID (-1 = caller thread) */
 143    DWORD   dwFlags;    /* Reserved for future use.  Must be zero. */
 144 } THREADNAME_INFO;
 145
 146 struct dbg_thread
 147 {
 148     struct dbg_process*         process;
 149     HANDLE                      handle;
 150     DWORD                       tid;
 151     void*                       teb;
 152     int                         wait_for_first_exception;
 153     enum dbg_exec_mode          exec_mode;      /* mode the thread is run (step/run...) */
 154     int                         exec_count;     /* count of mode operations */
 155     ADDRESS_MODE                addr_mode;      /* mode */
 156     struct dbg_breakpoint       step_over_bp;
 157     char                        name[9];
 158     struct dbg_thread*          next;
 159     struct dbg_thread*          prev;
 160 };
 161
 162 struct dbg_delayed_bp
 163 {
 164     BOOL                        is_symbol;
 165     union
 166     {
 167         struct
 168         {
 169             int                         lineno;
 170             char*                       name;
 171         } symbol;
 172         ADDRESS                 addr;
 173     } u;
 174 };
 175
 176 #define MAX_BREAKPOINTS 100
 177 struct dbg_process
 178 {
 179     HANDLE                      handle;
 180     DWORD                       pid;
 181     const char*                 imageName;
 182     struct dbg_thread*          threads;
 183     unsigned                    continue_on_first_exception;
 184     struct dbg_breakpoint       bp[MAX_BREAKPOINTS];
 185     unsigned                    next_bp;
 186     struct dbg_delayed_bp*      delayed_bp;
 187     int                         num_delayed_bp;
 188     struct dbg_process*         next;
 189     struct dbg_process*         prev;
 190 };
 191
 192 extern  struct dbg_process*     dbg_curr_process;
 193 extern  DWORD                   dbg_curr_pid;
 194 extern  struct dbg_thread*      dbg_curr_thread;
 195 extern  DWORD                   dbg_curr_tid;
 196 extern  CONTEXT                 dbg_context;
 197 extern  BOOL                    dbg_interactiveP;
 198 extern  int                     dbg_curr_frame;
 199
 200 struct dbg_internal_var
 201 {
 202     DWORD                       val;
 203     const char*                 name;
 204     LPDWORD                     pval;
 205     unsigned long               typeid;
 206 };
 207
 208 enum sym_get_lval {sglv_found, sglv_unknown, sglv_aborted};
 209
 210 enum type_expr_e
 211 {
 212     type_expr_type_id,
 213     type_expr_udt_class,
 214     type_expr_udt_struct,
 215     type_expr_udt_union,
 216     type_expr_enumeration
 217 };
 218
 219 struct type_expr_t
 220 {
 221     enum type_expr_e    type;
 222     unsigned            deref_count;
 223     union
 224     {
 225         unsigned long   typeid;
 226         const char*     name;
 227     } u;
 228 };
 229
 230   /* break.c */
 231 extern void             break_set_xpoints(BOOL set);
 232 extern BOOL             break_add_break(const ADDRESS* addr, BOOL verbose);
 233 extern BOOL             break_add_break_from_lvalue(const struct dbg_lvalue* value);
 234 extern void             break_add_break_from_id(const char* name, int lineno);
 235 extern void             break_add_break_from_lineno(int lineno);
 236 extern void             break_add_watch(const struct dbg_lvalue* lvalue, int is_write);
 237 extern void             break_add_watch_from_id(const char* name);
 238 extern void             break_check_delayed_bp(void);
 239 extern void             break_delete_xpoint(int num);
 240 extern void             break_delete_xpoints_from_module(unsigned long base);
 241 extern void             break_enable_xpoint(int num, BOOL enable);
 242 extern void             break_info(void);
 243 extern BOOL             break_should_continue(ADDRESS* addr, DWORD code, int* count);
 244 extern void             break_suspend_execution(void);
 245 extern void             break_restart_execution(int count);
 246 extern int              break_add_condition(int bpnum, struct expr* exp);
 247
 248   /* dbg.y */
 249 extern void             parser(const char*);
 250 extern int              input_read_line(const char* pfx, char* buffer, int size);
 251 extern int              input_fetch_entire_line(const char* pfx, char** line, size_t* alloc, BOOL check_nl);
 252
 253   /* debug.l */
 254 extern void             lexeme_flush(void);
 255 extern char*            lexeme_alloc(const char*);
 256
 257   /* display.c */
 258 extern int              display_print(void);
 259 extern int              display_add(struct expr* exp, int count, char format, int local_frame);
 260 extern int              display_delete(int displaynum);
 261 extern int              display_info(void);
 262 extern int              display_enable(int displaynum, int enable);
 263
 264   /* expr.c */
 265 extern void             expr_free_all(void);
 266 extern struct expr*     expr_alloc_internal_var(const char* name);
 267 extern struct expr*     expr_alloc_symbol(const char* name);
 268 extern struct expr*     expr_alloc_sconstant(int val);
 269 extern struct expr*     expr_alloc_uconstant(unsigned val);
 270 extern struct expr*     expr_alloc_string(const char* str);
 271 extern struct expr*     expr_alloc_binary_op(int oper, struct expr*, struct expr*);
 272 extern struct expr*     expr_alloc_unary_op(int oper, struct expr*);
 273 extern struct expr*     expr_alloc_pstruct(struct expr*, const char* element);
 274 extern struct expr*     expr_alloc_struct(struct expr*, const char* element);
 275 extern struct expr*     expr_alloc_func_call(const char*, int nargs, ...);
 276 extern struct expr*     expr_alloc_typecast(struct type_expr_t*, struct expr*);
 277 extern struct dbg_lvalue expr_eval(struct expr*);
 278 extern struct expr*     expr_clone(const struct expr* exp);
 279 extern int              expr_free(struct expr* exp);
 280 extern int              expr_print(const struct expr* exp);
 281
 282   /* info.c */
 283 extern void             print_help(void);
 284 extern void             info_help(void);
 285 extern void             info_win32_module(DWORD mod);
 286 extern void             info_win32_class(HWND hWnd, const char* clsName);
 287 extern void             info_win32_window(HWND hWnd, BOOL detailed);
 288 extern void             info_win32_processes(void);
 289 extern void             info_win32_threads(void);
 290 extern void             info_win32_exceptions(DWORD tid);
 291 extern void             info_win32_virtual(DWORD pid);
 292 extern void             info_win32_segments(DWORD start, int length);
 293 extern void             info_wine_dbg_channel(BOOL add, const char* chnl, const char* name);
 294
 295   /* memory.c */
 296 extern BOOL             memory_read_value(const struct dbg_lvalue* val, DWORD size, void* result);
 297 extern BOOL             memory_write_value(const struct dbg_lvalue* val, DWORD size, void* value);
 298 extern void             memory_examine(const struct dbg_lvalue* addr, int count, char format);
 299 extern void             memory_report_invalid_addr(const void* addr);
 300 extern void*            memory_to_linear_addr(const ADDRESS* address);
 301 extern BOOL             memory_get_current_pc(ADDRESS* address);
 302 extern BOOL             memory_get_current_stack(ADDRESS* address);
 303 extern BOOL             memory_get_current_frame(ADDRESS* address);
 304 extern BOOL             memory_get_string(HANDLE hp, void* addr, unsigned cookie, BOOL unicode, char* buffer, int size);
 305 extern BOOL             memory_get_string_indirect(HANDLE hp, void* addr, BOOL unicode, char* buffer, int size);
 306 extern void             memory_disassemble(const struct dbg_lvalue*, const struct dbg_lvalue*, int offset);
 307 extern BOOL             memory_disasm_one_insn(ADDRESS* addr);
 308 extern void             print_bare_address(const ADDRESS* addr);
 309 extern void             print_address(const ADDRESS* addr, BOOLEAN with_line);
 310 extern void             print_addr_and_args(const ADDRESS* pc, const ADDRESS* frame);
 311 extern void             print_basic(const struct dbg_lvalue* value, int count, char format);
 312
 313   /* source.c */
 314 extern void             source_list(IMAGEHLP_LINE* src1, IMAGEHLP_LINE* src2, int delta);
 315 extern void             source_list_from_addr(const ADDRESS* addr, int nlines);
 316 extern void             source_show_path(void);
 317 extern void             source_add_path(const char* path);
 318 extern void             source_nuke_path(void);
 319
 320   /* stack.c */
 321 extern void             stack_info(void);
 322 extern void             stack_backtrace(DWORD threadID, BOOL noisy);
 323 extern int              stack_set_frame(int newframe);
 324 extern int              stack_get_frame(SYMBOL_INFO* sym, IMAGEHLP_STACK_FRAME* ihsf);
 325
 326   /* symbol.c */
 327 extern enum sym_get_lval symbol_get_lvalue(const char* name, const int lineno, struct dbg_lvalue* addr, BOOL bp_disp);
 328 extern void             symbol_read_symtable(const char* filename, unsigned long offset);
 329 extern enum dbg_line_status symbol_get_function_line_status(const ADDRESS* addr);
 330 extern BOOL             symbol_get_line(const char* filename, const char* func, IMAGEHLP_LINE* ret);
 331 extern void             symbol_info(const char* str);
 332 extern int              symbol_info_locals(void);
 333
 334   /* types.c */
 335 extern void             print_value(const struct dbg_lvalue* addr, char format, int level);
 336 extern int              types_print_type(DWORD linear, DWORD typeid, BOOL details);
 337 extern int              print_types(void);
 338 extern long int         types_extract_as_integer(const struct dbg_lvalue*);
 339 extern BOOL             types_deref(const struct dbg_lvalue* value, struct dbg_lvalue* result);
 340 extern BOOL             types_udt_find_element(struct dbg_lvalue* value, const char* name, long int* tmpbuf);
 341 extern BOOL             types_array_index(const struct dbg_lvalue* value, int index, struct dbg_lvalue* result);
 342 extern BOOL             types_get_info(unsigned long, unsigned long,
 343                                        IMAGEHLP_SYMBOL_TYPE_INFO, void*);
 344 extern unsigned long    types_find_pointer(unsigned long linear, unsigned long typeid);
 345 extern unsigned long    types_find_type(unsigned long linear, const char* name, enum SymTagEnum tag);
 346
 347   /* winedbg.c */
 348 extern void             dbg_outputA(const char* buffer, int len);
 349 extern void             dbg_outputW(const WCHAR* buffer, int len);
 350 #ifdef __GNUC__
 351 extern int              dbg_printf(const char* format, ...) __attribute__((format (printf,1,2)));
 352 #else
 353 extern int              dbg_printf(const char* format, ...);
 354 #endif
 355 extern const struct dbg_internal_var* dbg_get_internal_var(const char*);
 356 extern BOOL             dbg_attach_debuggee(DWORD pid, BOOL cofe, BOOL wfe);
 357 extern BOOL             dbg_detach_debuggee(void);
 358 extern BOOL             dbg_interrupt_debuggee(void);
 359 extern void             dbg_run_debuggee(const char* args);
 360 extern struct dbg_process* dbg_add_process(DWORD pid, HANDLE h, const char* imageName);
 361 extern struct dbg_process* dbg_get_process(DWORD pid);
 362 extern void             dbg_del_process(struct dbg_process* p);
 363 struct dbg_thread*      dbg_add_thread(struct dbg_process* p, DWORD tid, HANDLE h, void* teb);
 364 extern struct dbg_thread* dbg_get_thread(struct dbg_process* p, DWORD tid);
 365 extern void             dbg_del_thread(struct dbg_thread* t);
 366 extern void             dbg_wait_next_exception(DWORD cont, int count, int mode);
 367 extern BOOL             dbg_get_debuggee_info(HANDLE hProcess, IMAGEHLP_MODULE* imh_mod);
 368
 369 /* gdbproxy.c */
 370 extern BOOL             gdb_remote(unsigned int);
 371
 372 static inline BOOL dbg_read_memory(const void* addr, void* buffer, size_t len)
 373 {
 374     DWORD rlen;
 375     return ReadProcessMemory(dbg_curr_process->handle, addr, buffer, len, &rlen) && len == rlen;
 376 }
 377
 378 static inline BOOL dbg_write_memory(void* addr, const void* buffer, size_t len)
 379 {
 380     DWORD wlen;
 381     return WriteProcessMemory(dbg_curr_process->handle, addr, buffer, len, &wlen) && len == wlen;
 382 }
 383
 384 static inline BOOL dbg_read_memory_verbose(const void* addr, void* buffer, size_t len)
 385 {
 386     if (dbg_read_memory(addr, buffer, len)) return TRUE;
 387     memory_report_invalid_addr(addr);
 388     return FALSE;
 389 }
 390
 391 static inline BOOL dbg_write_memory_verbose(void* addr, const void* buffer, size_t len)
 392 {
 393     if (dbg_write_memory(addr, buffer, len)) return TRUE;
 394     memory_report_invalid_addr(addr);
 395     return FALSE;
 396 }
 397
 398 static inline void* dbg_heap_realloc(void* buffer, size_t size)
 399 {
 400     return (buffer) ? HeapReAlloc(GetProcessHeap(), 0, buffer, size) :
 401         HeapAlloc(GetProcessHeap(), 0, size);
 402 }
 403
 404 extern struct dbg_internal_var          dbg_internal_vars[];
 405 extern const struct dbg_internal_var*   dbg_context_vars;
 406
 407 #define  DBG_IVARNAME(_var)     dbg_internal_var_##_var
 408 #define  DBG_IVARSTRUCT(_var)   dbg_internal_vars[DBG_IVARNAME(_var)]
 409 #define  DBG_IVAR(_var)         (*(DBG_IVARSTRUCT(_var).pval))
 410 #define  INTERNAL_VAR(_var,_val,_ref,itype) DBG_IVARNAME(_var),
 411 enum debug_int_var
 412 {
 413 #include "intvar.h"
 414    DBG_IV_LAST
 415 };
 416 #undef   INTERNAL_VAR
 417
 418 /* include CPU dependent bits */
 419 #include "be_cpu.h"
 420
 421 #endif  /* __WINE_DEBUGGER_H */