debugger/memory.c

   1 /*
   2  * Debugger memory handling
   3  *
   4  * Copyright 1993 Eric Youngdale
   5  * Copyright 1995 Alexandre Julliard
   6  * Copyright 2000 Eric Pouech
   7  */
   8
   9 #include "config.h"
  10 #include <stdlib.h>
  11 #include <string.h>
  12
  13 #include "debugger.h"
  14 #include "miscemu.h"
  15 #include "winbase.h"
  16
  17 #ifdef __i386__
  18 #include "wine/winbase16.h"
  19
  20 #define DBG_V86_MODULE(seg) ((seg)>>16)
  21 #define IS_SELECTOR_V86(seg) DBG_V86_MODULE(seg)
  22
  23 static  void    DEBUG_Die(const char* msg)
  24 {
  25    DEBUG_Printf(DBG_CHN_MESG, msg);
  26    exit(1);
  27 }
  28
  29 void*   DEBUG_XMalloc(size_t size)
  30 {
  31    void *res = malloc(size ? size : 1);
  32    if (res == NULL)
  33       DEBUG_Die("Memory exhausted.\n");
  34    memset(res, 0, size);
  35    return res;
  36 }
  37
  38 void* DEBUG_XReAlloc(void *ptr, size_t size)
  39 {
  40    void* res = realloc(ptr, size);
  41    if ((res == NULL) && size)
  42       DEBUG_Die("Memory exhausted.\n");
  43    return res;
  44 }
  45
  46 char*   DEBUG_XStrDup(const char *str)
  47 {
  48    char *res = strdup(str);
  49    if (!res)
  50       DEBUG_Die("Memory exhausted.\n");
  51    return res;
  52 }
  53
  54 void DEBUG_FixAddress( DBG_ADDR *addr, DWORD def)
  55 {
  56    if (addr->seg == 0xffffffff) addr->seg = def;
  57    if (!IS_SELECTOR_V86(addr->seg) && DEBUG_IsSelectorSystem(addr->seg)) addr->seg = 0;
  58 }
  59
  60 BOOL  DEBUG_FixSegment( DBG_ADDR* addr )
  61 {
  62    /* V86 mode ? */
  63    if (DEBUG_context.EFlags & V86_FLAG) {
  64       addr->seg |= (DWORD)(GetExePtr(GetCurrentTask())) << 16;
  65       return TRUE;
  66    }
  67    return FALSE;
  68 }
  69
  70 DWORD DEBUG_ToLinear( const DBG_ADDR *addr )
  71 {
  72    LDT_ENTRY    le;
  73
  74    if (IS_SELECTOR_V86(addr->seg))
  75       return (DWORD) DOSMEM_MemoryBase(DBG_V86_MODULE(addr->seg)) + (((addr->seg)&0xFFFF)<<4) + addr->off;
  76    if (DEBUG_IsSelectorSystem(addr->seg))
  77       return addr->off;
  78
  79    if (GetThreadSelectorEntry( DEBUG_CurrThread->handle, addr->seg, &le)) {
  80       return (le.HighWord.Bits.BaseHi << 24) + (le.HighWord.Bits.BaseMid << 16) + le.BaseLow + addr->off;
  81    }
  82    return 0;
  83 }
  84
  85 int     DEBUG_GetSelectorType( WORD sel )
  86 {
  87     LDT_ENTRY   le;
  88
  89     if (sel == 0)
  90         return 32;
  91     if (IS_SELECTOR_V86(sel))
  92         return 16;
  93     if (GetThreadSelectorEntry( DEBUG_CurrThread->handle, sel, &le))
  94         return le.HighWord.Bits.Default_Big ? 32 : 16;
  95          /* selector doesn't exist */
  96     return 0;
  97 }
  98
  99 /* Determine if sel is a system selector (i.e. not managed by Wine) */
 100 BOOL    DEBUG_IsSelectorSystem(WORD sel)
 101 {
 102    return !(sel & 4) || (((sel & 0xFFFF) >> 3) < 17);
 103 }
 104 #endif /* __i386__ */
 105
 106 void DEBUG_GetCurrentAddress( DBG_ADDR *addr )
 107 {
 108 #ifdef __i386__
 109     addr->seg  = DEBUG_context.SegCs;
 110
 111     if (!DEBUG_FixSegment( addr ) && DEBUG_IsSelectorSystem(addr->seg))
 112        addr->seg = 0;
 113     addr->off  = DEBUG_context.Eip;
 114 #else
 115     addr->seg  = 0;
 116     addr->off  = 0;
 117 #endif
 118 }
 119
 120 void    DEBUG_InvalAddr( const DBG_ADDR* addr )
 121 {
 122    DEBUG_Printf(DBG_CHN_MESG,"*** Invalid address ");
 123    DEBUG_PrintAddress(addr, DEBUG_CurrThread->dbg_mode, FALSE);
 124    DEBUG_Printf(DBG_CHN_MESG,"\n");
 125    if (DBG_IVAR(ExtDbgOnInvalidAddress)) DEBUG_ExternalDebugger();
 126 }
 127
 128 void    DEBUG_InvalLinAddr( void* addr )
 129 {
 130    DBG_ADDR address;
 131
 132    address.seg = 0;
 133    address.off = (unsigned long)addr;
 134    DEBUG_InvalAddr( &address );
 135 }
 136
 137 /***********************************************************************
 138  *           DEBUG_ReadMemory
 139  *
 140  * Read a memory value.
 141  */
 142 /* FIXME: this function is now getting closer and closer to
 143  * DEBUG_ExprGetValue. They should be merged...
 144  */
 145 int DEBUG_ReadMemory( const DBG_VALUE* val )
 146 {
 147     int         value = 0; /* to clear any unused byte */
 148     int         os = DEBUG_GetObjectSize(val->type);
 149
 150     assert(sizeof(value) >= os);
 151
 152     /* FIXME: only works on little endian systems */
 153
 154     if (val->cookie == DV_TARGET) {
 155        DBG_ADDR addr = val->addr;
 156        void*    lin;
 157
 158        DEBUG_FixAddress( &addr, DEBUG_context.SegDs );
 159        lin = (void*)DEBUG_ToLinear( &addr );
 160
 161        DEBUG_READ_MEM_VERBOSE(lin, &value, os);
 162     } else {
 163        if (val->addr.off)
 164           memcpy(&value, (void*)val->addr.off, os);
 165     }
 166     return value;
 167 }
 168
 169
 170 /***********************************************************************
 171  *           DEBUG_WriteMemory
 172  *
 173  * Store a value in memory.
 174  */
 175 void DEBUG_WriteMemory( const DBG_VALUE* val, int value )
 176 {
 177     int         os = DEBUG_GetObjectSize(val->type);
 178
 179     assert(sizeof(value) >= os);
 180
 181     /* FIXME: only works on little endian systems */
 182
 183     if (val->cookie == DV_TARGET) {
 184        DBG_ADDR addr = val->addr;
 185        void*    lin;
 186
 187        DEBUG_FixAddress( &addr, DEBUG_context.SegDs );
 188        lin = (void*)DEBUG_ToLinear( &addr );
 189        DEBUG_WRITE_MEM_VERBOSE(lin, &value, os);
 190     } else {
 191        memcpy((void*)val->addr.off, &value, os);
 192     }
 193 }
 194
 195
 196 /***********************************************************************
 197  *           DEBUG_ExamineMemory
 198  *
 199  * Implementation of the 'x' command.
 200  */
 201 void DEBUG_ExamineMemory( const DBG_VALUE *_value, int count, char format )
 202 {
 203     DBG_VALUE             value = *_value;
 204     int                   i;
 205     unsigned char       * pnt;
 206     struct datatype     * testtype;
 207
 208     assert(_value->cookie == DV_TARGET || _value->cookie == DV_HOST);
 209
 210     DEBUG_FixAddress( &value.addr,
 211                       (format == 'i') ?
 212                       DEBUG_context.SegCs :
 213                       DEBUG_context.SegDs );
 214
 215     /*
 216      * Dereference pointer to get actual memory address we need to be
 217      * reading.  We will use the same segment as what we have already,
 218      * and hope that this is a sensible thing to do.
 219      */
 220     if( value.type != NULL )
 221       {
 222         if( value.type == DEBUG_TypeIntConst )
 223           {
 224             /*
 225              * We know that we have the actual offset stored somewhere
 226              * else in 32-bit space.  Grab it, and we
 227              * should be all set.
 228              */
 229             unsigned int  seg2 = value.addr.seg;
 230             value.addr.seg = 0;
 231             value.addr.off = DEBUG_GetExprValue(&value, NULL);
 232             value.addr.seg = seg2;
 233           }
 234         else
 235           {
 236             if (DEBUG_TypeDerefPointer(&value, &testtype) == 0)
 237               return;
 238             if( testtype != NULL || value.type == DEBUG_TypeIntConst )
 239               {
 240                 value.addr.off = DEBUG_GetExprValue(&value, NULL);
 241               }
 242           }
 243       }
 244     else if (!value.addr.seg && !value.addr.off)
 245     {
 246         DEBUG_Printf(DBG_CHN_MESG,"Invalid expression\n");
 247         return;
 248     }
 249
 250     if (format != 'i' && count > 1)
 251     {
 252         DEBUG_PrintAddress( &value.addr, DEBUG_CurrThread->dbg_mode, FALSE );
 253         DEBUG_Printf(DBG_CHN_MESG,": ");
 254     }
 255
 256     pnt = (void*)DEBUG_ToLinear( &value.addr );
 257
 258     switch(format)
 259     {
 260         case 'u': {
 261                 WCHAR wch;
 262                 if (count == 1) count = 256;
 263                 while (count--)
 264                 {
 265                     if (!DEBUG_READ_MEM_VERBOSE(pnt, &wch, sizeof(wch)) || !wch)
 266                        break;
 267                     pnt += sizeof(wch);
 268                     DEBUG_Printf(DBG_CHN_MESG, "%c", (char)wch);
 269                 }
 270                 DEBUG_Printf(DBG_CHN_MESG,"\n");
 271                 return;
 272             }
 273           case 's': {
 274                 char ch;
 275
 276                 if (count == 1) count = 256;
 277                 while (count--)
 278                 {
 279                     if (!DEBUG_READ_MEM_VERBOSE(pnt, &ch, sizeof(ch)) || !ch)
 280                        break;
 281                     pnt++;
 282                     DEBUG_Output(DBG_CHN_MESG, &ch, 1);
 283                 }
 284                 DEBUG_Printf(DBG_CHN_MESG,"\n");
 285                 return;
 286           }
 287         case 'i':
 288                 while (count--)
 289                 {
 290                     DEBUG_PrintAddress( &value.addr, DEBUG_CurrThread->dbg_mode, TRUE );
 291                     DEBUG_Printf(DBG_CHN_MESG,": ");
 292                     DEBUG_Disasm( &value.addr, TRUE );
 293                     DEBUG_Printf(DBG_CHN_MESG,"\n");
 294                 }
 295                 return;
 296 #define DO_DUMP2(_t,_l,_f,_vv) { \
 297                 _t _v; \
 298                 for(i=0; i<count; i++) { \
 299                     if (!DEBUG_READ_MEM_VERBOSE(pnt, &_v, sizeof(_t))) break; \
 300                     DEBUG_Printf(DBG_CHN_MESG,_f,(_vv)); \
 301                     pnt += sizeof(_t); value.addr.off += sizeof(_t); \
 302                     if ((i % (_l)) == (_l)-1) { \
 303                         DEBUG_Printf(DBG_CHN_MESG,"\n"); \
 304                         DEBUG_PrintAddress( &value.addr, DEBUG_CurrThread->dbg_mode, FALSE );\
 305                         DEBUG_Printf(DBG_CHN_MESG,": ");\
 306                     } \
 307                 } \
 308                 DEBUG_Printf(DBG_CHN_MESG,"\n"); \
 309         } \
 310         return
 311 #define DO_DUMP(_t,_l,_f) DO_DUMP2(_t,_l,_f,_v)
 312
 313         case 'x': DO_DUMP(int, 4, " %8.8x");
 314         case 'd': DO_DUMP(unsigned int, 4, " %10d");
 315         case 'w': DO_DUMP(unsigned short, 8, " %04x");
 316         case 'c': DO_DUMP2(char, 32, " %c", (_v < 0x20) ? ' ' : _v);
 317         case 'b': DO_DUMP2(char, 16, " %02x", (_v) & 0xff);
 318         }
 319 }