2 * Debugger stack handling
4 * Copyright 1995 Alexandre Julliard
5 * Copyright 1996 Eric Youngdale
6 * Copyright 1999 Ove Kåven
13 #include "stackframe.h"
17 * We keep this info for each frame, so that we can
18 * find local variable information correctly.
26 struct symbol_info frame
;
30 static struct bt_info
* frames
= NULL
;
49 /***********************************************************************
52 * Dump the top of the stack
54 void DEBUG_InfoStack(void)
59 addr
.seg
= SS_reg(&DEBUG_context
);
60 addr
.off
= ESP_reg(&DEBUG_context
);
62 fprintf(stderr
,"Stack dump:\n");
63 if (IS_SELECTOR_32BIT(addr
.seg
))
65 DEBUG_ExamineMemory( &addr
, 24, 'x' );
67 else /* 16-bit mode */
70 DEBUG_ExamineMemory( &addr
, 24, 'w' );
76 static void DEBUG_ForceFrame(DBG_ADDR
*stack
, DBG_ADDR
*code
, int frameno
, int bits
, int noisy
)
78 int theframe
= nframe
++;
79 frames
= (struct bt_info
*)DBG_realloc(frames
,
80 nframe
*sizeof(struct bt_info
));
82 fprintf(stderr
,"%s%d ", (theframe
== curr_frame
? "=>" : " "),
84 frames
[theframe
].cs
= code
->seg
;
85 frames
[theframe
].eip
= code
->off
;
87 frames
[theframe
].frame
= DEBUG_PrintAddressAndArgs( code
, bits
,
90 DEBUG_FindNearestSymbol( code
, TRUE
,
91 &frames
[theframe
].frame
.sym
, stack
->off
,
92 &frames
[theframe
].frame
.list
);
93 frames
[theframe
].ss
= stack
->seg
;
94 frames
[theframe
].ebp
= stack
->off
;
96 fprintf( stderr
, (bits
== 16) ? " (bp=%04lx)\n" : " (ebp=%08lx)\n", stack
->off
);
100 static BOOL
DEBUG_Frame16(DBG_ADDR
*addr
, unsigned int *cs
, int frameno
, int noisy
)
102 unsigned int ss
= addr
->seg
, possible_cs
= 0;
103 FRAME16
*frame
= (FRAME16
*)DBG_ADDR_TO_LIN(addr
);
104 int theframe
= nframe
;
106 if (DEBUG_IsBadReadPtr( addr
, sizeof(FRAME16
) )) {
108 fprintf(stderr
,"*** Invalid address ");
109 DEBUG_PrintAddress(addr
, dbg_mode
, FALSE
);
110 fprintf(stderr
,"\n");
114 if (!frame
->bp
) return FALSE
;
116 frames
= (struct bt_info
*)DBG_realloc(frames
,
117 nframe
*sizeof(struct bt_info
));
119 fprintf(stderr
,"%s%d ", (theframe
== curr_frame
? "=>" : " "),
121 if (frame
->bp
& 1) *cs
= frame
->cs
;
123 /* not explicitly marked as far call,
124 * but check whether it could be anyway */
125 if (((frame
->cs
&7)==7) && (frame
->cs
!= *cs
) && !IS_SELECTOR_FREE(frame
->cs
)) {
127 LDT_GetEntry( SELECTOR_TO_ENTRY(frame
->cs
), &tcs
);
128 if ( tcs
.type
== SEGMENT_CODE
) {
129 /* it is very uncommon to push a code segment cs as
130 * a parameter, so this should work in most cases */
131 *cs
= possible_cs
= frame
->cs
;
135 frames
[theframe
].cs
= addr
->seg
= *cs
;
136 frames
[theframe
].eip
= addr
->off
= frame
->ip
;
138 frames
[theframe
].frame
= DEBUG_PrintAddressAndArgs( addr
, 16,
141 DEBUG_FindNearestSymbol( addr
, TRUE
,
142 &frames
[theframe
].frame
.sym
, frame
->bp
,
143 &frames
[theframe
].frame
.list
);
144 frames
[theframe
].ss
= addr
->seg
= ss
;
145 frames
[theframe
].ebp
= addr
->off
= frame
->bp
& ~1;
147 fprintf( stderr
, " (bp=%04lx", addr
->off
);
149 fprintf( stderr
, ", far call assumed" );
151 fprintf( stderr
, ")\n" );
156 static BOOL
DEBUG_Frame32(DBG_ADDR
*addr
, unsigned int *cs
, int frameno
, int noisy
)
158 unsigned int ss
= addr
->seg
;
159 FRAME32
*frame
= (FRAME32
*)DBG_ADDR_TO_LIN(addr
);
160 int theframe
= nframe
;
162 if (DEBUG_IsBadReadPtr( addr
, sizeof(FRAME32
) )) {
164 fprintf(stderr
,"*** Invalid address ");
165 DEBUG_PrintAddress(addr
, dbg_mode
, FALSE
);
166 fprintf(stderr
,"\n");
170 if (!frame
->ip
) return FALSE
;
172 frames
= (struct bt_info
*)DBG_realloc(frames
,
173 nframe
*sizeof(struct bt_info
));
175 fprintf(stderr
,"%s%d ", (theframe
== curr_frame
? "=>" : " "),
177 frames
[theframe
].cs
= addr
->seg
= *cs
;
178 frames
[theframe
].eip
= addr
->off
= frame
->ip
;
180 frames
[theframe
].frame
= DEBUG_PrintAddressAndArgs( addr
, 32,
183 DEBUG_FindNearestSymbol( addr
, TRUE
,
184 &frames
[theframe
].frame
.sym
, frame
->bp
,
185 &frames
[theframe
].frame
.list
);
186 if (noisy
) fprintf( stderr
, " (ebp=%08lx)\n", frame
->bp
);
187 frames
[theframe
].ss
= addr
->seg
= ss
;
188 frames
[theframe
].ebp
= frame
->bp
;
189 if (addr
->off
== frame
->bp
) return FALSE
;
190 addr
->off
= frame
->bp
;
194 static void DEBUG_DoBackTrace(int noisy
)
196 DBG_ADDR addr
, sw_addr
;
197 unsigned int ss
= SS_reg(&DEBUG_context
), cs
= CS_reg(&DEBUG_context
);
198 int frameno
= 0, is16
, ok
;
199 DWORD next_switch
, cur_switch
;
201 if (noisy
) fprintf( stderr
, "Backtrace:\n" );
204 if (frames
) DBG_free( frames
);
205 frames
= (struct bt_info
*) DBG_alloc( sizeof(struct bt_info
) );
207 fprintf(stderr
,"%s%d ",(curr_frame
== 0 ? "=>" : " "), frameno
);
209 if (IS_SELECTOR_SYSTEM(ss
)) ss
= 0;
210 if (IS_SELECTOR_SYSTEM(cs
)) cs
= 0;
212 /* first stack frame from registers */
213 if (IS_SELECTOR_32BIT(ss
))
215 frames
[0].cs
= addr
.seg
= cs
;
216 frames
[0].eip
= addr
.off
= EIP_reg(&DEBUG_context
);
218 frames
[0].frame
= DEBUG_PrintAddress( &addr
, 32, TRUE
);
220 DEBUG_FindNearestSymbol( &addr
, TRUE
, &frames
[0].frame
.sym
, 0,
221 &frames
[0].frame
.list
);
222 frames
[0].ss
= addr
.seg
= ss
;
223 frames
[0].ebp
= addr
.off
= EBP_reg(&DEBUG_context
);
224 if (noisy
) fprintf( stderr
, " (ebp=%08x)\n", frames
[0].ebp
);
227 frames
[0].cs
= addr
.seg
= cs
;
228 frames
[0].eip
= addr
.off
= LOWORD(EIP_reg(&DEBUG_context
));
230 frames
[0].frame
= DEBUG_PrintAddress( &addr
, 16, TRUE
);
232 DEBUG_FindNearestSymbol( &addr
, TRUE
, &frames
[0].frame
.sym
, 0,
233 &frames
[0].frame
.list
);
234 frames
[0].ss
= addr
.seg
= ss
;
235 frames
[0].ebp
= addr
.off
= BP_reg(&DEBUG_context
);
236 if (noisy
) fprintf( stderr
, " (bp=%04x)\n", frames
[0].ebp
);
240 next_switch
= NtCurrentTeb()->cur_stack
;
242 if (IsBadReadPtr((STACK32FRAME
*)next_switch
, sizeof(STACK32FRAME
))) {
243 if (noisy
) fprintf( stderr
, "Bad stack frame %p\n", (STACK32FRAME
*)next_switch
);
246 cur_switch
= (DWORD
)((STACK32FRAME
*)next_switch
)->frame16
;
247 sw_addr
.seg
= SELECTOROF(cur_switch
);
248 sw_addr
.off
= OFFSETOF(cur_switch
);
250 if (IsBadReadPtr((STACK16FRAME
*)PTR_SEG_TO_LIN(next_switch
), sizeof(STACK16FRAME
))) {
251 if (noisy
) fprintf( stderr
, "Bad stack frame %p\n", (STACK16FRAME
*)PTR_SEG_TO_LIN(next_switch
) );
254 cur_switch
= (DWORD
)((STACK16FRAME
*)PTR_SEG_TO_LIN(next_switch
))->frame32
;
256 sw_addr
.off
= cur_switch
;
258 if (DEBUG_IsBadReadPtr(&sw_addr
,1)) {
259 sw_addr
.seg
= (DWORD
)-1;
260 sw_addr
.off
= (DWORD
)-1;
263 for (ok
= TRUE
; ok
;) {
264 if ((frames
[frameno
].ss
== sw_addr
.seg
) &&
265 (frames
[frameno
].ebp
>= sw_addr
.off
)) {
267 * yes, I know this is confusing, it gave me a headache too */
269 STACK32FRAME
*frame
= (STACK32FRAME
*)next_switch
;
272 if (IsBadReadPtr((STACK32FRAME
*)next_switch
, sizeof(STACK32FRAME
))) {
273 if (noisy
) fprintf( stderr
, "Bad stack frame %p\n", (STACK32FRAME
*)next_switch
);
278 code
.off
= frame
->retaddr
;
282 addr
.off
= frame
->ebp
;
283 DEBUG_ForceFrame( &addr
, &code
, ++frameno
, 32, noisy
);
285 next_switch
= cur_switch
;
286 if (IsBadReadPtr((STACK16FRAME
*)PTR_SEG_TO_LIN(next_switch
), sizeof(STACK16FRAME
))) {
287 if (noisy
) fprintf( stderr
, "Bad stack frame %p\n", (STACK16FRAME
*)PTR_SEG_TO_LIN(next_switch
) );
290 cur_switch
= (DWORD
)((STACK16FRAME
*)PTR_SEG_TO_LIN(next_switch
))->frame32
;
292 sw_addr
.off
= cur_switch
;
296 STACK16FRAME
*frame
= (STACK16FRAME
*)PTR_SEG_TO_LIN(next_switch
);
299 if (IsBadReadPtr((STACK16FRAME
*)PTR_SEG_TO_LIN(next_switch
), sizeof(STACK16FRAME
))) {
300 if (noisy
) fprintf( stderr
, "Bad stack frame %p\n", (STACK16FRAME
*)PTR_SEG_TO_LIN(next_switch
) );
305 code
.seg
= frame
->cs
;
306 code
.off
= frame
->ip
;
309 addr
.seg
= SELECTOROF(next_switch
);
310 addr
.off
= frame
->bp
;
311 DEBUG_ForceFrame( &addr
, &code
, ++frameno
, 16, noisy
);
313 next_switch
= cur_switch
;
314 if (IsBadReadPtr((STACK32FRAME
*)next_switch
, sizeof(STACK32FRAME
))) {
315 if (noisy
) fprintf( stderr
, "Bad stack frame %p\n", (STACK32FRAME
*)next_switch
);
318 cur_switch
= (DWORD
)((STACK32FRAME
*)next_switch
)->frame16
;
319 sw_addr
.seg
= SELECTOROF(cur_switch
);
320 sw_addr
.off
= OFFSETOF(cur_switch
);
324 if (DEBUG_IsBadReadPtr(&sw_addr
,1)) {
325 sw_addr
.seg
= (DWORD
)-1;
326 sw_addr
.off
= (DWORD
)-1;
329 /* ordinary stack frame */
330 ok
= is16
? DEBUG_Frame16( &addr
, &cs
, ++frameno
, noisy
)
331 : DEBUG_Frame32( &addr
, &cs
, ++frameno
, noisy
);
334 if (noisy
) fprintf( stderr
, "\n" );
337 /***********************************************************************
340 * Display a stack back-trace.
342 void DEBUG_BackTrace(void)
344 DEBUG_DoBackTrace( TRUE
);
347 /***********************************************************************
348 * DEBUG_SilentBackTrace
350 * Display a stack back-trace.
352 void DEBUG_SilentBackTrace(void)
354 DEBUG_DoBackTrace( FALSE
);
358 DEBUG_SetFrame(int newframe
)
362 curr_frame
= newframe
;
364 if( curr_frame
>= nframe
)
366 curr_frame
= nframe
- 1;
374 if( frames
&& frames
[curr_frame
].frame
.list
.sourcefile
!= NULL
)
376 DEBUG_List(&frames
[curr_frame
].frame
.list
, NULL
, 0);
384 DEBUG_GetCurrentFrame(struct name_hash
** name
, unsigned int * eip
,
388 * If we don't have a valid backtrace, then just return.
396 * If we don't know what the current function is, then we also have
397 * nothing to report here.
399 if( frames
[curr_frame
].frame
.sym
== NULL
)
404 *name
= frames
[curr_frame
].frame
.sym
;
405 *eip
= frames
[curr_frame
].eip
;
406 *ebp
= frames
[curr_frame
].ebp
;