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