4 * Copyright (C) 2009-2009, Eric Pouech.
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
24 #define WIN32_NO_STATUS
25 #include "dbghelp_private.h"
26 #include "wine/winbase16.h"
28 #include "wine/debug.h"
30 WINE_DEFAULT_DEBUG_CHANNEL(dbghelp
);
32 #define STEP_FLAG 0x00000100 /* single step flag */
33 #define V86_FLAG 0x00020000
35 #define IS_VM86_MODE(ctx) (ctx->EFlags & V86_FLAG)
38 static ADDRESS_MODE
get_selector_type(HANDLE hThread
, const CONTEXT
* ctx
, WORD sel
)
42 if (IS_VM86_MODE(ctx
)) return AddrModeReal
;
43 /* null or system selector */
44 if (!(sel
& 4) || ((sel
>> 3) < 17)) return AddrModeFlat
;
45 if (hThread
&& GetThreadSelectorEntry(hThread
, sel
, &le
))
46 return le
.HighWord
.Bits
.Default_Big
? AddrMode1632
: AddrMode1616
;
47 /* selector doesn't exist */
51 static unsigned i386_build_addr(HANDLE hThread
, const CONTEXT
* ctx
, ADDRESS64
* addr
,
52 unsigned seg
, unsigned long offset
)
54 addr
->Mode
= AddrModeFlat
;
56 addr
->Offset
= offset
;
59 switch (addr
->Mode
= get_selector_type(hThread
, ctx
, seg
))
63 addr
->Offset
&= 0xffff;
76 static unsigned i386_get_addr(HANDLE hThread
, const CONTEXT
* ctx
,
77 enum cpu_addr ca
, ADDRESS64
* addr
)
82 case cpu_addr_pc
: return i386_build_addr(hThread
, ctx
, addr
, ctx
->SegCs
, ctx
->Eip
);
83 case cpu_addr_stack
: return i386_build_addr(hThread
, ctx
, addr
, ctx
->SegSs
, ctx
->Esp
);
84 case cpu_addr_frame
: return i386_build_addr(hThread
, ctx
, addr
, ctx
->SegSs
, ctx
->Ebp
);
90 enum st_mode
{stm_start
, stm_32bit
, stm_16bit
, stm_done
};
92 /* indexes in Reserved array */
93 #define __CurrentMode 0
94 #define __CurrentSwitch 1
95 #define __NextSwitch 2
97 #define curr_mode (frame->Reserved[__CurrentMode])
98 #define curr_switch (frame->Reserved[__CurrentSwitch])
99 #define next_switch (frame->Reserved[__NextSwitch])
101 static BOOL
i386_stack_walk(struct cpu_stack_walk
* csw
, LPSTACKFRAME64 frame
, CONTEXT
* context
)
103 STACK32FRAME frame32
;
104 STACK16FRAME frame16
;
110 unsigned deltapc
= 1;
116 if (curr_mode
>= stm_done
) return FALSE
;
118 TRACE("Enter: PC=%s Frame=%s Return=%s Stack=%s Mode=%s cSwitch=%p nSwitch=%p\n",
119 wine_dbgstr_addr(&frame
->AddrPC
),
120 wine_dbgstr_addr(&frame
->AddrFrame
),
121 wine_dbgstr_addr(&frame
->AddrReturn
),
122 wine_dbgstr_addr(&frame
->AddrStack
),
123 curr_mode
== stm_start
? "start" : (curr_mode
== stm_16bit
? "16bit" : "32bit"),
124 (void*)(DWORD_PTR
)curr_switch
, (void*)(DWORD_PTR
)next_switch
);
129 /* setup a pseudo context for the rest of the code (esp. unwinding) */
131 memset(context
, 0, sizeof(*context
));
132 context
->ContextFlags
= CONTEXT_CONTROL
| CONTEXT_SEGMENTS
;
133 if (frame
->AddrPC
.Mode
!= AddrModeFlat
) context
->SegCs
= frame
->AddrPC
.Segment
;
134 context
->Eip
= frame
->AddrPC
.Offset
;
135 if (frame
->AddrFrame
.Mode
!= AddrModeFlat
) context
->SegSs
= frame
->AddrFrame
.Segment
;
136 context
->Ebp
= frame
->AddrFrame
.Offset
;
137 if (frame
->AddrStack
.Mode
!= AddrModeFlat
) context
->SegSs
= frame
->AddrStack
.Segment
;
138 context
->Esp
= frame
->AddrStack
.Offset
;
141 if (curr_mode
== stm_start
)
143 THREAD_BASIC_INFORMATION info
;
145 if ((frame
->AddrPC
.Mode
== AddrModeFlat
) &&
146 (frame
->AddrFrame
.Mode
!= AddrModeFlat
))
148 WARN("Bad AddrPC.Mode / AddrFrame.Mode combination\n");
153 curr_mode
= (frame
->AddrPC
.Mode
== AddrModeFlat
) ? stm_32bit
: stm_16bit
;
156 /* cur_switch holds address of WOW32Reserved field in TEB in debuggee
159 if (NtQueryInformationThread(csw
->hThread
, ThreadBasicInformation
, &info
,
160 sizeof(info
), NULL
) == STATUS_SUCCESS
)
162 curr_switch
= (unsigned long)info
.TebBaseAddress
+ FIELD_OFFSET(TEB
, WOW32Reserved
);
163 if (!sw_read_mem(csw
, curr_switch
, &p
, sizeof(p
)))
165 WARN("Can't read TEB:WOW32Reserved\n");
169 if (!next_switch
) /* no 16-bit stack */
173 else if (curr_mode
== stm_16bit
)
175 if (!sw_read_mem(csw
, next_switch
, &frame32
, sizeof(frame32
)))
177 WARN("Bad stack frame %p\n", (void*)(DWORD_PTR
)next_switch
);
180 curr_switch
= (DWORD
)frame32
.frame16
;
181 tmp
.Mode
= AddrMode1616
;
182 tmp
.Segment
= SELECTOROF(curr_switch
);
183 tmp
.Offset
= OFFSETOF(curr_switch
);
184 if (!sw_read_mem(csw
, sw_xlat_addr(csw
, &tmp
), &ch
, sizeof(ch
)))
185 curr_switch
= 0xFFFFFFFF;
189 tmp
.Mode
= AddrMode1616
;
190 tmp
.Segment
= SELECTOROF(next_switch
);
191 tmp
.Offset
= OFFSETOF(next_switch
);
192 p
= sw_xlat_addr(csw
, &tmp
);
193 if (!sw_read_mem(csw
, p
, &frame16
, sizeof(frame16
)))
195 WARN("Bad stack frame 0x%08x\n", p
);
198 curr_switch
= (DWORD_PTR
)frame16
.frame32
;
200 if (!sw_read_mem(csw
, curr_switch
, &ch
, sizeof(ch
)))
201 curr_switch
= 0xFFFFFFFF;
205 /* FIXME: this will allow to work when we're not attached to a live target,
206 * but the 16 <=> 32 switch facility won't be available.
209 frame
->AddrReturn
.Mode
= frame
->AddrStack
.Mode
= (curr_mode
== stm_16bit
) ? AddrMode1616
: AddrModeFlat
;
210 /* don't set up AddrStack on first call. Either the caller has set it up, or
211 * we will get it in the next frame
213 memset(&frame
->AddrBStore
, 0, sizeof(frame
->AddrBStore
));
215 if (curr_mode
== stm_32bit
)
219 if (dwarf2_virtual_unwind(csw
, frame
->AddrPC
.Offset
- deltapc
, context
, &xframe
))
221 frame
->AddrStack
.Mode
= frame
->AddrFrame
.Mode
= frame
->AddrReturn
.Mode
= AddrModeFlat
;
222 frame
->AddrStack
.Offset
= context
->Esp
= xframe
;
223 frame
->AddrFrame
.Offset
= context
->Ebp
;
224 frame
->AddrReturn
.Offset
= context
->Eip
;
232 if (frame
->AddrFrame
.Offset
== 0) goto done_err
;
233 if (frame
->AddrFrame
.Mode
== AddrModeFlat
)
235 assert(curr_mode
== stm_32bit
);
236 do_switch
= curr_switch
&& frame
->AddrFrame
.Offset
>= curr_switch
;
240 assert(curr_mode
== stm_16bit
);
241 do_switch
= curr_switch
&&
242 frame
->AddrFrame
.Segment
== SELECTOROF(curr_switch
) &&
243 frame
->AddrFrame
.Offset
>= OFFSETOF(curr_switch
);
248 if (curr_mode
== stm_16bit
)
250 if (!sw_read_mem(csw
, next_switch
, &frame32
, sizeof(frame32
)))
252 WARN("Bad stack frame %p\n", (void*)(DWORD_PTR
)next_switch
);
256 frame
->AddrPC
.Mode
= AddrModeFlat
;
257 frame
->AddrPC
.Segment
= 0;
258 frame
->AddrPC
.Offset
= frame32
.retaddr
;
259 frame
->AddrFrame
.Mode
= AddrModeFlat
;
260 frame
->AddrFrame
.Segment
= 0;
261 frame
->AddrFrame
.Offset
= frame32
.ebp
;
263 frame
->AddrStack
.Mode
= AddrModeFlat
;
264 frame
->AddrStack
.Segment
= 0;
265 frame
->AddrReturn
.Mode
= AddrModeFlat
;
266 frame
->AddrReturn
.Segment
= 0;
268 next_switch
= curr_switch
;
269 tmp
.Mode
= AddrMode1616
;
270 tmp
.Segment
= SELECTOROF(next_switch
);
271 tmp
.Offset
= OFFSETOF(next_switch
);
272 p
= sw_xlat_addr(csw
, &tmp
);
274 if (!sw_read_mem(csw
, p
, &frame16
, sizeof(frame16
)))
276 WARN("Bad stack frame 0x%08x\n", p
);
279 curr_switch
= (DWORD_PTR
)frame16
.frame32
;
280 curr_mode
= stm_32bit
;
281 if (!sw_read_mem(csw
, curr_switch
, &ch
, sizeof(ch
)))
286 tmp
.Mode
= AddrMode1616
;
287 tmp
.Segment
= SELECTOROF(next_switch
);
288 tmp
.Offset
= OFFSETOF(next_switch
);
289 p
= sw_xlat_addr(csw
, &tmp
);
291 if (!sw_read_mem(csw
, p
, &frame16
, sizeof(frame16
)))
293 WARN("Bad stack frame 0x%08x\n", p
);
297 TRACE("Got a 16 bit stack switch:"
299 "\n\tedx:%08x ecx:%08x ebp:%08x"
300 "\n\tds:%04x es:%04x fs:%04x gs:%04x"
301 "\n\tcall_from_ip:%08x module_cs:%04x relay=%08x"
302 "\n\tentry_ip:%04x entry_point:%08x"
303 "\n\tbp:%04x ip:%04x cs:%04x\n",
304 (unsigned long)frame16
.frame32
,
305 frame16
.edx
, frame16
.ecx
, frame16
.ebp
,
306 frame16
.ds
, frame16
.es
, frame16
.fs
, frame16
.gs
,
307 frame16
.callfrom_ip
, frame16
.module_cs
, frame16
.relay
,
308 frame16
.entry_ip
, frame16
.entry_point
,
309 frame16
.bp
, frame16
.ip
, frame16
.cs
);
311 frame
->AddrPC
.Mode
= AddrMode1616
;
312 frame
->AddrPC
.Segment
= frame16
.cs
;
313 frame
->AddrPC
.Offset
= frame16
.ip
;
315 frame
->AddrFrame
.Mode
= AddrMode1616
;
316 frame
->AddrFrame
.Segment
= SELECTOROF(next_switch
);
317 frame
->AddrFrame
.Offset
= frame16
.bp
;
319 frame
->AddrStack
.Mode
= AddrMode1616
;
320 frame
->AddrStack
.Segment
= SELECTOROF(next_switch
);
322 frame
->AddrReturn
.Mode
= AddrMode1616
;
323 frame
->AddrReturn
.Segment
= frame16
.cs
;
325 next_switch
= curr_switch
;
326 if (!sw_read_mem(csw
, next_switch
, &frame32
, sizeof(frame32
)))
328 WARN("Bad stack frame %p\n", (void*)(DWORD_PTR
)next_switch
);
331 curr_switch
= (DWORD
)frame32
.frame16
;
332 tmp
.Mode
= AddrMode1616
;
333 tmp
.Segment
= SELECTOROF(curr_switch
);
334 tmp
.Offset
= OFFSETOF(curr_switch
);
336 if (!sw_read_mem(csw
, sw_xlat_addr(csw
, &tmp
), &ch
, sizeof(ch
)))
338 curr_mode
= stm_16bit
;
343 frame
->AddrPC
= frame
->AddrReturn
;
344 if (curr_mode
== stm_16bit
)
346 frame
->AddrStack
.Offset
= frame
->AddrFrame
.Offset
+ 2 * sizeof(WORD
);
347 /* "pop up" previous BP value */
348 if (!sw_read_mem(csw
, sw_xlat_addr(csw
, &frame
->AddrFrame
),
351 frame
->AddrFrame
.Offset
= val
;
358 if (dwarf2_virtual_unwind(csw
, frame
->AddrPC
.Offset
- deltapc
, context
, &xframe
))
360 frame
->AddrStack
.Mode
= frame
->AddrFrame
.Mode
= frame
->AddrReturn
.Mode
= AddrModeFlat
;
361 frame
->AddrStack
.Offset
= context
->Esp
= xframe
;
362 frame
->AddrFrame
.Offset
= context
->Ebp
;
363 frame
->AddrReturn
.Offset
= context
->Eip
;
367 frame
->AddrStack
.Offset
= frame
->AddrFrame
.Offset
+ 2 * sizeof(DWORD
);
368 /* "pop up" previous EBP value */
369 if (!sw_read_mem(csw
, frame
->AddrFrame
.Offset
,
370 &frame
->AddrFrame
.Offset
, sizeof(DWORD
)))
376 if (curr_mode
== stm_16bit
)
380 p
= sw_xlat_addr(csw
, &frame
->AddrFrame
);
381 if (!sw_read_mem(csw
, p
+ sizeof(WORD
), &val
, sizeof(WORD
)))
383 frame
->AddrReturn
.Offset
= val
;
384 /* get potential cs if a far call was used */
385 if (!sw_read_mem(csw
, p
+ 2 * sizeof(WORD
), &val
, sizeof(WORD
)))
387 if (frame
->AddrFrame
.Offset
& 1)
388 frame
->AddrReturn
.Segment
= val
; /* far call assumed */
391 /* not explicitly marked as far call,
392 * but check whether it could be anyway
394 if ((val
& 7) == 7 && val
!= frame
->AddrReturn
.Segment
)
398 if (GetThreadSelectorEntry(csw
->hThread
, val
, &le
) &&
399 (le
.HighWord
.Bits
.Type
& 0x08)) /* code segment */
401 /* it is very uncommon to push a code segment cs as
402 * a parameter, so this should work in most cases
404 frame
->AddrReturn
.Segment
= val
;
408 frame
->AddrFrame
.Offset
&= ~1;
409 /* we "pop" parameters as 16 bit entities... of course, this won't
410 * work if the parameter is in fact bigger than 16bit, but
411 * there's no way to know that here
413 for (i
= 0; i
< sizeof(frame
->Params
) / sizeof(frame
->Params
[0]); i
++)
415 sw_read_mem(csw
, p
+ (2 + i
) * sizeof(WORD
), &val
, sizeof(val
));
416 frame
->Params
[i
] = val
;
421 if (!sw_read_mem(csw
, frame
->AddrFrame
.Offset
+ sizeof(DWORD
),
422 &frame
->AddrReturn
.Offset
, sizeof(DWORD
)))
424 WARN("Cannot read new frame offset %p\n",
425 (void*)(DWORD_PTR
)(frame
->AddrFrame
.Offset
+ (int)sizeof(DWORD
)));
428 sw_read_mem(csw
, frame
->AddrFrame
.Offset
+ 2 * sizeof(DWORD
),
429 frame
->Params
, sizeof(frame
->Params
));
434 #define SET(field, seg, reg) \
435 switch (frame->field.Mode) \
437 case AddrModeFlat: context->reg = frame->field.Offset; break; \
438 case AddrMode1616: context->seg = frame->field.Segment; context->reg = frame->field.Offset; break; \
439 default: assert(0); \
441 SET(AddrStack
, SegSs
, Esp
);
442 SET(AddrFrame
, SegSs
, Ebp
);
443 SET(AddrReturn
, SegCs
, Eip
);
450 frame
->Virtual
= TRUE
;
451 p
= sw_xlat_addr(csw
, &frame
->AddrPC
);
452 if (p
&& sw_module_base(csw
, p
))
453 frame
->FuncTableEntry
= sw_table_access(csw
, p
);
455 frame
->FuncTableEntry
= NULL
;
457 TRACE("Leave: PC=%s Frame=%s Return=%s Stack=%s Mode=%s cSwitch=%p nSwitch=%p FuncTable=%p\n",
458 wine_dbgstr_addr(&frame
->AddrPC
),
459 wine_dbgstr_addr(&frame
->AddrFrame
),
460 wine_dbgstr_addr(&frame
->AddrReturn
),
461 wine_dbgstr_addr(&frame
->AddrStack
),
462 curr_mode
== stm_start
? "start" : (curr_mode
== stm_16bit
? "16bit" : "32bit"),
463 (void*)(DWORD_PTR
)curr_switch
, (void*)(DWORD_PTR
)next_switch
, frame
->FuncTableEntry
);
467 curr_mode
= stm_done
;
471 static unsigned i386_map_dwarf_register(unsigned regno
)
477 case 0: reg
= CV_REG_EAX
; break;
478 case 1: reg
= CV_REG_ECX
; break;
479 case 2: reg
= CV_REG_EDX
; break;
480 case 3: reg
= CV_REG_EBX
; break;
481 case 4: reg
= CV_REG_ESP
; break;
482 case 5: reg
= CV_REG_EBP
; break;
483 case 6: reg
= CV_REG_ESI
; break;
484 case 7: reg
= CV_REG_EDI
; break;
485 case 8: reg
= CV_REG_EIP
; break;
486 case 9: reg
= CV_REG_EFLAGS
; break;
487 case 10: reg
= CV_REG_CS
; break;
488 case 11: reg
= CV_REG_SS
; break;
489 case 12: reg
= CV_REG_DS
; break;
490 case 13: reg
= CV_REG_ES
; break;
491 case 14: reg
= CV_REG_FS
; break;
492 case 15: reg
= CV_REG_GS
; break;
493 case 16: case 17: case 18: case 19:
494 case 20: case 21: case 22: case 23:
495 reg
= CV_REG_ST0
+ regno
- 16; break;
496 case 24: reg
= CV_REG_CTRL
; break;
497 case 25: reg
= CV_REG_STAT
; break;
498 case 26: reg
= CV_REG_TAG
; break;
506 case 32: case 33: case 34: case 35:
507 case 36: case 37: case 38: case 39:
508 reg
= CV_REG_XMM0
+ regno
- 32; break;
509 case 40: reg
= CV_REG_MXCSR
; break;
511 FIXME("Don't know how to map register %d\n", regno
);
517 static void* i386_fetch_context_reg(CONTEXT
* ctx
, unsigned regno
, unsigned* size
)
522 case CV_REG_EAX
: *size
= sizeof(ctx
->Eax
); return &ctx
->Eax
;
523 case CV_REG_EDX
: *size
= sizeof(ctx
->Edx
); return &ctx
->Edx
;
524 case CV_REG_ECX
: *size
= sizeof(ctx
->Ecx
); return &ctx
->Ecx
;
525 case CV_REG_EBX
: *size
= sizeof(ctx
->Ebx
); return &ctx
->Ebx
;
526 case CV_REG_ESI
: *size
= sizeof(ctx
->Esi
); return &ctx
->Esi
;
527 case CV_REG_EDI
: *size
= sizeof(ctx
->Edi
); return &ctx
->Edi
;
528 case CV_REG_EBP
: *size
= sizeof(ctx
->Ebp
); return &ctx
->Ebp
;
529 case CV_REG_ESP
: *size
= sizeof(ctx
->Esp
); return &ctx
->Esp
;
530 case CV_REG_EIP
: *size
= sizeof(ctx
->Eip
); return &ctx
->Eip
;
532 case CV_REG_ST0
+ 0: *size
= sizeof(long double); return &ctx
->FloatSave
.RegisterArea
[0*sizeof(long double)];
533 case CV_REG_ST0
+ 1: *size
= sizeof(long double); return &ctx
->FloatSave
.RegisterArea
[1*sizeof(long double)];
534 case CV_REG_ST0
+ 2: *size
= sizeof(long double); return &ctx
->FloatSave
.RegisterArea
[2*sizeof(long double)];
535 case CV_REG_ST0
+ 3: *size
= sizeof(long double); return &ctx
->FloatSave
.RegisterArea
[3*sizeof(long double)];
536 case CV_REG_ST0
+ 4: *size
= sizeof(long double); return &ctx
->FloatSave
.RegisterArea
[4*sizeof(long double)];
537 case CV_REG_ST0
+ 5: *size
= sizeof(long double); return &ctx
->FloatSave
.RegisterArea
[5*sizeof(long double)];
538 case CV_REG_ST0
+ 6: *size
= sizeof(long double); return &ctx
->FloatSave
.RegisterArea
[6*sizeof(long double)];
539 case CV_REG_ST0
+ 7: *size
= sizeof(long double); return &ctx
->FloatSave
.RegisterArea
[7*sizeof(long double)];
541 case CV_REG_EFLAGS
: *size
= sizeof(ctx
->EFlags
); return &ctx
->EFlags
;
542 case CV_REG_ES
: *size
= sizeof(ctx
->SegEs
); return &ctx
->SegEs
;
543 case CV_REG_CS
: *size
= sizeof(ctx
->SegCs
); return &ctx
->SegCs
;
544 case CV_REG_SS
: *size
= sizeof(ctx
->SegSs
); return &ctx
->SegSs
;
545 case CV_REG_DS
: *size
= sizeof(ctx
->SegDs
); return &ctx
->SegDs
;
546 case CV_REG_FS
: *size
= sizeof(ctx
->SegFs
); return &ctx
->SegFs
;
547 case CV_REG_GS
: *size
= sizeof(ctx
->SegGs
); return &ctx
->SegGs
;
551 FIXME("Unknown register %x\n", regno
);
555 static const char* i386_fetch_regname(unsigned regno
)
559 case CV_REG_EAX
: return "eax";
560 case CV_REG_EDX
: return "edx";
561 case CV_REG_ECX
: return "ecx";
562 case CV_REG_EBX
: return "ebx";
563 case CV_REG_ESI
: return "esi";
564 case CV_REG_EDI
: return "edi";
565 case CV_REG_EBP
: return "ebp";
566 case CV_REG_ESP
: return "esp";
567 case CV_REG_EIP
: return "eip";
569 case CV_REG_ST0
+ 0: return "st0";
570 case CV_REG_ST0
+ 1: return "st1";
571 case CV_REG_ST0
+ 2: return "st2";
572 case CV_REG_ST0
+ 3: return "st3";
573 case CV_REG_ST0
+ 4: return "st4";
574 case CV_REG_ST0
+ 5: return "st5";
575 case CV_REG_ST0
+ 6: return "st6";
576 case CV_REG_ST0
+ 7: return "st7";
578 case CV_REG_EFLAGS
: return "eflags";
579 case CV_REG_ES
: return "es";
580 case CV_REG_CS
: return "cs";
581 case CV_REG_SS
: return "ss";
582 case CV_REG_DS
: return "ds";
583 case CV_REG_FS
: return "fs";
584 case CV_REG_GS
: return "gs";
586 FIXME("Unknown register %x\n", regno
);
590 struct cpu cpu_i386
= {
591 IMAGE_FILE_MACHINE_I386
,
596 i386_map_dwarf_register
,
597 i386_fetch_context_reg
,