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 /* used for C++ exceptions in msvcrt
145 * parameters:
146 * [0] CXX_FRAME_MAGIC
147 * [1] pointer to exception object
148 * [2] pointer to type
149 */
150 #define CXX_EXCEPTION 0xe06d7363
151 #define CXX_FRAME_MAGIC 0x19930520
152
153 /* Wine extension; Windows doesn't have a name for this code. This is an
154 undocumented exception understood by MS VC debugger, allowing the program
155 to name a particular thread. Search google.com or deja.com for "0x406d1388"
156 for more info. */
157 #define EXCEPTION_NAME_THREAD 0x406D1388
158
159 /* Helper structure */
160 typedef struct tagTHREADNAME_INFO
161 {
162 DWORD dwType; /* Must be 0x1000 */
163 LPCTSTR szName; /* Pointer to name - limited to 9 bytes (8 characters + terminator) */
164 DWORD dwThreadID; /* Thread ID (-1 = caller thread) */
165 DWORD dwFlags; /* Reserved for future use. Must be zero. */
166 } THREADNAME_INFO;
167
168 struct dbg_thread
169 {
170 struct dbg_process* process;
171 HANDLE handle;
172 DWORD tid;
173 void* teb;
174 enum dbg_exec_mode exec_mode; /* mode the thread is run (step/run...) */
175 int exec_count; /* count of mode operations */
176 ADDRESS_MODE addr_mode; /* mode */
177 int stopped_xpoint; /* xpoint on which the thread has stopped (-1 if none) */
178 struct dbg_breakpoint step_over_bp;
179 char name[9];
180 struct dbg_thread* next;
181 struct dbg_thread* prev;
182 BOOL in_exception; /* TRUE if thread stopped with an exception */
183 EXCEPTION_RECORD excpt_record; /* only valid when in_exception is TRUE */
184 struct
185 {
186 ADDRESS64 addr_pc;
187 ADDRESS64 addr_frame;
188 ADDRESS64 addr_stack;
189 DWORD linear_pc;
190 DWORD linear_frame;
191 DWORD linear_stack;
192 }* frames;
193 int num_frames;
194 int curr_frame;
195 };
196
197 struct dbg_delayed_bp
198 {
199 BOOL is_symbol;
200 BOOL software_bp;
201 union
202 {
203 struct
204 {
205 int lineno;
206 char* name;
207 } symbol;
208 ADDRESS64 addr;
209 } u;
210 };
211
212 #define MAX_BREAKPOINTS 100
213 struct dbg_process
214 {
215 HANDLE handle;
216 DWORD pid;
217 const struct be_process_io* process_io;
218 void* pio_data;
219 const WCHAR* imageName;
220 struct dbg_thread* threads;
221 unsigned continue_on_first_exception : 1,
222 active_debuggee : 1;
223 struct dbg_breakpoint bp[MAX_BREAKPOINTS];
224 unsigned next_bp;
225 struct dbg_delayed_bp* delayed_bp;
226 int num_delayed_bp;
227 struct open_file_list* source_ofiles;
228 char* search_path;
229 char source_current_file[MAX_PATH];
230 int source_start_line;
231 int source_end_line;
232 struct dbg_process* next;
233 struct dbg_process* prev;
234 };
235
236 /* describes the way the debugger interacts with a given process */
237 struct be_process_io
238 {
239 BOOL (*close_process)(struct dbg_process*, BOOL);
240 BOOL (*read)(HANDLE, const void*, void*, SIZE_T, SIZE_T*);
241 BOOL (*write)(HANDLE, void*, const void*, SIZE_T, SIZE_T*);
242 BOOL (*get_selector)(HANDLE, DWORD, LDT_ENTRY*);
243 };
244
245 extern struct dbg_process* dbg_curr_process;
246 extern DWORD dbg_curr_pid;
247 extern struct dbg_thread* dbg_curr_thread;
248 extern DWORD dbg_curr_tid;
249 extern CONTEXT dbg_context;
250 extern BOOL dbg_interactiveP;
251
252 struct dbg_internal_var
253 {
254 DWORD val;
255 const char* name;
256 LPDWORD pval;
257 unsigned long typeid; /* always internal type */
258 };
259
260 enum sym_get_lval {sglv_found, sglv_unknown, sglv_aborted};
261
262 enum type_expr_e
263 {
264 type_expr_type_id,
265 type_expr_udt_class,
266 type_expr_udt_struct,
267 type_expr_udt_union,
268 type_expr_enumeration
269 };
270
271 struct type_expr_t
272 {
273 enum type_expr_e type;
274 unsigned deref_count;
275 union
276 {
277 struct dbg_type type;
278 const char* name;
279 } u;
280 };
281
282 enum dbg_start {start_ok, start_error_parse, start_error_init};
283
284 /* break.c */
285 extern void break_set_xpoints(BOOL set);
286 extern BOOL break_add_break(const ADDRESS64* addr, BOOL verbose, BOOL swbp);
287 extern BOOL break_add_break_from_lvalue(const struct dbg_lvalue* value, BOOL swbp);
288 extern void break_add_break_from_id(const char* name, int lineno, BOOL swbp);
289 extern void break_add_break_from_lineno(int lineno, BOOL swbp);
290 extern void break_add_watch_from_lvalue(const struct dbg_lvalue* lvalue);
291 extern void break_add_watch_from_id(const char* name);
292 extern void break_check_delayed_bp(void);
293 extern void break_delete_xpoint(int num);
294 extern void break_delete_xpoints_from_module(unsigned long base);
295 extern void break_enable_xpoint(int num, BOOL enable);
296 extern void break_info(void);
297 extern void break_adjust_pc(ADDRESS64* addr, DWORD code, BOOL first_chance, BOOL* is_break);
298 extern BOOL break_should_continue(ADDRESS64* addr, DWORD code);
299 extern void break_suspend_execution(void);
300 extern void break_restart_execution(int count);
301 extern int break_add_condition(int bpnum, struct expr* exp);
302
303 /* crashdlg.c */
304 extern BOOL display_crash_dialog(void);
305 extern int msgbox_res_id(HWND hwnd, UINT textId, UINT captionId, UINT uType);
306
307 /* dbg.y */
308 extern void parser_handle(HANDLE);
309 extern int input_read_line(const char* pfx, char* buffer, int size);
310 extern int input_fetch_entire_line(const char* pfx, char** line);
311 extern HANDLE parser_generate_command_file(const char*, ...);
312
313 /* debug.l */
314 extern void lexeme_flush(void);
315 extern char* lexeme_alloc_size(int);
316
317 /* display.c */
318 extern int display_print(void);
319 extern int display_add(struct expr* exp, int count, char format);
320 extern int display_delete(int displaynum);
321 extern int display_info(void);
322 extern int display_enable(int displaynum, int enable);
323
324 /* expr.c */
325 extern void expr_free_all(void);
326 extern struct expr* expr_alloc_internal_var(const char* name);
327 extern struct expr* expr_alloc_symbol(const char* name);
328 extern struct expr* expr_alloc_sconstant(int val);
329 extern struct expr* expr_alloc_uconstant(unsigned val);
330 extern struct expr* expr_alloc_string(const char* str);
331 extern struct expr* expr_alloc_binary_op(int oper, struct expr*, struct expr*);
332 extern struct expr* expr_alloc_unary_op(int oper, struct expr*);
333 extern struct expr* expr_alloc_pstruct(struct expr*, const char* element);
334 extern struct expr* expr_alloc_struct(struct expr*, const char* element);
335 extern struct expr* expr_alloc_func_call(const char*, int nargs, ...);
336 extern struct expr* expr_alloc_typecast(struct type_expr_t*, struct expr*);
337 extern struct dbg_lvalue expr_eval(struct expr*);
338 extern struct expr* expr_clone(const struct expr* exp, BOOL *local_binding);
339 extern int expr_free(struct expr* exp);
340 extern int expr_print(const struct expr* exp);
341
342 /* info.c */
343 extern void print_help(void);
344 extern void info_help(void);
345 extern void info_win32_module(DWORD64 mod);
346 extern void info_win32_class(HWND hWnd, const char* clsName);
347 extern void info_win32_window(HWND hWnd, BOOL detailed);
348 extern void info_win32_processes(void);
349 extern void info_win32_threads(void);
350 extern void info_win32_exceptions(DWORD tid);
351 extern void info_win32_virtual(DWORD pid);
352 extern void info_win32_segments(DWORD start, int length);
353 extern void info_wine_dbg_channel(BOOL add, const char* chnl, const char* name);
354
355 /* memory.c */
356 extern BOOL memory_read_value(const struct dbg_lvalue* lvalue, DWORD size, void* result);
357 extern BOOL memory_write_value(const struct dbg_lvalue* val, DWORD size, void* value);
358 extern void memory_examine(const struct dbg_lvalue *lvalue, int count, char format);
359 extern void* memory_to_linear_addr(const ADDRESS64* address);
360 extern BOOL memory_get_current_pc(ADDRESS64* address);
361 extern BOOL memory_get_current_stack(ADDRESS64* address);
362 extern BOOL memory_get_current_frame(ADDRESS64* address);
363 extern BOOL memory_get_string(struct dbg_process* pcs, void* addr, BOOL in_debuggee, BOOL unicode, char* buffer, int size);
364 extern BOOL memory_get_string_indirect(struct dbg_process* pcs, void* addr, BOOL unicode, WCHAR* buffer, int size);
365 extern BOOL memory_get_register(DWORD regno, DWORD** value, char* buffer, int len);
366 extern void memory_disassemble(const struct dbg_lvalue*, const struct dbg_lvalue*, int instruction_count);
367 extern BOOL memory_disasm_one_insn(ADDRESS64* addr);
368 #define MAX_OFFSET_TO_STR_LEN 19
369 extern char* memory_offset_to_string(char *str, DWORD64 offset, unsigned mode);
370 extern void print_bare_address(const ADDRESS64* addr);
371 extern void print_address(const ADDRESS64* addr, BOOLEAN with_line);
372 extern void print_basic(const struct dbg_lvalue* value, char format);
373
374 /* source.c */
375 extern void source_list(IMAGEHLP_LINE* src1, IMAGEHLP_LINE* src2, int delta);
376 extern void source_list_from_addr(const ADDRESS64* addr, int nlines);
377 extern void source_show_path(void);
378 extern void source_add_path(const char* path);
379 extern void source_nuke_path(struct dbg_process* p);
380 extern void source_free_files(struct dbg_process* p);
381
382 /* stack.c */
383 extern void stack_info(void);
384 extern void stack_backtrace(DWORD threadID);
385 extern BOOL stack_set_frame(int newframe);
386 extern BOOL stack_get_current_frame(IMAGEHLP_STACK_FRAME* ihsf);
387 extern BOOL stack_get_register_current_frame(unsigned regno, DWORD** pval);
388 extern unsigned stack_fetch_frames(void);
389 extern BOOL stack_get_current_symbol(SYMBOL_INFO* sym);
390
391 /* symbol.c */
392 extern enum sym_get_lval symbol_get_lvalue(const char* name, const int lineno, struct dbg_lvalue* addr, BOOL bp_disp);
393 extern void symbol_read_symtable(const char* filename, unsigned long offset);
394 extern enum dbg_line_status symbol_get_function_line_status(const ADDRESS64* addr);
395 extern BOOL symbol_get_line(const char* filename, const char* func, IMAGEHLP_LINE* ret);
396 extern void symbol_info(const char* str);
397 extern void symbol_print_local(const SYMBOL_INFO* sym, ULONG base, BOOL detailed);
398 extern int symbol_info_locals(void);
399 extern BOOL symbol_is_local(const char* name);
400 struct sgv_data;
401 typedef enum sym_get_lval (*symbol_picker_t)(const char* name, const struct sgv_data* sgv,
402 struct dbg_lvalue* rtn);
403 extern symbol_picker_t symbol_current_picker;
404 extern enum sym_get_lval symbol_picker_interactive(const char* name, const struct sgv_data* sgv,
405 struct dbg_lvalue* rtn);
406 extern enum sym_get_lval symbol_picker_scoped(const char* name, const struct sgv_data* sgv,
407 struct dbg_lvalue* rtn);
408
409 /* tgt_active.c */
410 extern void dbg_run_debuggee(const char* args);
411 extern void dbg_wait_next_exception(DWORD cont, int count, int mode);
412 extern enum dbg_start dbg_active_attach(int argc, char* argv[]);
413 extern enum dbg_start dbg_active_launch(int argc, char* argv[]);
414 extern enum dbg_start dbg_active_auto(int argc, char* argv[]);
415 extern void dbg_active_wait_for_first_exception(void);
416 extern BOOL dbg_attach_debuggee(DWORD pid, BOOL cofe);
417
418 /* tgt_minidump.c */
419 extern void minidump_write(const char*, const EXCEPTION_RECORD*);
420 extern enum dbg_start minidump_reload(int argc, char* argv[]);
421
422 /* tgt_module.c */
423 extern enum dbg_start tgt_module_load(const char* name, BOOL keep);
424
425 /* types.c */
426 extern void print_value(const struct dbg_lvalue* addr, char format, int level);
427 extern int types_print_type(const struct dbg_type*, BOOL details);
428 extern int print_types(void);
429 extern long int types_extract_as_integer(const struct dbg_lvalue*);
430 extern LONGLONG types_extract_as_longlong(const struct dbg_lvalue*, unsigned* psize);
431 extern void types_extract_as_address(const struct dbg_lvalue*, ADDRESS64*);
432 extern BOOL types_deref(const struct dbg_lvalue* value, struct dbg_lvalue* result);
433 extern BOOL types_udt_find_element(struct dbg_lvalue* value, const char* name, long int* tmpbuf);
434 extern BOOL types_array_index(const struct dbg_lvalue* value, int index, struct dbg_lvalue* result);
435 extern BOOL types_get_info(const struct dbg_type*, IMAGEHLP_SYMBOL_TYPE_INFO, void*);
436 extern BOOL types_get_real_type(struct dbg_type* type, DWORD* tag);
437 extern struct dbg_type types_find_pointer(const struct dbg_type* type);
438 extern struct dbg_type types_find_type(unsigned long linear, const char* name, enum SymTagEnum tag);
439
440 /* winedbg.c */
441 extern void dbg_outputW(const WCHAR* buffer, int len);
442 extern const char* dbg_W2A(const WCHAR* buffer, unsigned len);
443 #ifdef __GNUC__
444 extern int dbg_printf(const char* format, ...) __attribute__((format (printf,1,2)));
445 #else
446 extern int dbg_printf(const char* format, ...);
447 #endif
448 extern const struct dbg_internal_var* dbg_get_internal_var(const char*);
449 extern BOOL dbg_interrupt_debuggee(void);
450 extern unsigned dbg_num_processes(void);
451 extern struct dbg_process* dbg_add_process(const struct be_process_io* pio, DWORD pid, HANDLE h);
452 extern void dbg_set_process_name(struct dbg_process* p, const WCHAR* name);
453 extern struct dbg_process* dbg_get_process(DWORD pid);
454 extern struct dbg_process* dbg_get_process_h(HANDLE handle);
455 extern void dbg_del_process(struct dbg_process* p);
456 struct dbg_thread* dbg_add_thread(struct dbg_process* p, DWORD tid, HANDLE h, void* teb);
457 extern struct dbg_thread* dbg_get_thread(struct dbg_process* p, DWORD tid);
458 extern void dbg_del_thread(struct dbg_thread* t);
459 extern BOOL dbg_init(HANDLE hProc, const WCHAR* in, BOOL invade);
460 extern BOOL dbg_load_module(HANDLE hProc, HANDLE hFile, const WCHAR* name, DWORD base, DWORD size);
461 extern BOOL dbg_get_debuggee_info(HANDLE hProcess, IMAGEHLP_MODULE* imh_mod);
462 extern void dbg_set_option(const char*, const char*);
463 extern void dbg_start_interactive(HANDLE hFile);
464 extern void dbg_init_console(void);
465
466 /* gdbproxy.c */
467 extern int gdb_main(int argc, char* argv[]);
468
469 static inline BOOL dbg_read_memory(const void* addr, void* buffer, size_t len)
470 {
471 SIZE_T rlen;
472 return dbg_curr_process->process_io->read(dbg_curr_process->handle, addr, buffer, len, &rlen) && len == rlen;
473 }
474
475 static inline BOOL dbg_write_memory(void* addr, const void* buffer, size_t len)
476 {
477 SIZE_T wlen;
478 return dbg_curr_process->process_io->write(dbg_curr_process->handle, addr, buffer, len, &wlen) && len == wlen;
479 }
480
481 static inline void* dbg_heap_realloc(void* buffer, size_t size)
482 {
483 return (buffer) ? HeapReAlloc(GetProcessHeap(), 0, buffer, size) :
484 HeapAlloc(GetProcessHeap(), 0, size);
485 }
486
487 extern struct dbg_internal_var dbg_internal_vars[];
488 extern const struct dbg_internal_var* dbg_context_vars;
489
490 #define DBG_IVARNAME(_var) dbg_internal_var_##_var
491 #define DBG_IVARSTRUCT(_var) dbg_internal_vars[DBG_IVARNAME(_var)]
492 #define DBG_IVAR(_var) (*(DBG_IVARSTRUCT(_var).pval))
493 #define INTERNAL_VAR(_var,_val,_ref,itype) DBG_IVARNAME(_var),
494 enum debug_int_var
495 {
496 #include "intvar.h"
497 DBG_IV_LAST
498 };
499 #undef INTERNAL_VAR
500
501 /* include CPU dependent bits */
502 #include "be_cpu.h"
503
504 #endif /* __WINE_DEBUGGER_H */
505
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.