2 * Debugger memory handling
4 * Copyright 1993 Eric Youngdale
5 * Copyright 1995 Alexandre Julliard
6 * Copyright 2000 Eric Pouech
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.
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.
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
24 #include "wine/port.h"
33 #define IS_VM86_MODE() (DEBUG_context.EFlags & V86_FLAG)
36 static void DEBUG_Die(const char* msg
)
38 DEBUG_Printf(DBG_CHN_MESG
, msg
);
42 void* DEBUG_XMalloc(size_t size
)
44 void *res
= malloc(size
? size
: 1);
46 DEBUG_Die("Memory exhausted.\n");
51 void* DEBUG_XReAlloc(void *ptr
, size_t size
)
53 void* res
= realloc(ptr
, size
);
54 if ((res
== NULL
) && size
)
55 DEBUG_Die("Memory exhausted.\n");
59 char* DEBUG_XStrDup(const char *str
)
61 char *res
= strdup(str
);
63 DEBUG_Die("Memory exhausted.\n");
67 enum dbg_mode
DEBUG_GetSelectorType( WORD sel
)
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 */
83 void DEBUG_FixAddress( DBG_ADDR
*addr
, DWORD def
)
85 if (addr
->seg
== 0xffffffff) addr
->seg
= def
;
86 if (DEBUG_IsSelectorSystem(addr
->seg
)) addr
->seg
= 0;
89 /* Determine if sel is a system selector (i.e. not managed by Wine) */
90 BOOL
DEBUG_IsSelectorSystem(WORD sel
)
92 if (IS_VM86_MODE()) return FALSE
; /* no system selectors in vm86 mode */
93 return !(sel
& 4) || ((sel
>> 3) < 17);
97 DWORD
DEBUG_ToLinear( const DBG_ADDR
*addr
)
102 if (IS_VM86_MODE()) return (DWORD
)(LOWORD(addr
->seg
) << 4) + addr
->off
;
104 if (DEBUG_IsSelectorSystem(addr
->seg
))
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
;
116 void DEBUG_GetCurrentAddress( DBG_ADDR
*addr
)
119 addr
->seg
= DEBUG_context
.SegCs
;
121 if (DEBUG_IsSelectorSystem(addr
->seg
))
123 addr
->off
= DEBUG_context
.Eip
;
124 #elif defined(__sparc__)
126 addr
->off
= DEBUG_context
.pc
;
127 #elif defined(__powerpc__)
129 addr
->off
= DEBUG_context
.Iar
;
131 # error You must define GET_IP for this CPU
135 void DEBUG_InvalAddr( const DBG_ADDR
* addr
)
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();
143 void DEBUG_InvalLinAddr( void* addr
)
148 address
.off
= (unsigned long)addr
;
149 DEBUG_InvalAddr( &address
);
152 /***********************************************************************
155 * Read a memory value.
157 /* FIXME: this function is now getting closer and closer to
158 * DEBUG_ExprGetValue. They should be merged...
160 int DEBUG_ReadMemory( const DBG_VALUE
* val
)
162 int value
= 0; /* to clear any unused byte */
163 int os
= DEBUG_GetObjectSize(val
->type
);
165 assert(sizeof(value
) >= os
);
167 /* FIXME: only works on little endian systems */
169 if (val
->cookie
== DV_TARGET
) {
170 DBG_ADDR addr
= val
->addr
;
174 DEBUG_FixAddress( &addr
, DEBUG_context
.SegDs
);
176 lin
= (void*)DEBUG_ToLinear( &addr
);
178 DEBUG_READ_MEM_VERBOSE(lin
, &value
, os
);
181 memcpy(&value
, (void*)val
->addr
.off
, os
);
187 /***********************************************************************
190 * Store a value in memory.
192 void DEBUG_WriteMemory( const DBG_VALUE
* val
, int value
)
194 int os
= DEBUG_GetObjectSize(val
->type
);
196 assert(sizeof(value
) >= os
);
198 /* FIXME: only works on little endian systems */
200 if (val
->cookie
== DV_TARGET
) {
201 DBG_ADDR addr
= val
->addr
;
205 DEBUG_FixAddress( &addr
, DEBUG_context
.SegDs
);
207 lin
= (void*)DEBUG_ToLinear( &addr
);
208 DEBUG_WRITE_MEM_VERBOSE(lin
, &value
, os
);
210 memcpy((void*)val
->addr
.off
, &value
, os
);
214 /***********************************************************************
217 * Get the address from a value
219 BOOL
DEBUG_GrabAddress( DBG_VALUE
* value
, BOOL fromCode
)
221 assert(value
->cookie
== DV_TARGET
|| value
->cookie
== DV_HOST
);
224 DEBUG_FixAddress( &value
->addr
,
225 (fromCode
) ? DEBUG_context
.SegCs
: DEBUG_context
.SegDs
);
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.
233 if (value
->type
!= NULL
) {
234 if (value
->type
== DEBUG_GetBasicType(DT_BASIC_CONST_INT
)) {
236 * We know that we have the actual offset stored somewhere
237 * else in 32-bit space. Grab it, and we
240 unsigned int seg2
= value
->addr
.seg
;
242 value
->addr
.off
= DEBUG_GetExprValue(value
, NULL
);
243 value
->addr
.seg
= seg2
;
245 struct datatype
* testtype
;
247 if (DEBUG_TypeDerefPointer(value
, &testtype
) == 0)
249 if (testtype
!= NULL
|| value
->type
== DEBUG_GetBasicType(DT_BASIC_CONST_INT
))
250 value
->addr
.off
= DEBUG_GetExprValue(value
, NULL
);
252 } else if (!value
->addr
.seg
&& !value
->addr
.off
) {
253 DEBUG_Printf(DBG_CHN_MESG
,"Invalid expression\n");
259 /***********************************************************************
260 * DEBUG_ExamineMemory
262 * Implementation of the 'x' command.
264 void DEBUG_ExamineMemory( const DBG_VALUE
*_value
, int count
, char format
)
266 DBG_VALUE value
= *_value
;
270 if (!DEBUG_GrabAddress(&value
, (format
== 'i'))) return;
272 if (format
!= 'i' && count
> 1)
274 DEBUG_PrintAddress( &value
.addr
, DEBUG_CurrThread
->dbg_mode
, FALSE
);
275 DEBUG_Printf(DBG_CHN_MESG
,": ");
278 pnt
= (void*)DEBUG_ToLinear( &value
.addr
);
283 if (count
== 1) count
= 256;
284 DEBUG_nchar
+= DEBUG_PrintStringW(DBG_CHN_MESG
, &value
.addr
, count
);
285 DEBUG_Printf(DBG_CHN_MESG
, "\n");
288 if (count
== 1) count
= 256;
289 DEBUG_nchar
+= DEBUG_PrintStringA(DBG_CHN_MESG
, &value
.addr
, count
);
290 DEBUG_Printf(DBG_CHN_MESG
, "\n");
293 while (count
-- && DEBUG_DisassembleInstruction( &value
.addr
));
299 if (!DEBUG_READ_MEM_VERBOSE(pnt
, &guid
, sizeof(guid
))) break;
300 DEBUG_Printf(DBG_CHN_MESG
,"{%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}\n",
301 guid
.Data1
, guid
.Data2
, guid
.Data3
,
302 guid
.Data4
[0], guid
.Data4
[1], guid
.Data4
[2], guid
.Data4
[3],
303 guid
.Data4
[4], guid
.Data4
[5], guid
.Data4
[6], guid
.Data4
[7] );
305 value
.addr
.off
+= sizeof(guid
);
308 DEBUG_PrintAddress( &value
.addr
, DEBUG_CurrThread
->dbg_mode
, FALSE
);
309 DEBUG_Printf(DBG_CHN_MESG
,": ");
314 #define DO_DUMP2(_t,_l,_f,_vv) { \
316 for(i=0; i<count; i++) { \
317 if (!DEBUG_READ_MEM_VERBOSE(pnt, &_v, sizeof(_t))) break; \
318 DEBUG_Printf(DBG_CHN_MESG,_f,(_vv)); \
319 pnt += sizeof(_t); value.addr.off += sizeof(_t); \
320 if ((i % (_l)) == (_l)-1) { \
321 DEBUG_Printf(DBG_CHN_MESG,"\n"); \
322 DEBUG_PrintAddress( &value.addr, DEBUG_CurrThread->dbg_mode, FALSE );\
323 DEBUG_Printf(DBG_CHN_MESG,": ");\
326 DEBUG_Printf(DBG_CHN_MESG,"\n"); \
329 #define DO_DUMP(_t,_l,_f) DO_DUMP2(_t,_l,_f,_v)
331 case 'x': DO_DUMP(int, 4, " %8.8x");
332 case 'd': DO_DUMP(unsigned int, 4, " %10d");
333 case 'w': DO_DUMP(unsigned short, 8, " %04x");
334 case 'c': DO_DUMP2(char, 32, " %c", (_v
< 0x20) ? ' ' : _v
);
335 case 'b': DO_DUMP2(char, 16, " %02x", (_v
) & 0xff);
339 /******************************************************************
342 * Prints on channel chnl, the string starting at address in target
343 * address space. The string stops when either len chars (if <> -1)
344 * have been printed, or the '\0' char is printed
346 int DEBUG_PrintStringA(int chnl
, const DBG_ADDR
* address
, int len
)
348 char* lin
= (void*)DEBUG_ToLinear(address
);
352 if (len
== -1) len
= 32767; /* should be big enough */
354 for (i
= len
; i
> 0; i
-= l
)
356 l
= min(sizeof(ach
) - 1, i
);
357 DEBUG_READ_MEM_VERBOSE(lin
, ach
, l
);
358 ach
[l
] = '\0'; /* protect from displaying junk */
360 DEBUG_OutputA(chnl
, ach
, l
);
361 if (l
< sizeof(ach
) - 1) break;
364 return len
- i
; /* number of actually written chars */
367 int DEBUG_PrintStringW(int chnl
, const DBG_ADDR
* address
, int len
)
369 char* lin
= (void*)DEBUG_ToLinear(address
);
373 if (len
== -1) len
= 32767; /* should be big enough */
376 if (!DEBUG_READ_MEM_VERBOSE(lin
, &wch
, sizeof(wch
)) || !wch
)
379 DEBUG_OutputW(chnl
, &wch
, 1);