programs/winedbg/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  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22
  23 #include "config.h"
  24 #include "wine/port.h"
  25
  26 #include <stdlib.h>
  27 #include <string.h>
  28
  29 #include "debugger.h"
  30 #include "winbase.h"
  31
  32 #ifdef __i386__
  33 #define IS_VM86_MODE() (DEBUG_context.EFlags & V86_FLAG)
  34 #endif
  35
  36 static  void    DEBUG_Die(const char* msg)
  37 {
  38    DEBUG_Printf(DBG_CHN_MESG, msg);
  39    exit(1);
  40 }
  41
  42 void*   DEBUG_XMalloc(size_t size)
  43 {
  44    void *res = malloc(size ? size : 1);
  45    if (res == NULL)
  46       DEBUG_Die("Memory exhausted.\n");
  47    memset(res, 0, size);
  48    return res;
  49 }
  50
  51 void* DEBUG_XReAlloc(void *ptr, size_t size)
  52 {
  53    void* res = realloc(ptr, size);
  54    if ((res == NULL) && size)
  55       DEBUG_Die("Memory exhausted.\n");
  56    return res;
  57 }
  58
  59 char*   DEBUG_XStrDup(const char *str)
  60 {
  61    char *res = strdup(str);
  62    if (!res)
  63       DEBUG_Die("Memory exhausted.\n");
  64    return res;
  65 }
  66
  67 enum dbg_mode DEBUG_GetSelectorType( WORD sel )
  68 {
  69 #ifdef __i386__
  70     LDT_ENTRY   le;
  71
  72     if (IS_VM86_MODE()) return MODE_VM86;
  73     if (sel == 0) return MODE_32;
  74     if (GetThreadSelectorEntry( DEBUG_CurrThread->handle, sel, &le))
  75         return le.HighWord.Bits.Default_Big ? MODE_32 : MODE_16;
  76     /* selector doesn't exist */
  77     return MODE_INVALID;
  78 #else
  79     return MODE_32;
  80 #endif
  81 }
  82 #ifdef __i386__
  83 void DEBUG_FixAddress( DBG_ADDR *addr, DWORD def)
  84 {
  85    if (addr->seg == 0xffffffff) addr->seg = def;
  86    if (DEBUG_IsSelectorSystem(addr->seg)) addr->seg = 0;
  87 }
  88
  89 /* Determine if sel is a system selector (i.e. not managed by Wine) */
  90 BOOL    DEBUG_IsSelectorSystem(WORD sel)
  91 {
  92     if (IS_VM86_MODE()) return FALSE;  /* no system selectors in vm86 mode */
  93     return !(sel & 4) || ((sel >> 3) < 17);
  94 }
  95 #endif /* __i386__ */
  96
  97 DWORD DEBUG_ToLinear( const DBG_ADDR *addr )
  98 {
  99 #ifdef __i386__
 100    LDT_ENTRY    le;
 101
 102    if (IS_VM86_MODE()) return (DWORD)(LOWORD(addr->seg) << 4) + addr->off;
 103
 104    if (DEBUG_IsSelectorSystem(addr->seg))
 105       return addr->off;
 106
 107    if (GetThreadSelectorEntry( DEBUG_CurrThread->handle, addr->seg, &le)) {
 108       return (le.HighWord.Bits.BaseHi << 24) + (le.HighWord.Bits.BaseMid << 16) + le.BaseLow + addr->off;
 109    }
 110    return 0;
 111 #else
 112    return addr->off;
 113 #endif
 114 }
 115
 116 void DEBUG_GetCurrentAddress( DBG_ADDR *addr )
 117 {
 118 #ifdef __i386__
 119     addr->seg  = DEBUG_context.SegCs;
 120
 121     if (DEBUG_IsSelectorSystem(addr->seg))
 122        addr->seg = 0;
 123     addr->off  = DEBUG_context.Eip;
 124 #elif defined(__sparc__)
 125     addr->seg = 0;
 126     addr->off = DEBUG_context.pc;
 127 #elif defined(__powerpc__)
 128     addr->seg = 0;
 129     addr->off = DEBUG_context.Iar;
 130 #else
 131 #       error You must define GET_IP for this CPU
 132 #endif
 133 }
 134
 135 void    DEBUG_InvalAddr( const DBG_ADDR* addr )
 136 {
 137    DEBUG_Printf(DBG_CHN_MESG,"*** Invalid address ");
 138    DEBUG_PrintAddress(addr, DEBUG_CurrThread->dbg_mode, FALSE);
 139    DEBUG_Printf(DBG_CHN_MESG,"\n");
 140    if (DBG_IVAR(ExtDbgOnInvalidAddress)) DEBUG_ExternalDebugger();
 141 }
 142
 143 void    DEBUG_InvalLinAddr( void* addr )
 144 {
 145    DBG_ADDR address;
 146
 147    address.seg = 0;
 148    address.off = (unsigned long)addr;
 149    DEBUG_InvalAddr( &address );
 150 }
 151
 152 /***********************************************************************
 153  *           DEBUG_ReadMemory
 154  *
 155  * Read a memory value.
 156  */
 157 /* FIXME: this function is now getting closer and closer to
 158  * DEBUG_ExprGetValue. They should be merged...
 159  */
 160 int DEBUG_ReadMemory( const DBG_VALUE* val )
 161 {
 162     int         value = 0; /* to clear any unused byte */
 163     int         os = DEBUG_GetObjectSize(val->type);
 164
 165     assert(sizeof(value) >= os);
 166
 167     /* FIXME: only works on little endian systems */
 168
 169     if (val->cookie == DV_TARGET) {
 170        DBG_ADDR addr = val->addr;
 171        void*    lin;
 172
 173 #ifdef __i386__
 174        DEBUG_FixAddress( &addr, DEBUG_context.SegDs );
 175 #endif
 176        lin = (void*)DEBUG_ToLinear( &addr );
 177
 178        DEBUG_READ_MEM_VERBOSE(lin, &value, os);
 179     } else {
 180        if (val->addr.off)
 181           memcpy(&value, (void*)val->addr.off, os);
 182     }
 183     return value;
 184 }
 185
 186
 187 /***********************************************************************
 188  *           DEBUG_WriteMemory
 189  *
 190  * Store a value in memory.
 191  */
 192 void DEBUG_WriteMemory( const DBG_VALUE* val, int value )
 193 {
 194     int         os = DEBUG_GetObjectSize(val->type);
 195
 196     assert(sizeof(value) >= os);
 197
 198     /* FIXME: only works on little endian systems */
 199
 200     if (val->cookie == DV_TARGET) {
 201        DBG_ADDR addr = val->addr;
 202        void*    lin;
 203
 204 #ifdef __i386__
 205        DEBUG_FixAddress( &addr, DEBUG_context.SegDs );
 206 #endif
 207        lin = (void*)DEBUG_ToLinear( &addr );
 208        DEBUG_WRITE_MEM_VERBOSE(lin, &value, os);
 209     } else {
 210        memcpy((void*)val->addr.off, &value, os);
 211     }
 212 }
 213
 214 /***********************************************************************
 215  *           DEBUG_GrabAddress
 216  *
 217  * Get the address from a value
 218  */
 219 BOOL DEBUG_GrabAddress( DBG_VALUE* value, BOOL fromCode )
 220 {
 221     assert(value->cookie == DV_TARGET || value->cookie == DV_HOST);
 222
 223 #ifdef __i386__
 224     DEBUG_FixAddress( &value->addr,
 225                       (fromCode) ? DEBUG_context.SegCs : DEBUG_context.SegDs);
 226 #endif
 227
 228     /*
 229      * Dereference pointer to get actual memory address we need to be
 230      * reading.  We will use the same segment as what we have already,
 231      * and hope that this is a sensible thing to do.
 232      */
 233     if (value->type != NULL) {
 234         if (value->type == DEBUG_GetBasicType(DT_BASIC_CONST_INT)) {
 235             /*
 236              * We know that we have the actual offset stored somewhere
 237              * else in 32-bit space.  Grab it, and we
 238              * should be all set.
 239              */
 240             unsigned int  seg2 = value->addr.seg;
 241             value->addr.seg = 0;
 242             value->addr.off = DEBUG_GetExprValue(value, NULL);
 243             value->addr.seg = seg2;
 244         } else {
 245             struct datatype     * testtype;
 246
 247             if (DEBUG_TypeDerefPointer(value, &testtype) == 0)
 248                 return FALSE;
 249             if (testtype != NULL || value->type == DEBUG_GetBasicType(DT_BASIC_CONST_INT))
 250                 value->addr.off = DEBUG_GetExprValue(value, NULL);
 251         }
 252     } else if (!value->addr.seg && !value->addr.off) {
 253         DEBUG_Printf(DBG_CHN_MESG,"Invalid expression\n");
 254         return FALSE;
 255     }
 256     return TRUE;
 257 }
 258
 259 /***********************************************************************
 260  *           DEBUG_ExamineMemory
 261  *
 262  * Implementation of the 'x' command.
 263  */
 264 void DEBUG_ExamineMemory( const DBG_VALUE *_value, int count, char format )
 265 {
 266     DBG_VALUE             value = *_value;
 267     int                   i;
 268     unsigned char       * pnt;
 269
 270     if (!DEBUG_GrabAddress(&value, (format == 'i'))) return;
 271
 272     if (format != 'i' && count > 1)
 273     {
 274         DEBUG_PrintAddress( &value.addr, DEBUG_CurrThread->dbg_mode, FALSE );
 275         DEBUG_Printf(DBG_CHN_MESG,": ");
 276     }
 277
 278     pnt = (void*)DEBUG_ToLinear( &value.addr );
 279
 280     switch(format)
 281     {
 282          case 'u':
 283                 if (count == 1) count = 256;
 284                 DEBUG_nchar += DEBUG_PrintStringW(DBG_CHN_MESG, &value.addr, count);
 285                 DEBUG_Printf(DBG_CHN_MESG, "\n");
 286                 return;
 287         case 's':
 288                 DEBUG_nchar += DEBUG_PrintStringA(DBG_CHN_MESG, &value.addr, count);
 289                 DEBUG_Printf(DBG_CHN_MESG, "\n");
 290                 return;
 291         case 'i':
 292                 while (count-- && DEBUG_DisassembleInstruction( &value.addr ));
 293                 return;
 294         case 'g':
 295                 while (count--)
 296                 {
 297                     GUID guid;
 298                     if (!DEBUG_READ_MEM_VERBOSE(pnt, &guid, sizeof(guid))) break;
 299                     DEBUG_Printf(DBG_CHN_MESG,"{%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}\n",
 300                                  guid.Data1, guid.Data2, guid.Data3,
 301                                  guid.Data4[0], guid.Data4[1], guid.Data4[2], guid.Data4[3],
 302                                  guid.Data4[4], guid.Data4[5], guid.Data4[6], guid.Data4[7] );
 303                     pnt += sizeof(guid);
 304                     value.addr.off += sizeof(guid);
 305                     if (count)
 306                     {
 307                         DEBUG_PrintAddress( &value.addr, DEBUG_CurrThread->dbg_mode, FALSE );
 308                         DEBUG_Printf(DBG_CHN_MESG,": ");
 309                     }
 310                 }
 311                 return;
 312
 313 #define DO_DUMP2(_t,_l,_f,_vv) { \
 314                 _t _v; \
 315                 for(i=0; i<count; i++) { \
 316                     if (!DEBUG_READ_MEM_VERBOSE(pnt, &_v, sizeof(_t))) break; \
 317                     DEBUG_Printf(DBG_CHN_MESG,_f,(_vv)); \
 318                     pnt += sizeof(_t); value.addr.off += sizeof(_t); \
 319                     if ((i % (_l)) == (_l)-1) { \
 320                         DEBUG_Printf(DBG_CHN_MESG,"\n"); \
 321                         DEBUG_PrintAddress( &value.addr, DEBUG_CurrThread->dbg_mode, FALSE );\
 322                         DEBUG_Printf(DBG_CHN_MESG,": ");\
 323                     } \
 324                 } \
 325                 DEBUG_Printf(DBG_CHN_MESG,"\n"); \
 326         } \
 327         return
 328 #define DO_DUMP(_t,_l,_f) DO_DUMP2(_t,_l,_f,_v)
 329
 330         case 'x': DO_DUMP(int, 4, " %8.8x");
 331         case 'd': DO_DUMP(unsigned int, 4, " %10d");
 332         case 'w': DO_DUMP(unsigned short, 8, " %04x");
 333         case 'c': DO_DUMP2(char, 32, " %c", (_v < 0x20) ? ' ' : _v);
 334         case 'b': DO_DUMP2(char, 16, " %02x", (_v) & 0xff);
 335         }
 336 }
 337
 338 /******************************************************************
 339  *              DEBUG_PrintStringA
 340  *
 341  * Prints on channel chnl, the string starting at address in target
 342  * address space. The string stops when either len chars (if <> -1)
 343  * have been printed, or the '\0' char is printed
 344  */
 345 int  DEBUG_PrintStringA(int chnl, const DBG_ADDR* address, int len)
 346 {
 347     char*       lin = (void*)DEBUG_ToLinear(address);
 348     char        ach[16+1];
 349     int         i, l;
 350
 351     if (len == -1) len = 32767; /* should be big enough */
 352
 353     /* so that the ach is always terminated */
 354     ach[sizeof(ach) - 1] = '\0';
 355     for (i = len; i >= 0; i -= sizeof(ach) - 1)
 356     {
 357         l = min(sizeof(ach) - 1, i);
 358         DEBUG_READ_MEM_VERBOSE(lin, ach, l);
 359         l = strlen(ach);
 360         DEBUG_OutputA(chnl, ach, l);
 361         lin += l;
 362         if (l < sizeof(ach) - 1) break;
 363     }
 364     return len - i; /* number of actually written chars */
 365 }
 366
 367 int  DEBUG_PrintStringW(int chnl, const DBG_ADDR* address, int len)
 368 {
 369     char*       lin = (void*)DEBUG_ToLinear(address);
 370     WCHAR       wch;
 371     int         ret = 0;
 372
 373     if (len == -1) len = 32767; /* should be big enough */
 374     while (len--)
 375     {
 376         if (!DEBUG_READ_MEM_VERBOSE(lin, &wch, sizeof(wch)) || !wch)
 377             break;
 378         lin += sizeof(wch);
 379         DEBUG_OutputW(chnl, &wch, 1);
 380         ret++;
 381     }
 382     return ret;
 383 }