1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
|
//:: Some helpers for debugging.
//: Load the 'map' file generated during 'bootstrap --debug translate' when running
//: 'bootstrap --trace run'.
//: (It'll only affect the trace.)
:(before "End Globals")
map</*address*/uint32_t, string> Symbol_name; // used only by 'bootstrap run'
map</*address*/uint32_t, string> Source_line; // used only by 'bootstrap run'
:(before "End --trace Settings")
load_labels();
load_source_lines();
:(code)
void load_labels() {
ifstream fin("labels");
if (fin.fail()) return;
fin >> std::hex;
while (has_data(fin)) {
uint32_t addr = 0;
fin >> addr;
string name;
fin >> name;
put(Symbol_name, addr, name);
}
}
void load_source_lines() {
ifstream fin("source_lines");
if (fin.fail()) return;
fin >> std::hex;
while (has_data(fin)) {
uint32_t addr = 0;
fin >> addr;
string line;
getline(fin, line);
put(Source_line, addr, hacky_squeeze_out_whitespace(line));
}
}
:(after "Run One Instruction")
if (contains_key(Symbol_name, EIP))
trace(Callstack_depth, "run") << "== label " << get(Symbol_name, EIP) << end();
if (contains_key(Source_line, EIP))
trace(Callstack_depth, "run") << "inst: " << get(Source_line, EIP) << end();
else
// no source line info; do what you can
trace(Callstack_depth, "run") << "inst: " << debug_info(EIP) << end();
:(code)
string debug_info(uint32_t inst_address) {
uint8_t op = read_mem_u8(inst_address);
if (op != 0xe8) {
ostringstream out;
out << HEXBYTE << NUM(op);
return out.str();
}
int32_t offset = read_mem_i32(inst_address+/*skip op*/1);
uint32_t next_eip = inst_address+/*inst length*/5+offset;
if (contains_key(Symbol_name, next_eip))
return "e8/call "+get(Symbol_name, next_eip);
ostringstream out;
out << "e8/call 0x" << HEXWORD << next_eip;
return out.str();
}
//: If a label starts with '$watch-', make a note of the effective address
//: computed by the next instruction. Start dumping out its contents to the
//: trace after every subsequent instruction.
:(after "Run One Instruction")
dump_watch_points();
:(before "End Globals")
map<string, uint32_t> Watch_points;
:(before "End Reset")
Watch_points.clear();
:(code)
void dump_watch_points() {
if (Watch_points.empty()) return;
trace(Callstack_depth, "dbg") << "watch points:" << end();
for (map<string, uint32_t>::iterator p = Watch_points.begin(); p != Watch_points.end(); ++p)
trace(Callstack_depth, "dbg") << " " << p->first << ": " << HEXWORD << p->second << " -> " << HEXWORD << read_mem_u32(p->second) << end();
}
:(before "End Globals")
string Watch_this_effective_address;
:(after "Run One Instruction")
Watch_this_effective_address = "";
if (contains_key(Symbol_name, EIP) && starts_with(get(Symbol_name, EIP), "$watch-"))
Watch_this_effective_address = get(Symbol_name, EIP);
:(after "Found effective_address(addr)")
if (!Watch_this_effective_address.empty()) {
dbg << "now watching " << HEXWORD << addr << " for " << Watch_this_effective_address << end();
put(Watch_points, Watch_this_effective_address, addr);
}
//: If a label starts with '$dump-stack', dump out to the trace n bytes on
//: either side of ESP.
:(after "Run One Instruction")
if (contains_key(Symbol_name, EIP) && starts_with(get(Symbol_name, EIP), "$dump-stack")) {
dump_stack(64);
}
:(code)
void dump_stack(int n) {
uint32_t stack_pointer = Reg[ESP].u;
uint32_t start = ((stack_pointer-n)&0xfffffff0);
dbg << "stack:" << end();
for (uint32_t addr = start; addr < start+n*2; addr+=16) {
if (addr >= AFTER_STACK) break;
ostringstream out;
out << HEXWORD << addr << ":";
for (int i = 0; i < 16; i+=4) {
out << ' ';
out << ((addr+i == stack_pointer) ? '[' : ' ');
out << HEXWORD << read_mem_u32(addr+i);
out << ((addr+i == stack_pointer) ? ']' : ' ');
}
dbg << out.str() << end();
}
}
//: Special label that dumps regions of memory.
//: Not a general mechanism; by the time you get here you're willing to hack
//: on the emulator.
:(after "Run One Instruction")
if (contains_key(Symbol_name, EIP) && get(Symbol_name, EIP) == "$dump-stream-at-EAX")
dump_stream_at(Reg[EAX].u);
:(code)
void dump_stream_at(uint32_t stream_start) {
int32_t stream_length = read_mem_i32(stream_start + 8);
dbg << "stream length: " << std::dec << stream_length << end();
for (int i = 0; i < stream_length + 12; ++i)
dbg << "0x" << HEXWORD << (stream_start+i) << ": " << HEXBYTE << NUM(read_mem_u8(stream_start+i)) << end();
}
//: helpers
:(code)
string hacky_squeeze_out_whitespace(const string& s) {
// strip whitespace at start
string::const_iterator first = s.begin();
while (first != s.end() && isspace(*first))
++first;
if (first == s.end()) return "";
// strip whitespace at end
string::const_iterator last = --s.end();
while (last != s.begin() && isspace(*last))
--last;
++last;
// replace runs of spaces/dots with single space until comment or string
// TODO:
// leave alone dots not surrounded by whitespace
// leave alone '#' within word
// leave alone '"' within word
// squeeze spaces after end of string
ostringstream out;
bool previous_was_space = false;
bool in_comment_or_string = false;
for (string::const_iterator curr = first; curr != last; ++curr) {
if (in_comment_or_string)
out << *curr;
else if (isspace(*curr) || *curr == '.')
previous_was_space = true;
else {
if (previous_was_space)
out << ' ';
out << *curr;
previous_was_space = false;
if (*curr == '#' || *curr == '"') in_comment_or_string = true;
}
}
return out.str();
}
|