debugger/memory.c

   1 /*
   2  * Debugger memory handling
   3  *
   4  * Copyright 1993 Eric Youngdale
   5  * Copyright 1995 Alexandre Julliard
   6  */
   7
   8 #include <stdio.h>
   9 #include <stdlib.h>
  10 #include "debugger.h"
  11
  12
  13 /***********************************************************************
  14  *           DEBUG_IsBadReadPtr
  15  *
  16  * Check if we are allowed to read memory at 'address'.
  17  */
  18 BOOL DEBUG_IsBadReadPtr( const DBG_ADDR *address, int size )
  19 {
  20     if (address->seg)  /* segmented addr */
  21         return IsBadReadPtr( (SEGPTR)MAKELONG( (WORD)address->off,
  22                                                (WORD)address->seg ), size );
  23         /* FIXME: should check if resulting linear addr is readable */
  24     else  /* linear address */
  25         return FALSE;  /* FIXME: should do some checks here */
  26 }
  27
  28
  29 /***********************************************************************
  30  *           DEBUG_IsBadWritePtr
  31  *
  32  * Check if we are allowed to write memory at 'address'.
  33  */
  34 BOOL DEBUG_IsBadWritePtr( const DBG_ADDR *address, int size )
  35 {
  36     if (address->seg)  /* segmented addr */
  37         /* Note: we use IsBadReadPtr here because we are */
  38         /* always allowed to write to read-only segments */
  39         return IsBadReadPtr( (SEGPTR)MAKELONG( (WORD)address->off,
  40                                                (WORD)address->seg ), size );
  41         /* FIXME: should check if resulting linear addr is writable */
  42     else  /* linear address */
  43         return FALSE;  /* FIXME: should do some checks here */
  44 }
  45
  46
  47 /***********************************************************************
  48  *           DEBUG_ReadMemory
  49  *
  50  * Read a memory value.
  51  */
  52 int DEBUG_ReadMemory( const DBG_ADDR *address )
  53 {
  54     DBG_ADDR addr = *address;
  55
  56     DBG_FIX_ADDR_SEG( &addr, DS_reg(DEBUG_context) );
  57     if (!DBG_CHECK_READ_PTR( &addr, sizeof(int) )) return 0;
  58     return *(int *)DBG_ADDR_TO_LIN( &addr );
  59 }
  60
  61
  62 /***********************************************************************
  63  *           DEBUG_WriteMemory
  64  *
  65  * Store a value in memory.
  66  */
  67 void DEBUG_WriteMemory( const DBG_ADDR *address, int value )
  68 {
  69     DBG_ADDR addr = *address;
  70
  71     DBG_FIX_ADDR_SEG( &addr, DS_reg(DEBUG_context) );
  72     if (!DBG_CHECK_WRITE_PTR( &addr, sizeof(int) )) return;
  73     *(int *)DBG_ADDR_TO_LIN( &addr ) = value;
  74 }
  75
  76
  77 /***********************************************************************
  78  *           DEBUG_ExamineMemory
  79  *
  80  * Implementation of the 'x' command.
  81  */
  82 void DEBUG_ExamineMemory( const DBG_ADDR *address, int count, char format )
  83 {
  84     DBG_ADDR addr = *address;
  85     unsigned char * pnt;
  86     unsigned int * dump;
  87     unsigned short int * wdump;
  88     int i;
  89
  90     DBG_FIX_ADDR_SEG( &addr, (format == 'i') ?
  91                              CS_reg(DEBUG_context) : DS_reg(DEBUG_context) );
  92
  93     if (format != 'i' && count > 1)
  94     {
  95         DEBUG_PrintAddress( &addr, dbg_mode );
  96         fprintf(stderr,": ");
  97     }
  98
  99     pnt = DBG_ADDR_TO_LIN( &addr );
 100
 101     switch(format)
 102     {
 103         case 's':
 104                 if (count == 1) count = 256;
 105                 while (count--)
 106                 {
 107                     if (!DBG_CHECK_READ_PTR( &addr, sizeof(char) )) return;
 108                     if (!*pnt) break;
 109                     addr.off++;
 110                     fputc( *pnt++, stderr );
 111                 }
 112                 fprintf(stderr,"\n");
 113                 return;
 114
 115         case 'i':
 116                 while (count--)
 117                 {
 118                     DEBUG_PrintAddress( &addr, dbg_mode );
 119                     fprintf(stderr,": ");
 120                     if (!DBG_CHECK_READ_PTR( &addr, 1 )) return;
 121                     DEBUG_Disasm( &addr );
 122                     fprintf(stderr,"\n");
 123                 }
 124                 return;
 125         case 'x':
 126                 dump = (unsigned int *)pnt;
 127                 for(i=0; i<count; i++)
 128                 {
 129                     if (!DBG_CHECK_READ_PTR( &addr, sizeof(int) )) return;
 130                     fprintf(stderr," %8.8x", *dump++);
 131                     addr.off += sizeof(int);
 132                     if ((i % 8) == 7)
 133                     {
 134                         fprintf(stderr,"\n");
 135                         DEBUG_PrintAddress( &addr, dbg_mode );
 136                         fprintf(stderr,": ");
 137                     }
 138                 }
 139                 fprintf(stderr,"\n");
 140                 return;
 141
 142         case 'd':
 143                 dump = (unsigned int *)pnt;
 144                 for(i=0; i<count; i++)
 145                 {
 146                     if (!DBG_CHECK_READ_PTR( &addr, sizeof(int) )) return;
 147                     fprintf(stderr," %d", *dump++);
 148                     addr.off += sizeof(int);
 149                     if ((i % 8) == 7)
 150                     {
 151                         fprintf(stderr,"\n");
 152                         DEBUG_PrintAddress( &addr, dbg_mode );
 153                         fprintf(stderr,": ");
 154                     }
 155                 }
 156                 fprintf(stderr,"\n");
 157                 return;
 158
 159         case 'w':
 160                 wdump = (unsigned short *)pnt;
 161                 for(i=0; i<count; i++)
 162                 {
 163                     if (!DBG_CHECK_READ_PTR( &addr, sizeof(short) )) return;
 164                     fprintf(stderr," %04x", *wdump++);
 165                     addr.off += sizeof(short);
 166                     if ((i % 8) == 7)
 167                     {
 168                         fprintf(stderr,"\n");
 169                         DEBUG_PrintAddress( &addr, dbg_mode );
 170                         fprintf(stderr,": ");
 171                     }
 172                 }
 173                 fprintf(stderr,"\n");
 174                 return;
 175
 176         case 'c':
 177                 for(i=0; i<count; i++)
 178                 {
 179                     if (!DBG_CHECK_READ_PTR( &addr, sizeof(char) )) return;
 180                     if(*pnt < 0x20)
 181                     {
 182                         fprintf(stderr,"  ");
 183                         pnt++;
 184                     }
 185                     else fprintf(stderr," %c", *pnt++);
 186                     addr.off++;
 187                     if ((i % 32) == 31)
 188                     {
 189                         fprintf(stderr,"\n");
 190                         DEBUG_PrintAddress( &addr, dbg_mode );
 191                         fprintf(stderr,": ");
 192                     }
 193                 }
 194                 fprintf(stderr,"\n");
 195                 return;
 196
 197         case 'b':
 198                 for(i=0; i<count; i++)
 199                 {
 200                     if (!DBG_CHECK_READ_PTR( &addr, sizeof(char) )) return;
 201                     fprintf(stderr," %02x", (*pnt++) & 0xff);
 202                     addr.off++;
 203                     if ((i % 16) == 15)
 204                     {
 205                         fprintf(stderr,"\n");
 206                         DEBUG_PrintAddress( &addr, dbg_mode );
 207                         fprintf(stderr,": ");
 208                     }
 209                 }
 210                 fprintf(stderr,"\n");
 211                 return;
 212         }
 213 }