debugger/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 <sys/types.h> /* u_long ... */
  25 #include <assert.h>
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "wine/exception.h"
  29
  30 #ifdef __i386__
  31 #define STEP_FLAG 0x00000100 /* single step flag */
  32 #define V86_FLAG  0x00020000
  33 #endif
  34
  35 #define SYM_FUNC         0x0
  36 #define SYM_DATA         0x1
  37 #define SYM_WIN32        0x2
  38 #define SYM_WINE         0x4
  39 #define SYM_INVALID      0x8
  40 #define SYM_TRAMPOLINE   0x10
  41 #define SYM_STEP_THROUGH 0x20
  42
  43 enum    debug_type {DT_BASIC, DT_POINTER, DT_ARRAY, DT_STRUCT, DT_ENUM,
  44                     DT_FUNC, DT_BITFIELD};
  45
  46 enum    debug_type_basic {DT_BASIC_INT = 1, DT_BASIC_CHAR, DT_BASIC_LONGINT, DT_BASIC_UINT,
  47                           DT_BASIC_ULONGINT, DT_BASIC_LONGLONGINT, DT_BASIC_ULONGLONGINT,
  48                           DT_BASIC_SHORTINT, DT_BASIC_USHORTINT, DT_BASIC_SCHAR, DT_BASIC_UCHAR,
  49                           DT_BASIC_FLOAT, DT_BASIC_LONGDOUBLE, DT_BASIC_DOUBLE,
  50                           DT_BASIC_CMPLX_INT, DT_BASIC_CMPLX_FLOAT, DT_BASIC_CMPLX_DOUBLE,
  51                           DT_BASIC_CMPLX_LONGDOUBLE, DT_BASIC_VOID,
  52                           /* modifier on size isn't possible on current types definitions
  53                            * so we need to add more types... */
  54                           DT_BASIC_BOOL1, DT_BASIC_BOOL2, DT_BASIC_BOOL4,
  55                           /* this is not really a basic type... */
  56                           DT_BASIC_STRING,
  57                           /* this is for historical reasons... should take care of it RSN */
  58                           DT_BASIC_CONST_INT,
  59                           /* to be kept as last... sentinel entry... do not use */
  60                           DT_BASIC_LAST};
  61
  62 /*
  63  * Return values for DEBUG_CheckLinenoStatus.  Used to determine
  64  * what to do when the 'step' command is given.
  65  */
  66 #define FUNC_HAS_NO_LINES       (0)
  67 #define NOT_ON_LINENUMBER       (1)
  68 #define AT_LINENUMBER           (2)
  69 #define FUNC_IS_TRAMPOLINE      (3)
  70
  71 typedef struct
  72 {
  73     DWORD               seg;  /* 0xffffffff means current default segment (cs or ds) */
  74     DWORD               off;
  75 } DBG_ADDR;
  76
  77 typedef struct
  78 {
  79    struct datatype*     type;
  80    int                  cookie; /* DV_??? */
  81 /* DV_TARGET references an address in debugger's address space, whereas DV_HOST
  82  * references the debuggee address space
  83  */
  84 #       define  DV_TARGET       0xF00D
  85 #       define  DV_HOST         0x50DA
  86 #       define  DV_INVALID      0x0000
  87
  88    DBG_ADDR             addr;
  89 } DBG_VALUE;
  90
  91 struct list_id
  92 {
  93     char * sourcefile;
  94     int    line;
  95 };
  96
  97 struct  wine_lines {
  98   unsigned long         line_number;
  99   DBG_ADDR              pc_offset;
 100 };
 101
 102 struct symbol_info
 103 {
 104   struct name_hash * sym;
 105   struct list_id     list;
 106 };
 107
 108 typedef struct wine_lines WineLineNo;
 109
 110 /*
 111  * This structure holds information about stack variables, function
 112  * parameters, and register variables, which are all local to this
 113  * function.
 114  */
 115 struct  wine_locals {
 116   unsigned int          regno:8;        /* For register symbols */
 117   signed int            offset:24;      /* offset from esp/ebp to symbol */
 118   unsigned int          pc_start;       /* For RBRAC/LBRAC */
 119   unsigned int          pc_end;         /* For RBRAC/LBRAC */
 120   char                * name;           /* Name of symbol */
 121   struct datatype     * type;           /* Datatype of symbol */
 122 };
 123
 124 typedef struct wine_locals WineLocals;
 125
 126 enum exec_mode
 127 {
 128     EXEC_CONT,                  /* Continuous execution */
 129     EXEC_PASS,                  /* Continue, passing exception to app */
 130     EXEC_STEP_OVER,             /* Stepping over a call to next source line */
 131     EXEC_STEP_INSTR,            /* Step to next source line, stepping in if needed */
 132     EXEC_STEPI_OVER,            /* Stepping over a call */
 133     EXEC_STEPI_INSTR,           /* Single-stepping an instruction */
 134     EXEC_FINISH,                /* Step until we exit current frame */
 135     EXEC_STEP_OVER_TRAMPOLINE,  /* Step over trampoline.  Requires that
 136                                  * we dig the real return value off the stack
 137                                  * and set breakpoint there - not at the
 138                                  * instr just after the call.
 139                                  */
 140 };
 141
 142 #define DBG_BREAK       0
 143 #define DBG_WATCH       1
 144
 145 typedef struct
 146 {
 147     DBG_ADDR      addr;
 148     WORD          enabled : 1,
 149                   type : 1,
 150                   is32 : 1,
 151                   refcount : 13;
 152     WORD          skipcount;
 153     union {
 154        struct {
 155           BYTE          opcode;
 156           BOOL          (*func)(void);
 157        } b;
 158        struct {
 159           BYTE          rw : 1,
 160                         len : 2;
 161           BYTE          reg;
 162           DWORD         oldval;
 163        } w;
 164     } u;
 165     struct expr * condition;
 166 } DBG_BREAKPOINT;
 167
 168 enum dbg_mode
 169 {
 170     MODE_INVALID, MODE_16, MODE_32, MODE_VM86
 171 };
 172
 173
 174 enum exit_mode
 175 {
 176     EXIT_CONT, EXIT_QUIT, EXIT_DETACH
 177 };
 178
 179 /* Wine extension; Windows doesn't have a name for this code.  This is an
 180    undocumented exception understood by MS VC debugger, allowing the program
 181    to name a particular thread.  Search google.com or deja.com for "0x406d1388"
 182    for more info. */
 183 #define EXCEPTION_NAME_THREAD               0x406D1388
 184
 185 /* Helper structure */
 186 typedef struct tagTHREADNAME_INFO
 187 {
 188    DWORD   dwType;     /* Must be 0x1000 */
 189    LPCTSTR szName;     /* Pointer to name - limited to 9 bytes (8 characters + terminator) */
 190    DWORD   dwThreadID; /* Thread ID (-1 = caller thread) */
 191    DWORD   dwFlags;    /* Reserved for future use.  Must be zero. */
 192 } THREADNAME_INFO;
 193
 194 typedef struct tagDBG_THREAD {
 195     struct tagDBG_PROCESS*      process;
 196     HANDLE                      handle;
 197     DWORD                       tid;
 198     LPVOID                      start;
 199     LPVOID                      teb;
 200     int                         wait_for_first_exception;
 201     enum dbg_mode               dbg_mode;
 202     enum exec_mode              dbg_exec_mode;
 203     int                         dbg_exec_count;
 204     DBG_BREAKPOINT              stepOverBP;
 205     char                        name[9];
 206     struct tagDBG_THREAD*       next;
 207     struct tagDBG_THREAD*       prev;
 208 } DBG_THREAD;
 209
 210 typedef struct tagDBG_DELAYED_BP {
 211     int                         lineno;
 212     char*                       name;
 213 } DBG_DELAYED_BP;
 214
 215 typedef struct tagDBG_PROCESS {
 216     HANDLE                      handle;
 217     DWORD                       pid;
 218     const char*                 imageName;
 219     DBG_THREAD*                 threads;
 220     int                         num_threads;
 221     unsigned                    continue_on_first_exception;
 222     struct tagDBG_MODULE**      modules;
 223     int                         num_modules;
 224     unsigned long               dbg_hdr_addr;
 225     DBG_DELAYED_BP*             delayed_bp;
 226     int                         num_delayed_bp;
 227     /*
 228      * This is an index we use to keep track of the debug information
 229      * when we have multiple sources.  We use the same database to also
 230      * allow us to do an 'info shared' type of deal, and we use the index
 231      * to eliminate duplicates.
 232      */
 233     int                         next_index;
 234     struct tagDBG_PROCESS*      next;
 235     struct tagDBG_PROCESS*      prev;
 236 } DBG_PROCESS;
 237
 238 extern  DBG_PROCESS*    DEBUG_CurrProcess;
 239 extern  DBG_THREAD*     DEBUG_CurrThread;
 240 extern  DWORD           DEBUG_CurrTid;
 241 extern  DWORD           DEBUG_CurrPid;
 242 extern  CONTEXT         DEBUG_context;
 243 extern  BOOL            DEBUG_interactiveP;
 244
 245 #define DEBUG_READ_MEM(addr, buf, len) \
 246       (ReadProcessMemory(DEBUG_CurrProcess->handle, (addr), (buf), (len), NULL))
 247
 248 #define DEBUG_WRITE_MEM(addr, buf, len) \
 249       (WriteProcessMemory(DEBUG_CurrProcess->handle, (addr), (buf), (len), NULL))
 250
 251 #define DEBUG_READ_MEM_VERBOSE(addr, buf, len) \
 252       (DEBUG_READ_MEM((addr), (buf), (len)) || (DEBUG_InvalLinAddr( addr ),0))
 253
 254 #define DEBUG_WRITE_MEM_VERBOSE(addr, buf, len) \
 255       (DEBUG_WRITE_MEM((addr), (buf), (len)) || (DEBUG_InvalLinAddr( addr ),0))
 256
 257 enum DbgInfoLoad {DIL_DEFERRED, DIL_LOADED, DIL_NOINFO, DIL_ERROR};
 258 enum DbgModuleType {DMT_UNKNOWN, DMT_ELF, DMT_NE, DMT_PE};
 259
 260 typedef struct tagDBG_MODULE {
 261    void*                        load_addr;
 262    unsigned long                size;
 263    char*                        module_name;
 264    enum DbgInfoLoad             dil;
 265    enum DbgModuleType           type;
 266    unsigned short               main : 1;
 267    short int                    dbg_index;
 268    HMODULE                      handle;
 269    struct tagMSC_DBG_INFO*      msc_info;
 270    struct tagELF_DBG_INFO*      elf_info;
 271 } DBG_MODULE;
 272
 273 typedef struct {
 274    DWORD                val;
 275    const char*          name;
 276    LPDWORD              pval;
 277    struct datatype*     type;
 278 } DBG_INTVAR;
 279
 280 #define OFFSET_OF(__c,__f)              ((int)(((char*)&(((__c*)0)->__f))-((char*)0)))
 281
 282   /* from winelib.so */
 283 extern void DEBUG_ExternalDebugger(void);
 284
 285   /* debugger/break.c */
 286 extern void DEBUG_SetBreakpoints( BOOL set );
 287 extern void DEBUG_AddBreakpoint( const DBG_VALUE *addr, BOOL (*func)(void) );
 288 extern void DEBUG_AddBreakpointFromId( const char *name, int lineno );
 289 extern void DEBUG_AddBreakpointFromLineno( int lineno );
 290 extern void DEBUG_AddWatchpoint( const DBG_VALUE *addr, int is_write );
 291 extern void DEBUG_AddWatchpointFromId( const char *name );
 292 extern void DEBUG_CheckDelayedBP( void );
 293 extern void DEBUG_DelBreakpoint( int num );
 294 extern void DEBUG_EnableBreakpoint( int num, BOOL enable );
 295 extern void DEBUG_InfoBreakpoints(void);
 296 extern BOOL DEBUG_HandleTrap(void);
 297 extern BOOL DEBUG_ShouldContinue( DBG_ADDR *addr, DWORD code, enum exec_mode mode,
 298                                   int * count );
 299 extern void DEBUG_SuspendExecution( void );
 300 extern enum exec_mode DEBUG_RestartExecution( enum exec_mode mode, int count );
 301 extern BOOL DEBUG_IsFctReturn(void);
 302 extern int  DEBUG_AddBPCondition(int bpnum, struct expr * exp);
 303
 304   /* debugger/db_disasm.c */
 305 extern void DEBUG_Disasm( DBG_ADDR *addr, int display );
 306
 307   /* debugger/dbg.y */
 308 extern enum exit_mode DEBUG_Parser(void);
 309 extern void DEBUG_Exit( DWORD );
 310
 311   /* debugger/debug.l */
 312 extern void DEBUG_FlushSymbols(void);
 313 extern char*DEBUG_MakeSymbol(const char*);
 314 extern int  DEBUG_ReadLine(const char* pfx, char* buffer, int size, int flush_sym, int keep_hist);
 315
 316   /* debugger/display.c */
 317 extern int DEBUG_DoDisplay(void);
 318 extern int DEBUG_AddDisplay(struct expr * exp, int count, char format);
 319 extern int DEBUG_DoDisplay(void);
 320 extern int DEBUG_DelDisplay(int displaynum);
 321 extern int DEBUG_InfoDisplay(void);
 322
 323   /* debugger/editline.c */
 324 extern char * readline(const char *);
 325 extern void add_history(char *);
 326
 327   /* debugger/expr.c */
 328 extern void DEBUG_FreeExprMem(void);
 329 struct expr * DEBUG_IntVarExpr(const char* name);
 330 struct expr * DEBUG_SymbolExpr(const char * name);
 331 struct expr * DEBUG_ConstExpr(int val);
 332 struct expr * DEBUG_StringExpr(const char * str);
 333 struct expr * DEBUG_SegAddr(struct expr *, struct expr *);
 334 struct expr * DEBUG_USConstExpr(unsigned int val);
 335 struct expr * DEBUG_BinopExpr(int oper, struct expr *, struct expr *);
 336 struct expr * DEBUG_UnopExpr(int oper, struct expr *);
 337 struct expr * DEBUG_StructPExpr(struct expr *, const char * element);
 338 struct expr * DEBUG_StructExpr(struct expr *, const char * element);
 339 struct expr * DEBUG_ArrayExpr(struct expr *, struct expr * index);
 340 struct expr * DEBUG_CallExpr(const char *, int nargs, ...);
 341 struct expr * DEBUG_TypeCastExpr(struct datatype *, struct expr *);
 342 extern DBG_VALUE DEBUG_EvalExpr(struct expr *);
 343 extern int DEBUG_DelDisplay(int displaynum);
 344 extern struct expr * DEBUG_CloneExpr(const struct expr * exp);
 345 extern int DEBUG_FreeExpr(struct expr * exp);
 346 extern int DEBUG_DisplayExpr(const struct expr * exp);
 347
 348   /* debugger/hash.c */
 349 extern struct name_hash * DEBUG_AddSymbol( const char *name,
 350                                            const DBG_VALUE *addr,
 351                                            const char *sourcefile,
 352                                            int flags);
 353 extern int DEBUG_GetSymbolValue( const char * name, const int lineno,
 354                                  DBG_VALUE *addr, int );
 355 extern BOOL DEBUG_SetSymbolValue( const char * name, const DBG_VALUE *addr );
 356 extern const char * DEBUG_FindNearestSymbol( const DBG_ADDR *addr, int flag,
 357                                              struct name_hash ** rtn,
 358                                              unsigned int ebp,
 359                                              struct list_id * source);
 360 extern void DEBUG_ReadSymbolTable( const char * filename );
 361 extern void DEBUG_AddLineNumber( struct name_hash * func, int line_num,
 362                                  unsigned long offset );
 363 extern struct wine_locals *
 364             DEBUG_AddLocal( struct name_hash * func, int regno,
 365                             int offset,
 366                             int pc_start,
 367                             int pc_end,
 368                             char * name);
 369 extern int DEBUG_CheckLinenoStatus(const DBG_ADDR *addr);
 370 extern void DEBUG_GetFuncInfo(struct list_id * ret, const char * file,
 371                               const char * func);
 372 extern int DEBUG_SetSymbolSize(struct name_hash * sym, unsigned int len);
 373 extern int DEBUG_SetSymbolBPOff(struct name_hash * sym, unsigned int len);
 374 extern int DEBUG_GetSymbolAddr(struct name_hash * sym, DBG_ADDR * addr);
 375 extern int DEBUG_cmp_sym(const void * p1, const void * p2);
 376 extern BOOL DEBUG_GetLineNumberAddr( const struct name_hash *, const int lineno,
 377                                      DBG_ADDR *addr, int bp_flag );
 378
 379 extern int DEBUG_SetLocalSymbolType(struct wine_locals * sym,
 380                                     struct datatype * type);
 381 extern BOOL DEBUG_Normalize(struct name_hash * nh );
 382
 383   /* debugger/info.c */
 384 extern void DEBUG_PrintBasic( const DBG_VALUE* value, int count, char format );
 385 extern struct symbol_info DEBUG_PrintAddress( const DBG_ADDR *addr,
 386                                               enum dbg_mode mode, int flag );
 387 extern void DEBUG_Help(void);
 388 extern void DEBUG_HelpInfo(void);
 389 extern struct symbol_info DEBUG_PrintAddressAndArgs( const DBG_ADDR *addr,
 390                                                      enum dbg_mode mode,
 391                                                      unsigned int ebp,
 392                                                      int flag );
 393 extern void DEBUG_InfoClass(const char* clsName);
 394 extern void DEBUG_WalkClasses(void);
 395 extern void DEBUG_WalkModref(DWORD p);
 396 extern void DEBUG_DumpModule(DWORD mod);
 397 extern void DEBUG_WalkModules(void);
 398 extern void DEBUG_WalkProcess(void);
 399 extern void DEBUG_WalkThreads(void);
 400 extern void DEBUG_DumpQueue(DWORD q);
 401 extern void DEBUG_WalkQueues(void);
 402 extern void DEBUG_InfoSegments(DWORD s, int v);
 403 extern void DEBUG_InfoVirtual(void);
 404 extern void DEBUG_InfoWindow(HWND hWnd);
 405 extern void DEBUG_WalkWindows(HWND hWnd, int indent);
 406
 407   /* debugger/memory.c */
 408 extern int  DEBUG_ReadMemory( const DBG_VALUE* value );
 409 extern void DEBUG_WriteMemory( const DBG_VALUE* val, int value );
 410 extern void DEBUG_ExamineMemory( const DBG_VALUE *addr, int count, char format);
 411 extern void DEBUG_InvalAddr( const DBG_ADDR* addr );
 412 extern void DEBUG_InvalLinAddr( void* addr );
 413 extern DWORD DEBUG_ToLinear( const DBG_ADDR *address );
 414 extern void DEBUG_GetCurrentAddress( DBG_ADDR * );
 415 extern BOOL DEBUG_GrabAddress( DBG_VALUE* value, BOOL fromCode );
 416 extern enum dbg_mode DEBUG_GetSelectorType( WORD sel );
 417 #ifdef __i386__
 418 extern void DEBUG_FixAddress( DBG_ADDR *address, DWORD def );
 419 extern int  DEBUG_IsSelectorSystem( WORD sel );
 420 #endif
 421
 422   /* debugger/module.c */
 423 extern int  DEBUG_LoadEntryPoints( const char * prefix );
 424 extern void DEBUG_LoadModule32( const char* name, HANDLE hFile, DWORD base );
 425 extern DBG_MODULE* DEBUG_AddModule(const char* name, enum DbgModuleType type,
 426                                    void* mod_addr, u_long size, HMODULE hmod);
 427 extern DBG_MODULE* DEBUG_FindModuleByName(const char* name, enum DbgModuleType type);
 428 extern DBG_MODULE* DEBUG_FindModuleByHandle(HANDLE handle, enum DbgModuleType type);
 429 extern DBG_MODULE* DEBUG_FindModuleByAddr(void* addr, enum DbgModuleType type);
 430 extern DBG_MODULE* DEBUG_GetProcessMainModule(DBG_PROCESS* process);
 431 extern DBG_MODULE* DEBUG_RegisterPEModule(HMODULE, u_long load_addr, u_long size,
 432                                           const char* name);
 433 extern DBG_MODULE* DEBUG_RegisterELFModule(u_long load_addr, u_long size,
 434                                            const char* name);
 435 extern enum DbgInfoLoad DEBUG_RegisterPEDebugInfo(DBG_MODULE* wmod, HANDLE hFile,
 436                                                   void* _nth, unsigned long nth_ofs);
 437 extern void DEBUG_ReportDIL(enum DbgInfoLoad dil, const char* pfx,
 438                             const char* filename, DWORD load_addr);
 439 extern void DEBUG_InfoShare(void);
 440
 441   /* debugger/msc.c */
 442 extern enum DbgInfoLoad DEBUG_RegisterMSCDebugInfo(DBG_MODULE* module, HANDLE hFile,
 443                                                    void* nth, unsigned long nth_ofs);
 444 extern enum DbgInfoLoad DEBUG_RegisterStabsDebugInfo(DBG_MODULE* module,
 445                                                      HANDLE hFile, void* nth,
 446                                                      unsigned long nth_ofs);
 447 extern void DEBUG_InitCVDataTypes(void);
 448
 449   /* debugger/registers.c */
 450 extern void DEBUG_InfoRegisters(void);
 451 extern BOOL DEBUG_ValidateRegisters(void);
 452
 453   /* debugger/source.c */
 454 extern void DEBUG_ShowDir(void);
 455 extern void DEBUG_AddPath(const char * path);
 456 extern void DEBUG_List(struct list_id * line1, struct list_id * line2,
 457                        int delta);
 458 extern void DEBUG_NukePath(void);
 459 extern void DEBUG_Disassemble(const DBG_VALUE *, const DBG_VALUE*, int offset);
 460 extern BOOL DEBUG_DisassembleInstruction(DBG_ADDR *addr);
 461
 462   /* debugger/stack.c */
 463 extern void DEBUG_InfoStack(void);
 464 extern void DEBUG_BackTrace(DWORD threadID, BOOL noisy);
 465 extern int  DEBUG_InfoLocals(void);
 466 extern int  DEBUG_SetFrame(int newframe);
 467 extern int  DEBUG_GetCurrentFrame(struct name_hash ** name,
 468                                   unsigned int * eip,
 469                                   unsigned int * ebp);
 470
 471   /* debugger/stabs.c */
 472 extern enum DbgInfoLoad DEBUG_ReadExecutableDbgInfo(const char* exe_name);
 473 extern enum DbgInfoLoad DEBUG_ParseStabs(char * addr, unsigned int load_offset,
 474                                          unsigned int staboff, int stablen,
 475                                          unsigned int strtaboff, int strtablen);
 476
 477   /* debugger/types.c */
 478 extern int DEBUG_nchar;
 479 extern void DEBUG_InitTypes(void);
 480 extern struct datatype * DEBUG_NewDataType(enum debug_type xtype,
 481                                            const char * typename);
 482 extern unsigned int DEBUG_TypeDerefPointer(const DBG_VALUE *value,
 483                                            struct datatype ** newtype);
 484 extern int DEBUG_AddStructElement(struct datatype * dt,
 485                                   char * name, struct datatype * type,
 486                                   int offset, int size);
 487 extern int DEBUG_SetStructSize(struct datatype * dt, int size);
 488 extern int DEBUG_SetPointerType(struct datatype * dt, struct datatype * dt2);
 489 extern int DEBUG_SetArrayParams(struct datatype * dt, int min, int max,
 490                                 struct datatype * dt2);
 491 extern void DEBUG_Print( const DBG_VALUE *addr, int count, char format, int level );
 492 extern unsigned int DEBUG_FindStructElement(DBG_VALUE * addr,
 493                                             const char * ele_name, int * tmpbuf);
 494 extern struct datatype * DEBUG_GetPointerType(struct datatype * dt);
 495 extern int DEBUG_GetObjectSize(struct datatype * dt);
 496 extern unsigned int DEBUG_ArrayIndex(const DBG_VALUE * addr, DBG_VALUE * result,
 497                                      int index);
 498 extern struct datatype * DEBUG_FindOrMakePointerType(struct datatype * reftype);
 499 extern long long int DEBUG_GetExprValue(const DBG_VALUE * addr, char ** format);
 500 extern int DEBUG_SetBitfieldParams(struct datatype * dt, int offset,
 501                                    int nbits, struct datatype * dt2);
 502 extern int DEBUG_CopyFieldlist(struct datatype * dt, struct datatype * dt2);
 503 extern enum debug_type DEBUG_GetType(struct datatype * dt);
 504 extern struct datatype * DEBUG_TypeCast(enum debug_type, const char *);
 505 extern int DEBUG_PrintTypeCast(const struct datatype *);
 506 extern int DEBUG_PrintType( const DBG_VALUE* addr );
 507 extern struct datatype * DEBUG_GetBasicType(enum debug_type_basic);
 508
 509   /* debugger/winedbg.c */
 510 #define DBG_CHN_MESG    1
 511 #define DBG_CHN_ERR     2
 512 #define DBG_CHN_WARN    4
 513 #define DBG_CHN_FIXME   8
 514 #define DBG_CHN_TRACE   16
 515 extern void     DEBUG_Output(int chn, const char* buffer, int len);
 516 #ifdef __GNUC__
 517 extern int      DEBUG_Printf(int chn, const char* format, ...) __attribute__((format (printf,2,3)));
 518 #else
 519 extern int      DEBUG_Printf(int chn, const char* format, ...);
 520 #endif
 521 extern DBG_INTVAR*      DEBUG_GetIntVar(const char*);
 522 extern BOOL DEBUG_Attach(DWORD pid, BOOL cofe);
 523 extern BOOL DEBUG_Detach(void);
 524 extern void DEBUG_Run(const char* args);
 525 extern DBG_PROCESS*     DEBUG_GetProcess(DWORD pid);
 526 extern DBG_THREAD*      DEBUG_GetThread(DBG_PROCESS* p, DWORD tid);
 527 extern int curr_frame;
 528
 529 /* Choose your allocator! */
 530 #if 1
 531 /* this one is libc's fast one */
 532 extern void*    DEBUG_XMalloc(size_t size);
 533 extern void*    DEBUG_XReAlloc(void *ptr, size_t size);
 534 extern char*    DEBUG_XStrDup(const char *str);
 535
 536 #define DBG_alloc(x)            DEBUG_XMalloc(x)
 537 #define DBG_realloc(x,y)        DEBUG_XReAlloc(x,y)
 538 #define DBG_free(x)             free(x)
 539 #define DBG_strdup(x)           DEBUG_XStrDup(x)
 540 #else
 541 /* this one is slow (takes 5 minutes to load the debugger on my machine),
 542    if someone could make optimized routines so it wouldn't
 543    take so long to load, it could be made default) */
 544 #define DBG_alloc(x) HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,x)
 545 #define DBG_realloc(x,y) HeapReAlloc(GetProcessHeap(),0,x,y)
 546 #define DBG_free(x) HeapFree(GetProcessHeap(),0,x)
 547 inline static LPSTR DBG_strdup( LPCSTR str )
 548 {
 549     INT len = strlen(str) + 1;
 550     LPSTR p = DBG_alloc( len );
 551     if (p) memcpy( p, str, len );
 552     return p;
 553 }
 554 #endif
 555
 556 #define DEBUG_STATUS_OFFSET             0x80003000
 557 #define DEBUG_STATUS_INTERNAL_ERROR     (DEBUG_STATUS_OFFSET+0)
 558 #define DEBUG_STATUS_NO_SYMBOL          (DEBUG_STATUS_OFFSET+1)
 559 #define DEBUG_STATUS_DIV_BY_ZERO        (DEBUG_STATUS_OFFSET+2)
 560 #define DEBUG_STATUS_BAD_TYPE           (DEBUG_STATUS_OFFSET+3)
 561 #define DEBUG_STATUS_NO_FIELD           (DEBUG_STATUS_OFFSET+4)
 562
 563 extern DBG_INTVAR               DEBUG_IntVars[];
 564
 565 #define  DBG_IVARNAME(_var)     DEBUG_IV_##_var
 566 #define  DBG_IVARSTRUCT(_var)   DEBUG_IntVars[DBG_IVARNAME(_var)]
 567 #define  DBG_IVAR(_var)         (*(DBG_IVARSTRUCT(_var).pval))
 568 #define  INTERNAL_VAR(_var,_val,_ref,_typ) DBG_IVARNAME(_var),
 569 enum debug_int_var {
 570 #include "intvar.h"
 571    DBG_IV_LAST
 572 };
 573 #undef   INTERNAL_VAR
 574
 575 #endif  /* __WINE_DEBUGGER_H */