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