Commit | Line | Data |
---|---|---|
f377b406 | 1 | /* Disassembly display. |
f33c6cbf | 2 | |
42a4f53d | 3 | Copyright (C) 1998-2019 Free Software Foundation, Inc. |
f33c6cbf | 4 | |
f377b406 SC |
5 | Contributed by Hewlett-Packard Company. |
6 | ||
7 | This file is part of GDB. | |
8 | ||
9 | This program is free software; you can redistribute it and/or modify | |
10 | it under the terms of the GNU General Public License as published by | |
a9762ec7 | 11 | the Free Software Foundation; either version 3 of the License, or |
f377b406 SC |
12 | (at your option) any later version. |
13 | ||
14 | This program 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 | |
17 | GNU General Public License for more details. | |
18 | ||
19 | You should have received a copy of the GNU General Public License | |
a9762ec7 | 20 | along with this program. If not, see <http://www.gnu.org/licenses/>. */ |
c906108c SS |
21 | |
22 | #include "defs.h" | |
957b8b5a | 23 | #include "arch-utils.h" |
c906108c SS |
24 | #include "symtab.h" |
25 | #include "breakpoint.h" | |
26 | #include "frame.h" | |
fd0407d6 | 27 | #include "value.h" |
52575520 | 28 | #include "source.h" |
f70a7d61 | 29 | #include "disasm.h" |
d7b2e967 | 30 | #include "tui/tui.h" |
6d7fd9aa | 31 | #include "tui/tui-command.h" |
d7b2e967 AC |
32 | #include "tui/tui-data.h" |
33 | #include "tui/tui-win.h" | |
34 | #include "tui/tui-layout.h" | |
35 | #include "tui/tui-winsource.h" | |
36 | #include "tui/tui-stack.h" | |
37 | #include "tui/tui-file.h" | |
2c0b251b | 38 | #include "tui/tui-disasm.h" |
bfad4537 | 39 | #include "tui/tui-source.h" |
6c95b8df | 40 | #include "progspace.h" |
77e371c0 | 41 | #include "objfiles.h" |
1df2f9ef | 42 | #include "cli/cli-style.h" |
c906108c | 43 | |
6a83354a | 44 | #include "gdb_curses.h" |
96ec9981 | 45 | |
aec2f747 SC |
46 | struct tui_asm_line |
47 | { | |
48 | CORE_ADDR addr; | |
6b915f7d | 49 | std::string addr_string; |
825165c5 | 50 | size_t addr_size; |
6b915f7d | 51 | std::string insn; |
aec2f747 SC |
52 | }; |
53 | ||
1df2f9ef TT |
54 | /* Helper function to find the number of characters in STR, skipping |
55 | any ANSI escape sequences. */ | |
56 | static size_t | |
57 | len_without_escapes (const std::string &str) | |
58 | { | |
59 | size_t len = 0; | |
60 | const char *ptr = str.c_str (); | |
61 | char c; | |
62 | ||
63 | while ((c = *ptr++) != '\0') | |
64 | { | |
65 | if (c == '\033') | |
66 | { | |
67 | ui_file_style style; | |
68 | size_t n_read; | |
69 | if (style.parse (ptr, &n_read)) | |
70 | ptr += n_read; | |
71 | else | |
72 | { | |
73 | /* Shouldn't happen, but just skip the ESC if it somehow | |
74 | does. */ | |
75 | ++ptr; | |
76 | } | |
77 | } | |
78 | else | |
79 | ++len; | |
80 | } | |
81 | return len; | |
82 | } | |
83 | ||
aec2f747 SC |
84 | /* Function to set the disassembly window's content. |
85 | Disassemble count lines starting at pc. | |
86 | Return address of the count'th instruction after pc. */ | |
87 | static CORE_ADDR | |
6b915f7d TT |
88 | tui_disassemble (struct gdbarch *gdbarch, |
89 | std::vector<tui_asm_line> &asm_lines, | |
1df2f9ef TT |
90 | CORE_ADDR pc, int pos, int count, |
91 | size_t *addr_size = nullptr) | |
aec2f747 | 92 | { |
1df2f9ef TT |
93 | bool term_out = source_styling && gdb_stdout->can_emit_style_escape (); |
94 | string_file gdb_dis_out (term_out); | |
aec2f747 | 95 | |
1cc6d956 | 96 | /* Now construct each line. */ |
6b915f7d | 97 | for (int i = 0; i < count; ++i) |
aec2f747 | 98 | { |
d7e74731 | 99 | print_address (gdbarch, pc, &gdb_dis_out); |
6b915f7d TT |
100 | asm_lines[pos + i].addr = pc; |
101 | asm_lines[pos + i].addr_string = std::move (gdb_dis_out.string ()); | |
aec2f747 | 102 | |
d7e74731 | 103 | gdb_dis_out.clear (); |
aec2f747 | 104 | |
1df2f9ef TT |
105 | if (addr_size != nullptr) |
106 | { | |
107 | size_t new_size; | |
108 | ||
109 | if (term_out) | |
110 | new_size = len_without_escapes (asm_lines[pos + i].addr_string); | |
111 | else | |
112 | new_size = asm_lines[pos + i].addr_string.size (); | |
113 | *addr_size = std::max (*addr_size, new_size); | |
825165c5 | 114 | asm_lines[pos + i].addr_size = new_size; |
1df2f9ef TT |
115 | } |
116 | ||
d7e74731 | 117 | pc = pc + gdb_print_insn (gdbarch, pc, &gdb_dis_out, NULL); |
aec2f747 | 118 | |
6b915f7d | 119 | asm_lines[pos + i].insn = std::move (gdb_dis_out.string ()); |
aec2f747 | 120 | |
1cc6d956 | 121 | /* Reset the buffer to empty. */ |
d7e74731 | 122 | gdb_dis_out.clear (); |
aec2f747 | 123 | } |
aec2f747 SC |
124 | return pc; |
125 | } | |
126 | ||
1cc6d956 MS |
127 | /* Find the disassembly address that corresponds to FROM lines above |
128 | or below the PC. Variable sized instructions are taken into | |
129 | account by the algorithm. */ | |
aec2f747 | 130 | static CORE_ADDR |
13274fc3 | 131 | tui_find_disassembly_address (struct gdbarch *gdbarch, CORE_ADDR pc, int from) |
aec2f747 | 132 | { |
d02c80cd | 133 | CORE_ADDR new_low; |
6ba8e26f | 134 | int max_lines; |
aec2f747 | 135 | |
6ba8e26f AC |
136 | max_lines = (from > 0) ? from : - from; |
137 | if (max_lines <= 1) | |
6b915f7d | 138 | return pc; |
aec2f747 | 139 | |
6b915f7d | 140 | std::vector<tui_asm_line> asm_lines (max_lines); |
aec2f747 | 141 | |
6ba8e26f | 142 | new_low = pc; |
aec2f747 SC |
143 | if (from > 0) |
144 | { | |
6b915f7d | 145 | tui_disassemble (gdbarch, asm_lines, pc, 0, max_lines); |
4cfcaf21 | 146 | new_low = asm_lines[max_lines - 1].addr; |
aec2f747 SC |
147 | } |
148 | else | |
149 | { | |
150 | CORE_ADDR last_addr; | |
151 | int pos; | |
77e371c0 | 152 | struct bound_minimal_symbol msymbol; |
aec2f747 | 153 | |
1cc6d956 MS |
154 | /* Find backward an address which is a symbol and for which |
155 | disassembling from that address will fill completely the | |
156 | window. */ | |
6ba8e26f | 157 | pos = max_lines - 1; |
aec2f747 | 158 | do { |
6ba8e26f | 159 | new_low -= 1 * max_lines; |
77e371c0 | 160 | msymbol = lookup_minimal_symbol_by_pc_section (new_low, 0); |
aec2f747 | 161 | |
77e371c0 TT |
162 | if (msymbol.minsym) |
163 | new_low = BMSYMBOL_VALUE_ADDRESS (msymbol); | |
aec2f747 | 164 | else |
6ba8e26f | 165 | new_low += 1 * max_lines; |
aec2f747 | 166 | |
6b915f7d | 167 | tui_disassemble (gdbarch, asm_lines, new_low, 0, max_lines); |
4cfcaf21 | 168 | last_addr = asm_lines[pos].addr; |
77e371c0 | 169 | } while (last_addr > pc && msymbol.minsym); |
aec2f747 | 170 | |
1cc6d956 MS |
171 | /* Scan forward disassembling one instruction at a time until |
172 | the last visible instruction of the window matches the pc. | |
173 | We keep the disassembled instructions in the 'lines' window | |
174 | and shift it downward (increasing its addresses). */ | |
aec2f747 SC |
175 | if (last_addr < pc) |
176 | do | |
177 | { | |
178 | CORE_ADDR next_addr; | |
179 | ||
180 | pos++; | |
6ba8e26f | 181 | if (pos >= max_lines) |
aec2f747 SC |
182 | pos = 0; |
183 | ||
6b915f7d TT |
184 | next_addr = tui_disassemble (gdbarch, asm_lines, |
185 | last_addr, pos, 1); | |
aec2f747 SC |
186 | |
187 | /* If there are some problems while disassembling exit. */ | |
188 | if (next_addr <= last_addr) | |
189 | break; | |
190 | last_addr = next_addr; | |
191 | } while (last_addr <= pc); | |
192 | pos++; | |
6ba8e26f | 193 | if (pos >= max_lines) |
aec2f747 | 194 | pos = 0; |
4cfcaf21 | 195 | new_low = asm_lines[pos].addr; |
aec2f747 | 196 | } |
6ba8e26f | 197 | return new_low; |
aec2f747 SC |
198 | } |
199 | ||
200 | /* Function to set the disassembly window's content. */ | |
61c33f10 | 201 | bool |
81c82c4b | 202 | tui_disasm_window::set_contents (struct gdbarch *arch, |
9f7540a5 | 203 | const struct symtab_and_line &sal) |
c906108c | 204 | { |
d02c80cd | 205 | int i; |
81c82c4b | 206 | int offset = horizontal_offset; |
0bb65f1e | 207 | int max_lines, line_width; |
aec2f747 | 208 | CORE_ADDR cur_pc; |
3add462f | 209 | struct tui_locator_window *locator = tui_locator_win_info_ptr (); |
7806cea7 | 210 | int tab_len = tui_tab_width; |
aec2f747 | 211 | int insn_pos; |
1df2f9ef | 212 | |
9f7540a5 | 213 | CORE_ADDR pc = sal.pc; |
aec2f747 | 214 | if (pc == 0) |
61c33f10 | 215 | return false; |
aec2f747 | 216 | |
81c82c4b TT |
217 | gdbarch = arch; |
218 | start_line_or_addr.loa = LOA_ADDRESS; | |
219 | start_line_or_addr.u.addr = pc; | |
3add462f | 220 | cur_pc = locator->addr; |
aec2f747 | 221 | |
0bb65f1e | 222 | /* Window size, excluding highlight box. */ |
81c82c4b | 223 | max_lines = height - 2; |
398fdd60 | 224 | line_width = width - TUI_EXECINFO_SIZE - 2; |
aec2f747 SC |
225 | |
226 | /* Get temporary table that will hold all strings (addr & insn). */ | |
6b915f7d | 227 | std::vector<tui_asm_line> asm_lines (max_lines); |
1df2f9ef TT |
228 | size_t addr_size = 0; |
229 | tui_disassemble (gdbarch, asm_lines, pc, 0, max_lines, &addr_size); | |
aec2f747 | 230 | |
f5396833 | 231 | /* Align instructions to the same column. */ |
aec2f747 SC |
232 | insn_pos = (1 + (addr_size / tab_len)) * tab_len; |
233 | ||
1cc6d956 | 234 | /* Now construct each line. */ |
81c82c4b | 235 | content.resize (max_lines); |
6ba8e26f | 236 | for (i = 0; i < max_lines; i++) |
aec2f747 | 237 | { |
81c82c4b | 238 | tui_source_element *src = &content[i]; |
6b915f7d TT |
239 | |
240 | std::string line | |
241 | = (asm_lines[i].addr_string | |
825165c5 | 242 | + n_spaces (insn_pos - asm_lines[i].addr_size) |
6b915f7d | 243 | + asm_lines[i].insn); |
aec2f747 | 244 | |
1df2f9ef | 245 | const char *ptr = line.c_str (); |
d1da6b01 | 246 | src->line = tui_copy_source_line (&ptr, -1, offset, line_width, 0); |
aec2f747 | 247 | |
362c05fe AS |
248 | src->line_or_addr.loa = LOA_ADDRESS; |
249 | src->line_or_addr.u.addr = asm_lines[i].addr; | |
4cfcaf21 | 250 | src->is_exec_point = asm_lines[i].addr == cur_pc; |
aec2f747 | 251 | } |
61c33f10 | 252 | return true; |
aec2f747 | 253 | } |
c906108c SS |
254 | |
255 | ||
13274fc3 UW |
256 | void |
257 | tui_get_begin_asm_address (struct gdbarch **gdbarch_p, CORE_ADDR *addr_p) | |
c906108c | 258 | { |
3add462f | 259 | struct tui_locator_window *locator; |
957b8b5a | 260 | struct gdbarch *gdbarch = get_current_arch (); |
52469d76 | 261 | CORE_ADDR addr = 0; |
c906108c | 262 | |
dd1abb8c | 263 | locator = tui_locator_win_info_ptr (); |
c906108c | 264 | |
3add462f | 265 | if (locator->addr == 0) |
c906108c | 266 | { |
52469d76 TT |
267 | if (have_full_symbols () || have_partial_symbols ()) |
268 | { | |
269 | set_default_source_symtab_and_line (); | |
270 | struct symtab_and_line sal = get_current_source_symtab_and_line (); | |
271 | ||
272 | if (sal.symtab != nullptr) | |
273 | find_line_pc (sal.symtab, sal.line, &addr); | |
274 | } | |
275 | ||
276 | if (addr == 0) | |
277 | { | |
278 | struct bound_minimal_symbol main_symbol | |
279 | = lookup_minimal_symbol (main_name (), nullptr, nullptr); | |
280 | if (main_symbol.minsym != nullptr) | |
281 | addr = BMSYMBOL_VALUE_ADDRESS (main_symbol); | |
282 | } | |
c906108c | 283 | } |
1cc6d956 | 284 | else /* The target is executing. */ |
13274fc3 | 285 | { |
3add462f TT |
286 | gdbarch = locator->gdbarch; |
287 | addr = locator->addr; | |
13274fc3 | 288 | } |
c906108c | 289 | |
13274fc3 UW |
290 | *gdbarch_p = gdbarch; |
291 | *addr_p = addr; | |
65f05602 | 292 | } |
c906108c | 293 | |
77cad3ba | 294 | /* Determine what the low address will be to display in the TUI's |
1cc6d956 MS |
295 | disassembly window. This may or may not be the same as the low |
296 | address input. */ | |
77cad3ba | 297 | CORE_ADDR |
13274fc3 UW |
298 | tui_get_low_disassembly_address (struct gdbarch *gdbarch, |
299 | CORE_ADDR low, CORE_ADDR pc) | |
77cad3ba SC |
300 | { |
301 | int pos; | |
302 | ||
1cc6d956 MS |
303 | /* Determine where to start the disassembly so that the pc is about |
304 | in the middle of the viewport. */ | |
6d7fd9aa TT |
305 | if (tui_win_list[DISASSEM_WIN] != NULL) |
306 | pos = tui_win_list[DISASSEM_WIN]->height; | |
307 | else if (TUI_CMD_WIN == NULL) | |
308 | pos = tui_term_height () / 2 - 2; | |
309 | else | |
310 | pos = tui_term_height () - TUI_CMD_WIN->height - 2; | |
311 | pos = (pos - 2) / 2; | |
312 | ||
13274fc3 | 313 | pc = tui_find_disassembly_address (gdbarch, pc, -pos); |
77cad3ba SC |
314 | |
315 | if (pc < low) | |
316 | pc = low; | |
317 | return pc; | |
318 | } | |
319 | ||
65f05602 | 320 | /* Scroll the disassembly forward or backward vertically. */ |
c906108c | 321 | void |
c3bd716f | 322 | tui_disasm_window::do_scroll_vertical (int num_to_scroll) |
c906108c | 323 | { |
53e7cdba | 324 | if (!content.empty ()) |
c906108c | 325 | { |
aec2f747 | 326 | CORE_ADDR pc; |
c906108c | 327 | |
57e4b379 | 328 | pc = start_line_or_addr.u.addr; |
c3bd716f TT |
329 | if (num_to_scroll >= 0) |
330 | num_to_scroll++; | |
331 | else | |
332 | --num_to_scroll; | |
c906108c | 333 | |
9f7540a5 TT |
334 | symtab_and_line sal {}; |
335 | sal.pspace = current_program_space; | |
336 | sal.pc = tui_find_disassembly_address (gdbarch, pc, num_to_scroll); | |
337 | update_source_window_as_is (gdbarch, sal); | |
aec2f747 SC |
338 | } |
339 | } | |
c2cd8994 TT |
340 | |
341 | bool | |
342 | tui_disasm_window::location_matches_p (struct bp_location *loc, int line_no) | |
343 | { | |
344 | return (content[line_no].line_or_addr.loa == LOA_ADDRESS | |
345 | && content[line_no].line_or_addr.u.addr == loc->address); | |
346 | } | |
a54700c6 | 347 | |
088f37dd TT |
348 | bool |
349 | tui_disasm_window::addr_is_displayed (CORE_ADDR addr) const | |
350 | { | |
351 | bool is_displayed = false; | |
352 | int threshold = SCROLL_THRESHOLD; | |
353 | ||
354 | int i = 0; | |
355 | while (i < content.size () - threshold && !is_displayed) | |
356 | { | |
357 | is_displayed | |
358 | = (content[i].line_or_addr.loa == LOA_ADDRESS | |
359 | && content[i].line_or_addr.u.addr == addr); | |
360 | i++; | |
361 | } | |
362 | ||
363 | return is_displayed; | |
364 | } | |
365 | ||
a54700c6 | 366 | void |
1ae58f0c | 367 | tui_disasm_window::maybe_update (struct frame_info *fi, symtab_and_line sal) |
a54700c6 TT |
368 | { |
369 | CORE_ADDR low; | |
370 | ||
1ae58f0c TT |
371 | struct gdbarch *frame_arch = get_frame_arch (fi); |
372 | ||
373 | if (find_pc_partial_function (sal.pc, NULL, &low, NULL) == 0) | |
a54700c6 TT |
374 | { |
375 | /* There is no symbol available for current PC. There is no | |
376 | safe way how to "disassemble backwards". */ | |
1ae58f0c | 377 | low = sal.pc; |
a54700c6 TT |
378 | } |
379 | else | |
1ae58f0c | 380 | low = tui_get_low_disassembly_address (frame_arch, low, sal.pc); |
a54700c6 TT |
381 | |
382 | struct tui_line_or_address a; | |
383 | ||
384 | a.loa = LOA_ADDRESS; | |
385 | a.u.addr = low; | |
1ae58f0c | 386 | if (!addr_is_displayed (sal.pc)) |
9f7540a5 TT |
387 | { |
388 | sal.pc = low; | |
389 | update_source_window (frame_arch, sal); | |
390 | } | |
a54700c6 TT |
391 | else |
392 | { | |
1ae58f0c | 393 | a.u.addr = sal.pc; |
a54700c6 TT |
394 | set_is_exec_point_at (a); |
395 | } | |
396 | } |