|
1
|
1 /* Ddbg - Win32 Debugger for the D programming language
|
|
|
2 * Copyright (c) 2007 Jascha Wetzel
|
|
|
3 * All rights reserved. See LICENSE.TXT for details.
|
|
|
4 */
|
|
|
5
|
|
|
6 import util;
|
|
|
7 import codeview.codeview;
|
|
|
8 import expression.evaluationcontext;
|
|
|
9
|
|
|
10 import std.string;
|
|
|
11
|
|
|
12 /**************************************************************************************************
|
|
|
13 Wraps the raw stack data with functions for unwinding it.
|
|
|
14 **************************************************************************************************/
|
|
|
15 class CallStack
|
|
|
16 {
|
|
|
17 ubyte[] data;
|
|
|
18 uint base_ptr, // the "base" of the stack, i.e. the largest address
|
|
|
19 top_ptr, // the current top of the stack = Esp
|
|
|
20 frame_ptr; // the current frame pointer
|
|
|
21
|
|
|
22 /**********************************************************************************************
|
|
|
23 Initializes the object with pointers to base, top (esp) and frame (ebp)
|
|
|
24 of the stack. Resizes the data array to the required size.
|
|
|
25 **********************************************************************************************/
|
|
|
26 this(uint base_ptr_, uint top_ptr_, uint frame_ptr_)
|
|
|
27 {
|
|
|
28 base_ptr = base_ptr_;
|
|
|
29 top_ptr = top_ptr_;
|
|
|
30 frame_ptr = frame_ptr_;
|
|
|
31 data.length = base_ptr-top_ptr;
|
|
|
32 }
|
|
|
33
|
|
|
34 /**********************************************************************************************
|
|
|
35 Calculates the first frame.
|
|
|
36 Params: prev_index = first byte of previous frame pointer
|
|
|
37 Returns: Array covering the frame.
|
|
|
38 **********************************************************************************************/
|
|
|
39 ubyte[] firstFrame(out uint prev_index)
|
|
|
40 {
|
|
|
41 prev_index = frame_ptr-top_ptr;
|
|
|
42 if ( prev_index >= data.length )
|
|
|
43 return data;
|
|
|
44 return data[0..prev_index];
|
|
|
45 }
|
|
|
46
|
|
|
47 /**********************************************************************************************
|
|
|
48 Calculates the previous frame.
|
|
|
49 Params:
|
|
|
50 frame_index = start of desired frame in data array
|
|
|
51 prev_index = start of previous to desired frame in data array
|
|
|
52 Returns: Array covering the previous frame.
|
|
|
53 **********************************************************************************************/
|
|
|
54 ubyte[] prevFrame(in uint frame_index, out uint prev_index)
|
|
|
55 {
|
|
|
56 if ( frame_index >= data.length-4 )
|
|
|
57 return null;
|
|
|
58
|
|
|
59 uint prev_frame_ptr = (cast(uint[])data)[frame_index>>2];
|
|
|
60 if ( prev_frame_ptr < top_ptr || prev_frame_ptr > base_ptr )
|
|
|
61 return null;
|
|
|
62
|
|
|
63 prev_index = prev_frame_ptr-top_ptr;
|
|
|
64 assert( prev_index > frame_index && prev_index <= data.length );
|
|
|
65 return data[frame_index..prev_index];
|
|
|
66 }
|
|
|
67
|
|
|
68 /**********************************************************************************************
|
|
|
69
|
|
|
70 **********************************************************************************************/
|
|
|
71 ubyte[] getFrame(uint frame_level)
|
|
|
72 {
|
|
|
73 uint prev_frame_idx;
|
|
|
74 ubyte[] frame = firstFrame(prev_frame_idx);
|
|
|
75 for ( ; frame_level > 0; --frame_level )
|
|
|
76 frame = prevFrame(prev_frame_idx, prev_frame_idx);
|
|
|
77 return frame;
|
|
|
78 }
|
|
|
79
|
|
|
80 /**********************************************************************************************
|
|
|
81 Loads data from the stack for a given symbol.
|
|
|
82 Returns: Array of bytes continaing the data
|
|
|
83 **********************************************************************************************/
|
|
|
84 bool loadSymbolData(StackSymbol sym, SymbolData symdata, uint frame_level=0)
|
|
|
85 {
|
|
|
86 if ( sym is null )
|
|
|
87 return false;
|
|
|
88 uint prev_frame_idx;
|
|
|
89 ubyte[] frame = firstFrame(prev_frame_idx);
|
|
|
90 for ( ; frame_level > 0; --frame_level )
|
|
|
91 frame = prevFrame(prev_frame_idx, prev_frame_idx);
|
|
|
92
|
|
|
93 symdata.defered_load = true;
|
|
|
94
|
|
|
95 bool loadSymbolData(uint offset)
|
|
|
96 {
|
|
|
97 // index is in this frame
|
|
|
98 if ( offset <= frame.length-sym.size ) {
|
|
|
99 symdata.len = sym.size;
|
|
|
100 symdata.ptr = top_ptr + (frame.ptr - data.ptr) + offset;
|
|
|
101 return true;
|
|
|
102 }
|
|
|
103 assert( offset >= frame.length );
|
|
|
104 // consider previous frame
|
|
|
105 offset -= frame.length;
|
|
|
106 frame = prevFrame(prev_frame_idx, prev_frame_idx);
|
|
|
107 if ( frame !is null )
|
|
|
108 return loadSymbolData(offset);
|
|
|
109 return false;
|
|
|
110 }
|
|
|
111
|
|
|
112 return loadSymbolData(frame.length+sym.cvdata.offset);
|
|
|
113 }
|
|
|
114 }
|
