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