4 * Copyright 1995 Alexandre Julliard
5 * Copyright 1996 Eric Youngdale
6 * Copyright 1999 Ove Kåven
7 * Copyright 2004 Eric Pouech
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
30 #include "dbghelp_private.h"
33 #include "thread.h" /* FIXME: must be included before winternl.h */
35 #include "wine/debug.h"
36 #include "stackframe.h"
38 WINE_DEFAULT_DEBUG_CHANNEL(dbghelp
);
40 enum st_mode
{stm_start
, stm_32bit
, stm_16bit
, stm_done
};
42 static const char* wine_dbgstr_addr(const ADDRESS
* addr
)
44 if (!addr
) return "(null)";
48 return wine_dbg_sprintf("flat<%08lx>", addr
->Offset
);
50 return wine_dbg_sprintf("1616<%04x:%04lx>", addr
->Segment
, addr
->Offset
);
52 return wine_dbg_sprintf("1632<%04x:%08lx>", addr
->Segment
, addr
->Offset
);
54 return wine_dbg_sprintf("real<%04x:%04lx>", addr
->Segment
, addr
->Offset
);
60 /* indexes in Reserved array */
61 #define __CurrentMode 0
62 #define __CurrentSwitch 1
63 #define __NextSwitch 2
65 #define curr_mode (frame->Reserved[__CurrentMode])
66 #define curr_switch (frame->Reserved[__CurrentSwitch])
67 #define next_switch (frame->Reserved[__NextSwitch])
69 /***********************************************************************
70 * StackWalk (DBGHELP.@)
72 BOOL WINAPI
StackWalk(DWORD MachineType
, HANDLE hProcess
, HANDLE hThread
,
73 LPSTACKFRAME frame
, LPVOID ctx
,
74 PREAD_PROCESS_MEMORY_ROUTINE f_read_mem
,
75 PFUNCTION_TABLE_ACCESS_ROUTINE FunctionTableAccessRoutine
,
76 PGET_MODULE_BASE_ROUTINE GetModuleBaseRoutine
,
77 PTRANSLATE_ADDRESS_ROUTINE f_xlat_adr
)
87 TRACE("(%ld, %p, %p, %p, %p, %p, %p, %p, %p)\n",
88 MachineType
, hProcess
, hThread
, frame
, ctx
,
89 f_read_mem
, FunctionTableAccessRoutine
,
90 GetModuleBaseRoutine
, f_xlat_adr
);
92 if (MachineType
!= IMAGE_FILE_MACHINE_I386
)
94 SetLastError(ERROR_INVALID_PARAMETER
);
99 if (curr_mode
>= stm_done
) return FALSE
;
101 if (!f_read_mem
) f_read_mem
= ReadProcessMemory
;
102 if (!f_xlat_adr
) f_xlat_adr
= addr_to_linear
;
104 TRACE("Enter: PC=%s Frame=%s Return=%s Stack=%s Mode=%s cSwitch=%08lx nSwitch=%08lx\n",
105 wine_dbgstr_addr(&frame
->AddrPC
),
106 wine_dbgstr_addr(&frame
->AddrFrame
),
107 wine_dbgstr_addr(&frame
->AddrReturn
),
108 wine_dbgstr_addr(&frame
->AddrStack
),
109 curr_mode
== stm_start
? "start" : (curr_mode
== stm_16bit
? "16bit" : "32bit"),
110 curr_switch
, next_switch
);
112 if (curr_mode
== stm_start
)
114 THREAD_BASIC_INFORMATION info
;
117 curr_mode
= (frame
->AddrPC
.Mode
== AddrModeFlat
) ?
118 stm_32bit
: stm_16bit
;
120 /* cur_switch holds address of curr_stack's field in TEB in debuggee
123 if (NtQueryInformationThread(hThread
, ThreadBasicInformation
, &info
,
124 sizeof(info
), NULL
) != STATUS_SUCCESS
)
126 curr_switch
= (unsigned long)info
.TebBaseAddress
+ FIELD_OFFSET(TEB
, cur_stack
);
127 if (!f_read_mem(hProcess
, (void*)curr_switch
, &next_switch
,
128 sizeof(next_switch
), NULL
))
130 WARN("Can't read TEB:cur_stack\n");
133 if (curr_mode
== stm_16bit
)
135 if (!f_read_mem(hProcess
, (void*)next_switch
, &frame32
,
136 sizeof(frame32
), NULL
))
138 WARN("Bad stack frame 0x%08lx\n", next_switch
);
141 curr_switch
= (DWORD
)frame32
.frame16
;
142 tmp
.Mode
= AddrMode1616
;
143 tmp
.Segment
= SELECTOROF(curr_switch
);
144 tmp
.Offset
= OFFSETOF(curr_switch
);
145 if (!f_read_mem(hProcess
, (void*)f_xlat_adr(hProcess
, hThread
, &tmp
),
146 &ch
, sizeof(ch
), NULL
))
147 curr_switch
= 0xFFFFFFFF;
148 frame
->AddrReturn
.Mode
= frame
->AddrStack
.Mode
= AddrMode1616
;
152 tmp
.Mode
= AddrMode1616
;
153 tmp
.Segment
= SELECTOROF(next_switch
);
154 tmp
.Offset
= OFFSETOF(next_switch
);
155 p
= f_xlat_adr(hProcess
, hThread
, &tmp
);
156 if (!f_read_mem(hProcess
, (void*)p
, &frame16
, sizeof(frame16
), NULL
))
158 WARN("Bad stack frame 0x%08lx\n", p
);
161 curr_switch
= (DWORD
)frame16
.frame32
;
163 if (!f_read_mem(hProcess
, (void*)curr_switch
, &ch
, sizeof(ch
), NULL
))
164 curr_switch
= 0xFFFFFFFF;
165 frame
->AddrReturn
.Mode
= frame
->AddrStack
.Mode
= AddrModeFlat
;
167 /* don't set up AddrStack on first call. Either the caller has set it up, or
168 * we will get it in the next frame
173 if (frame
->AddrFrame
.Offset
== 0) goto done_err
;
174 if (frame
->AddrFrame
.Mode
== AddrModeFlat
)
176 assert(curr_mode
== stm_32bit
);
177 do_switch
= curr_switch
&& frame
->AddrFrame
.Offset
>= curr_switch
;
181 assert(curr_mode
== stm_16bit
);
182 do_switch
= OFFSETOF(curr_switch
) &&
183 frame
->AddrFrame
.Segment
== SELECTOROF(curr_switch
) &&
184 frame
->AddrFrame
.Offset
>= OFFSETOF(curr_switch
);
189 if (curr_mode
== stm_16bit
)
191 if (!f_read_mem(hProcess
, (void*)next_switch
, &frame32
,
192 sizeof(frame32
), NULL
))
194 WARN("Bad stack frame 0x%08lx\n", next_switch
);
198 frame
->AddrPC
.Mode
= AddrModeFlat
;
199 frame
->AddrPC
.Segment
= 0;
200 frame
->AddrPC
.Offset
= frame32
.retaddr
;
201 frame
->AddrFrame
.Mode
= AddrModeFlat
;
202 frame
->AddrFrame
.Segment
= 0;
203 frame
->AddrFrame
.Offset
= frame32
.ebp
;
205 frame
->AddrStack
.Mode
= AddrModeFlat
;
206 frame
->AddrStack
.Segment
= 0;
207 frame
->AddrReturn
.Mode
= AddrModeFlat
;
208 frame
->AddrReturn
.Segment
= 0;
210 next_switch
= curr_switch
;
211 tmp
.Mode
= AddrMode1616
;
212 tmp
.Segment
= SELECTOROF(next_switch
);
213 tmp
.Offset
= OFFSETOF(next_switch
);
214 p
= f_xlat_adr(hProcess
, hThread
, &tmp
);
216 if (!f_read_mem(hProcess
, (void*)p
, &frame16
, sizeof(frame16
), NULL
))
218 WARN("Bad stack frame 0x%08lx\n", p
);
221 curr_switch
= (DWORD
)frame16
.frame32
;
222 curr_mode
= stm_32bit
;
223 if (!f_read_mem(hProcess
, (void*)curr_switch
, &ch
, sizeof(ch
), NULL
))
224 curr_switch
= 0xFFFFFFFF;
228 tmp
.Mode
= AddrMode1616
;
229 tmp
.Segment
= SELECTOROF(next_switch
);
230 tmp
.Offset
= OFFSETOF(next_switch
);
231 p
= f_xlat_adr(hProcess
, hThread
, &tmp
);
233 if (!f_read_mem(hProcess
, (void*)p
, &frame16
, sizeof(frame16
), NULL
))
235 WARN("Bad stack frame 0x%08lx\n", p
);
239 TRACE("Got a 16 bit stack switch:"
241 "\n\tedx:%08lx ecx:%08lx ebp:%08lx"
242 "\n\tds:%04x es:%04x fs:%04x gs:%04x"
243 "\n\tcall_from_ip:%08lx module_cs:%04lx relay=%08lx"
244 "\n\tentry_ip:%04x entry_point:%08lx"
245 "\n\tbp:%04x ip:%04x cs:%04x\n",
246 (unsigned long)frame16
.frame32
,
247 frame16
.edx
, frame16
.ecx
, frame16
.ebp
,
248 frame16
.ds
, frame16
.es
, frame16
.fs
, frame16
.gs
,
249 frame16
.callfrom_ip
, frame16
.module_cs
, frame16
.relay
,
250 frame16
.entry_ip
, frame16
.entry_point
,
251 frame16
.bp
, frame16
.ip
, frame16
.cs
);
254 frame
->AddrPC
.Mode
= AddrMode1616
;
255 frame
->AddrPC
.Segment
= frame16
.cs
;
256 frame
->AddrPC
.Offset
= frame16
.ip
;
258 frame
->AddrFrame
.Mode
= AddrMode1616
;
259 frame
->AddrFrame
.Segment
= SELECTOROF(next_switch
);
260 frame
->AddrFrame
.Offset
= frame16
.bp
;
262 frame
->AddrStack
.Mode
= AddrMode1616
;
263 frame
->AddrStack
.Segment
= SELECTOROF(next_switch
);
265 frame
->AddrReturn
.Mode
= AddrMode1616
;
266 frame
->AddrReturn
.Segment
= frame16
.cs
;
268 next_switch
= curr_switch
;
269 if (!f_read_mem(hProcess
, (void*)next_switch
, &frame32
, sizeof(frame32
),
272 WARN("Bad stack frame 0x%08lx\n", next_switch
);
275 curr_switch
= (DWORD
)frame32
.frame16
;
276 tmp
.Mode
= AddrMode1616
;
277 tmp
.Segment
= SELECTOROF(curr_switch
);
278 tmp
.Offset
= OFFSETOF(curr_switch
);
280 if (!f_read_mem(hProcess
, (void*)f_xlat_adr(hProcess
, hThread
, &tmp
),
281 &ch
, sizeof(ch
), NULL
))
282 curr_switch
= 0xFFFFFFFF;
283 curr_mode
= stm_16bit
;
288 frame
->AddrPC
= frame
->AddrReturn
;
289 if (curr_mode
== stm_16bit
)
291 frame
->AddrStack
.Offset
= frame
->AddrFrame
.Offset
+ 2 * sizeof(WORD
);
292 /* "pop up" previous BP value */
293 if (!f_read_mem(hProcess
,
294 (void*)f_xlat_adr(hProcess
, hThread
, &frame
->AddrFrame
),
295 &val
, sizeof(WORD
), NULL
))
297 frame
->AddrFrame
.Offset
= val
;
301 frame
->AddrStack
.Offset
= frame
->AddrFrame
.Offset
+ 2 * sizeof(DWORD
);
302 /* "pop up" previous EBP value */
303 if (!f_read_mem(hProcess
, (void*)frame
->AddrFrame
.Offset
,
304 &frame
->AddrFrame
.Offset
, sizeof(DWORD
), NULL
))
310 if (curr_mode
== stm_16bit
)
314 p
= f_xlat_adr(hProcess
, hThread
, &frame
->AddrFrame
);
315 if (!f_read_mem(hProcess
, (void*)(p
+ sizeof(WORD
)), &val
, sizeof(WORD
), NULL
))
317 frame
->AddrReturn
.Offset
= val
;
318 /* get potential cs if a far call was used */
319 if (!f_read_mem(hProcess
, (void*)(p
+ 2 * sizeof(WORD
)),
320 &val
, sizeof(WORD
), NULL
))
322 if (frame
->AddrFrame
.Offset
& 1)
323 frame
->AddrReturn
.Segment
= val
; /* far call assumed */
326 /* not explicitly marked as far call,
327 * but check whether it could be anyway
329 if ((val
& 7) == 7 && val
!= frame
->AddrReturn
.Segment
)
333 if (GetThreadSelectorEntry(hThread
, val
, &le
) &&
334 (le
.HighWord
.Bits
.Type
& 0x08)) /* code segment */
336 /* it is very uncommon to push a code segment cs as
337 * a parameter, so this should work in most cases
339 frame
->AddrReturn
.Segment
= val
;
343 frame
->AddrFrame
.Offset
&= ~1;
344 /* we "pop" parameters as 16 bit entities... of course, this won't
345 * work if the parameter is in fact bigger than 16bit, but
346 * there's no way to know that here
348 for (i
= 0; i
< sizeof(frame
->Params
) / sizeof(frame
->Params
[0]); i
++)
350 f_read_mem(hProcess
, (void*)(p
+ (2 + i
) * sizeof(WORD
)),
351 &val
, sizeof(val
), NULL
);
352 frame
->Params
[i
] = val
;
357 if (!f_read_mem(hProcess
,
358 (void*)(frame
->AddrFrame
.Offset
+ sizeof(DWORD
)),
359 &frame
->AddrReturn
.Offset
, sizeof(DWORD
), NULL
))
362 (void*)(frame
->AddrFrame
.Offset
+ 2 * sizeof(DWORD
)),
363 frame
->Params
, sizeof(frame
->Params
), NULL
);
367 frame
->Virtual
= FALSE
;
369 TRACE("Leave: PC=%s Frame=%s Return=%s Stack=%s Mode=%s cSwitch=%08lx nSwitch=%08lx\n",
370 wine_dbgstr_addr(&frame
->AddrPC
),
371 wine_dbgstr_addr(&frame
->AddrFrame
),
372 wine_dbgstr_addr(&frame
->AddrReturn
),
373 wine_dbgstr_addr(&frame
->AddrStack
),
374 curr_mode
== stm_start
? "start" : (curr_mode
== stm_16bit
? "16bit" : "32bit"),
375 curr_switch
, next_switch
);
379 curr_mode
= stm_done
;