More include optimizations.
[wine] / debugger / memory.c
1 /*
2  * Debugger memory handling
3  *
4  * Copyright 1993 Eric Youngdale
5  * Copyright 1995 Alexandre Julliard
6  */
7
8 #include "config.h"
9 #include <stdio.h>
10 #include <stdlib.h>
11 #include "wine/winbase16.h"
12 #include "debugger.h"
13 #include "miscemu.h"
14
15
16 /************************************************************
17  *   
18  *  Check if linear pointer in [addr, addr+size[
19  *     read  (rwflag == 1)
20  *   or
21  *     write (rwflag == 0)
22  ************************************************************/
23
24 #if defined(linux) || defined(__FreeBSD__) || defined(__OpenBSD__)
25 BOOL DEBUG_checkmap_bad( const char *addr, size_t size, int rwflag)
26 {
27   FILE *fp;
28   char buf[80];      /* temporary line buffer */
29   char prot[5];      /* protection string */
30   char *start, *end;
31   int ret = TRUE;
32
33 #ifdef linux
34   /* 
35      The entries in /proc/self/maps are of the form:
36      08000000-08002000 r-xp 00000000 03:41 2361
37      08002000-08003000 rw-p 00001000 03:41 2361
38      08003000-08005000 rwxp 00000000 00:00 0
39      40000000-40005000 r-xp 00000000 03:41 67219
40      40005000-40006000 rw-p 00004000 03:41 67219
41      40006000-40007000 rw-p 00000000 00:00 0
42      ...
43       start    end     perm   ???    major:minor inode
44
45      Only permissions start and end are used here
46      */
47 #else
48 /*
49     % cat /proc/curproc/map
50     start      end         resident   private perm    type
51     0x1000     0xe000            12         0 r-x COW vnode
52     0xe000     0x10000            2         2 rwx COW vnode
53     0x10000    0x27000            4         4 rwx     default
54     0x800e000  0x800f000          1         1 rw-     default
55     0xefbde000 0xefbfe000         1         1 rwx     default
56     
57     COW = "copy on write"
58 */
59 #endif
60
61   
62 #ifdef linux
63   if (!(fp = fopen("/proc/self/maps", "r")))
64 #else
65   if (!(fp = fopen("/proc/curproc/map", "r")))
66 #endif
67     return FALSE; 
68
69   while (fgets( buf, 79, fp)) {
70 #ifdef linux
71     sscanf(buf, "%x-%x %3s", (int *) &start, (int *) &end, prot);
72 #else
73     sscanf(buf, "%x %x %*d %*d %3s", (int *) &start, (int *) &end, prot);
74 #endif
75     if ( end <= addr)
76       continue;
77     if (start <= addr && addr+size < end) {
78       if (rwflag) 
79         ret = (prot[0] != 'r'); /* test for reading */
80       else
81         ret = (prot[1] != 'w'); /* test for writing */
82     }
83     break;
84   }
85   fclose( fp);
86   return ret;
87 }
88 #else  /* linux || FreeBSD */
89 /* FIXME: code needed for BSD et al. */
90 BOOL DEBUG_checkmap_bad(char *addr, size_t size, int rwflag)
91 {
92     return FALSE;
93 }
94 #endif  /* linux || FreeBSD */
95
96
97 /***********************************************************************
98  *           DEBUG_IsBadReadPtr
99  *
100  * Check if we are allowed to read memory at 'address'.
101  */
102 BOOL DEBUG_IsBadReadPtr( const DBG_ADDR *address, int size )
103 {
104     if (!IS_SELECTOR_V86(address->seg))
105     if (address->seg)  /* segmented addr */
106     {
107         if (IsBadReadPtr16( (SEGPTR)MAKELONG( (WORD)address->off,
108                                               (WORD)address->seg ), size ))
109             return TRUE;
110     }
111     return DEBUG_checkmap_bad( DBG_ADDR_TO_LIN(address), size, 1);
112 }
113
114
115 /***********************************************************************
116  *           DEBUG_IsBadWritePtr
117  *
118  * Check if we are allowed to write memory at 'address'.
119  */
120 BOOL DEBUG_IsBadWritePtr( const DBG_ADDR *address, int size )
121 {
122     if (!IS_SELECTOR_V86(address->seg))
123     if (address->seg)  /* segmented addr */
124     {
125         /* Note: we use IsBadReadPtr here because we are */
126         /* always allowed to write to read-only segments */
127         if (IsBadReadPtr16( (SEGPTR)MAKELONG( (WORD)address->off,
128                                               (WORD)address->seg ), size ))
129             return TRUE;
130     }
131     return DEBUG_checkmap_bad( DBG_ADDR_TO_LIN(address), size, 0);
132 }
133
134
135 /***********************************************************************
136  *           DEBUG_ReadMemory
137  *
138  * Read a memory value.
139  */
140 int DEBUG_ReadMemory( const DBG_ADDR *address )
141 {
142     DBG_ADDR addr = *address;
143
144     DBG_FIX_ADDR_SEG( &addr, DS_reg(&DEBUG_context) );
145     if (!DBG_CHECK_READ_PTR( &addr, sizeof(int) )) return 0;
146     return *(int *)DBG_ADDR_TO_LIN( &addr );
147 }
148
149
150 /***********************************************************************
151  *           DEBUG_WriteMemory
152  *
153  * Store a value in memory.
154  */
155 void DEBUG_WriteMemory( const DBG_ADDR *address, int value )
156 {
157     DBG_ADDR addr = *address;
158
159     DBG_FIX_ADDR_SEG( &addr, DS_reg(&DEBUG_context) );
160     if (!DBG_CHECK_WRITE_PTR( &addr, sizeof(int) )) return;
161     *(int *)DBG_ADDR_TO_LIN( &addr ) = value;
162 }
163
164
165 /***********************************************************************
166  *           DEBUG_ExamineMemory
167  *
168  * Implementation of the 'x' command.
169  */
170 void DEBUG_ExamineMemory( const DBG_ADDR *address, int count, char format )
171 {
172     DBG_ADDR addr =     * address;
173     unsigned int        * dump;
174     int                   i;
175     unsigned char       * pnt;
176     unsigned int          seg2;
177     struct datatype     * testtype;
178     unsigned short int  * wdump;
179
180     DBG_FIX_ADDR_SEG( &addr, (format == 'i') ?
181                              CS_reg(&DEBUG_context) : DS_reg(&DEBUG_context) );
182
183     /*
184      * Dereference pointer to get actual memory address we need to be
185      * reading.  We will use the same segment as what we have already,
186      * and hope that this is a sensible thing to do.
187      */
188     if( addr.type != NULL )
189       {
190         if( addr.type == DEBUG_TypeIntConst )
191           {
192             /*
193              * We know that we have the actual offset stored somewhere
194              * else in 32-bit space.  Grab it, and we
195              * should be all set.
196              */
197             seg2 = addr.seg;
198             addr.seg = 0;
199             addr.off = DEBUG_GetExprValue(&addr, NULL);
200             addr.seg = seg2;
201           }
202         else
203           {
204             if (!DBG_CHECK_READ_PTR( &addr, 1 )) return;
205             DEBUG_TypeDerefPointer(&addr, &testtype);
206             if( testtype != NULL || addr.type == DEBUG_TypeIntConst )
207               {
208                 addr.off = DEBUG_GetExprValue(&addr, NULL);
209               }
210           }
211       }
212     else if (!addr.seg && !addr.off)
213     {
214         fprintf(stderr,"Invalid expression\n");
215         return;
216     }
217
218     if (format != 'i' && count > 1)
219     {
220         DEBUG_PrintAddress( &addr, dbg_mode, FALSE );
221         fprintf(stderr,": ");
222     }
223
224     pnt = DBG_ADDR_TO_LIN( &addr );
225
226     switch(format)
227     {
228         case 'u': {
229                 WCHAR *ptr = (WCHAR*)pnt;
230                 if (count == 1) count = 256;
231                 while (count--)
232                 {
233                     if (!DBG_CHECK_READ_PTR( &addr, sizeof(WCHAR) )) return;
234                     if (!*ptr) break;
235                     addr.off++;
236                     fputc( (char)*ptr++, stderr );
237                 }
238                 fprintf(stderr,"\n");
239                 return;
240             }
241         case 's':
242                 if (count == 1) count = 256;
243                 while (count--)
244                 {
245                     if (!DBG_CHECK_READ_PTR( &addr, sizeof(char) )) return;
246                     if (!*pnt) break;
247                     addr.off++;
248                     fputc( *pnt++, stderr );
249                 }
250                 fprintf(stderr,"\n");
251                 return;
252
253         case 'i':
254                 while (count--)
255                 {
256                     DEBUG_PrintAddress( &addr, dbg_mode, TRUE );
257                     fprintf(stderr,": ");
258                     if (!DBG_CHECK_READ_PTR( &addr, 1 )) return;
259                     DEBUG_Disasm( &addr, TRUE );
260                     fprintf(stderr,"\n");
261                 }
262                 return;
263         case 'x':
264                 dump = (unsigned int *)pnt;
265                 for(i=0; i<count; i++) 
266                 {
267                     if (!DBG_CHECK_READ_PTR( &addr, sizeof(int) )) return;
268                     fprintf(stderr," %8.8x", *dump++);
269                     addr.off += sizeof(int);
270                     if ((i % 8) == 7)
271                     {
272                         fprintf(stderr,"\n");
273                         DEBUG_PrintAddress( &addr, dbg_mode, FALSE );
274                         fprintf(stderr,": ");
275                     }
276                 }
277                 fprintf(stderr,"\n");
278                 return;
279         
280         case 'd':
281                 dump = (unsigned int *)pnt;
282                 for(i=0; i<count; i++) 
283                 {
284                     if (!DBG_CHECK_READ_PTR( &addr, sizeof(int) )) return;
285                     fprintf(stderr," %d", *dump++);
286                     addr.off += sizeof(int);
287                     if ((i % 8) == 7)
288                     {
289                         fprintf(stderr,"\n");
290                         DEBUG_PrintAddress( &addr, dbg_mode, FALSE );
291                         fprintf(stderr,": ");
292                     }
293                 }
294                 fprintf(stderr,"\n");
295                 return;
296         
297         case 'w':
298                 wdump = (unsigned short *)pnt;
299                 for(i=0; i<count; i++) 
300                 {
301                     if (!DBG_CHECK_READ_PTR( &addr, sizeof(short) )) return;
302                     fprintf(stderr," %04x", *wdump++);
303                     addr.off += sizeof(short);
304                     if ((i % 8) == 7)
305                     {
306                         fprintf(stderr,"\n");
307                         DEBUG_PrintAddress( &addr, dbg_mode, FALSE );
308                         fprintf(stderr,": ");
309                     }
310                 }
311                 fprintf(stderr,"\n");
312                 return;
313         
314         case 'c':
315                 for(i=0; i<count; i++) 
316                 {
317                     if (!DBG_CHECK_READ_PTR( &addr, sizeof(char) )) return;
318                     if(*pnt < 0x20)
319                     {
320                         fprintf(stderr,"  ");
321                         pnt++;
322                     }
323                     else fprintf(stderr," %c", *pnt++);
324                     addr.off++;
325                     if ((i % 32) == 31)
326                     {
327                         fprintf(stderr,"\n");
328                         DEBUG_PrintAddress( &addr, dbg_mode, FALSE );
329                         fprintf(stderr,": ");
330                     }
331                 }
332                 fprintf(stderr,"\n");
333                 return;
334         
335         case 'b':
336                 for(i=0; i<count; i++) 
337                 {
338                     if (!DBG_CHECK_READ_PTR( &addr, sizeof(char) )) return;
339                     fprintf(stderr," %02x", (*pnt++) & 0xff);
340                     addr.off++;
341                     if ((i % 16) == 15)
342                     {
343                         fprintf(stderr,"\n");
344                         DEBUG_PrintAddress( &addr, dbg_mode, FALSE );
345                         fprintf(stderr,": ");
346                     }
347                 }
348                 fprintf(stderr,"\n");
349                 return;
350         }
351 }