1 /* Disassemble support for GDB. 2 3 Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009 4 Free Software Foundation, Inc. 5 6 This file is part of GDB. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 3 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 20 21 #include "defs.h" 22 #include "target.h" 23 #include "value.h" 24 #include "ui-out.h" 25 #include "gdb_string.h" 26 #include "disasm.h" 27 #include "gdbcore.h" 28 #include "dis-asm.h" 29 30 /* Disassemble functions. 31 FIXME: We should get rid of all the duplicate code in gdb that does 32 the same thing: disassemble_command() and the gdbtk variation. */ 33 34 /* This Structure is used to store line number information. 35 We need a different sort of line table from the normal one cuz we can't 36 depend upon implicit line-end pc's for lines to do the 37 reordering in this function. */ 38 39 struct dis_line_entry 40 { 41 int line; 42 CORE_ADDR start_pc; 43 CORE_ADDR end_pc; 44 }; 45 46 /* Like target_read_memory, but slightly different parameters. */ 47 static int 48 dis_asm_read_memory (bfd_vma memaddr, gdb_byte *myaddr, unsigned int len, 49 struct disassemble_info *info) 50 { 51 return target_read_memory (memaddr, myaddr, len); 52 } 53 54 /* Like memory_error with slightly different parameters. */ 55 static void 56 dis_asm_memory_error (int status, bfd_vma memaddr, 57 struct disassemble_info *info) 58 { 59 memory_error (status, memaddr); 60 } 61 62 /* Like print_address with slightly different parameters. */ 63 static void 64 dis_asm_print_address (bfd_vma addr, struct disassemble_info *info) 65 { 66 struct gdbarch *gdbarch = info->application_data; 67 print_address (gdbarch, addr, info->stream); 68 } 69 70 static int 71 compare_lines (const void *mle1p, const void *mle2p) 72 { 73 struct dis_line_entry *mle1, *mle2; 74 int val; 75 76 mle1 = (struct dis_line_entry *) mle1p; 77 mle2 = (struct dis_line_entry *) mle2p; 78 79 val = mle1->line - mle2->line; 80 81 if (val != 0) 82 return val; 83 84 return mle1->start_pc - mle2->start_pc; 85 } 86 87 static int 88 dump_insns (struct gdbarch *gdbarch, struct ui_out *uiout, 89 struct disassemble_info * di, 90 CORE_ADDR low, CORE_ADDR high, 91 int how_many, int flags, struct ui_stream *stb) 92 { 93 int num_displayed = 0; 94 CORE_ADDR pc; 95 96 /* parts of the symbolic representation of the address */ 97 int unmapped; 98 int offset; 99 int line; 100 struct cleanup *ui_out_chain; 101 102 for (pc = low; pc < high;) 103 { 104 char *filename = NULL; 105 char *name = NULL; 106 107 QUIT; 108 if (how_many >= 0) 109 { 110 if (num_displayed >= how_many) 111 break; 112 else 113 num_displayed++; 114 } 115 ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, NULL); 116 ui_out_field_core_addr (uiout, "address", gdbarch, pc); 117 118 if (!build_address_symbolic (pc, 0, &name, &offset, &filename, 119 &line, &unmapped)) 120 { 121 /* We don't care now about line, filename and 122 unmapped. But we might in the future. */ 123 ui_out_text (uiout, " <"); 124 ui_out_field_string (uiout, "func-name", name); 125 ui_out_text (uiout, "+"); 126 ui_out_field_int (uiout, "offset", offset); 127 ui_out_text (uiout, ">:\t"); 128 } 129 else 130 ui_out_text (uiout, ":\t"); 131 132 if (filename != NULL) 133 xfree (filename); 134 if (name != NULL) 135 xfree (name); 136 137 ui_file_rewind (stb->stream); 138 if (flags & DISASSEMBLY_RAW_INSN) 139 { 140 CORE_ADDR old_pc = pc; 141 bfd_byte data; 142 int status; 143 pc += gdbarch_print_insn (gdbarch, pc, di); 144 for (;old_pc < pc; old_pc++) 145 { 146 status = (*di->read_memory_func) (old_pc, &data, 1, di); 147 if (status != 0) 148 (*di->memory_error_func) (status, old_pc, di); 149 ui_out_message (uiout, 0, " %02x", (unsigned)data); 150 } 151 ui_out_text (uiout, "\t"); 152 } 153 else 154 pc += gdbarch_print_insn (gdbarch, pc, di); 155 ui_out_field_stream (uiout, "inst", stb); 156 ui_file_rewind (stb->stream); 157 do_cleanups (ui_out_chain); 158 ui_out_text (uiout, "\n"); 159 } 160 return num_displayed; 161 } 162 163 /* The idea here is to present a source-O-centric view of a 164 function to the user. This means that things are presented 165 in source order, with (possibly) out of order assembly 166 immediately following. */ 167 static void 168 do_mixed_source_and_assembly (struct gdbarch *gdbarch, struct ui_out *uiout, 169 struct disassemble_info *di, int nlines, 170 struct linetable_entry *le, 171 CORE_ADDR low, CORE_ADDR high, 172 struct symtab *symtab, 173 int how_many, int flags, struct ui_stream *stb) 174 { 175 int newlines = 0; 176 struct dis_line_entry *mle; 177 struct symtab_and_line sal; 178 int i; 179 int out_of_order = 0; 180 int next_line = 0; 181 CORE_ADDR pc; 182 int num_displayed = 0; 183 struct cleanup *ui_out_chain; 184 struct cleanup *ui_out_tuple_chain = make_cleanup (null_cleanup, 0); 185 struct cleanup *ui_out_list_chain = make_cleanup (null_cleanup, 0); 186 187 mle = (struct dis_line_entry *) alloca (nlines 188 * sizeof (struct dis_line_entry)); 189 190 /* Copy linetable entries for this function into our data 191 structure, creating end_pc's and setting out_of_order as 192 appropriate. */ 193 194 /* First, skip all the preceding functions. */ 195 196 for (i = 0; i < nlines - 1 && le[i].pc < low; i++); 197 198 /* Now, copy all entries before the end of this function. */ 199 200 for (; i < nlines - 1 && le[i].pc < high; i++) 201 { 202 if (le[i].line == le[i + 1].line && le[i].pc == le[i + 1].pc) 203 continue; /* Ignore duplicates */ 204 205 /* Skip any end-of-function markers. */ 206 if (le[i].line == 0) 207 continue; 208 209 mle[newlines].line = le[i].line; 210 if (le[i].line > le[i + 1].line) 211 out_of_order = 1; 212 mle[newlines].start_pc = le[i].pc; 213 mle[newlines].end_pc = le[i + 1].pc; 214 newlines++; 215 } 216 217 /* If we're on the last line, and it's part of the function, 218 then we need to get the end pc in a special way. */ 219 220 if (i == nlines - 1 && le[i].pc < high) 221 { 222 mle[newlines].line = le[i].line; 223 mle[newlines].start_pc = le[i].pc; 224 sal = find_pc_line (le[i].pc, 0); 225 mle[newlines].end_pc = sal.end; 226 newlines++; 227 } 228 229 /* Now, sort mle by line #s (and, then by addresses within 230 lines). */ 231 232 if (out_of_order) 233 qsort (mle, newlines, sizeof (struct dis_line_entry), compare_lines); 234 235 /* Now, for each line entry, emit the specified lines (unless 236 they have been emitted before), followed by the assembly code 237 for that line. */ 238 239 ui_out_chain = make_cleanup_ui_out_list_begin_end (uiout, "asm_insns"); 240 241 for (i = 0; i < newlines; i++) 242 { 243 /* Print out everything from next_line to the current line. */ 244 if (mle[i].line >= next_line) 245 { 246 if (next_line != 0) 247 { 248 /* Just one line to print. */ 249 if (next_line == mle[i].line) 250 { 251 ui_out_tuple_chain 252 = make_cleanup_ui_out_tuple_begin_end (uiout, 253 "src_and_asm_line"); 254 print_source_lines (symtab, next_line, mle[i].line + 1, 0); 255 } 256 else 257 { 258 /* Several source lines w/o asm instructions associated. */ 259 for (; next_line < mle[i].line; next_line++) 260 { 261 struct cleanup *ui_out_list_chain_line; 262 struct cleanup *ui_out_tuple_chain_line; 263 264 ui_out_tuple_chain_line 265 = make_cleanup_ui_out_tuple_begin_end (uiout, 266 "src_and_asm_line"); 267 print_source_lines (symtab, next_line, next_line + 1, 268 0); 269 ui_out_list_chain_line 270 = make_cleanup_ui_out_list_begin_end (uiout, 271 "line_asm_insn"); 272 do_cleanups (ui_out_list_chain_line); 273 do_cleanups (ui_out_tuple_chain_line); 274 } 275 /* Print the last line and leave list open for 276 asm instructions to be added. */ 277 ui_out_tuple_chain 278 = make_cleanup_ui_out_tuple_begin_end (uiout, 279 "src_and_asm_line"); 280 print_source_lines (symtab, next_line, mle[i].line + 1, 0); 281 } 282 } 283 else 284 { 285 ui_out_tuple_chain 286 = make_cleanup_ui_out_tuple_begin_end (uiout, "src_and_asm_line"); 287 print_source_lines (symtab, mle[i].line, mle[i].line + 1, 0); 288 } 289 290 next_line = mle[i].line + 1; 291 ui_out_list_chain 292 = make_cleanup_ui_out_list_begin_end (uiout, "line_asm_insn"); 293 } 294 295 num_displayed += dump_insns (gdbarch, uiout, di, 296 mle[i].start_pc, mle[i].end_pc, 297 how_many, flags, stb); 298 299 /* When we've reached the end of the mle array, or we've seen the last 300 assembly range for this source line, close out the list/tuple. */ 301 if (i == (newlines - 1) || mle[i + 1].line > mle[i].line) 302 { 303 do_cleanups (ui_out_list_chain); 304 do_cleanups (ui_out_tuple_chain); 305 ui_out_tuple_chain = make_cleanup (null_cleanup, 0); 306 ui_out_list_chain = make_cleanup (null_cleanup, 0); 307 ui_out_text (uiout, "\n"); 308 } 309 if (how_many >= 0 && num_displayed >= how_many) 310 break; 311 } 312 do_cleanups (ui_out_chain); 313 } 314 315 316 static void 317 do_assembly_only (struct gdbarch *gdbarch, struct ui_out *uiout, 318 struct disassemble_info * di, 319 CORE_ADDR low, CORE_ADDR high, 320 int how_many, int flags, struct ui_stream *stb) 321 { 322 int num_displayed = 0; 323 struct cleanup *ui_out_chain; 324 325 ui_out_chain = make_cleanup_ui_out_list_begin_end (uiout, "asm_insns"); 326 327 num_displayed = dump_insns (gdbarch, uiout, di, low, high, how_many, 328 flags, stb); 329 330 do_cleanups (ui_out_chain); 331 } 332 333 /* Initialize the disassemble info struct ready for the specified 334 stream. */ 335 336 static int ATTR_FORMAT (printf, 2, 3) 337 fprintf_disasm (void *stream, const char *format, ...) 338 { 339 va_list args; 340 va_start (args, format); 341 vfprintf_filtered (stream, format, args); 342 va_end (args); 343 /* Something non -ve. */ 344 return 0; 345 } 346 347 static struct disassemble_info 348 gdb_disassemble_info (struct gdbarch *gdbarch, struct ui_file *file) 349 { 350 struct disassemble_info di; 351 init_disassemble_info (&di, file, fprintf_disasm); 352 di.flavour = bfd_target_unknown_flavour; 353 di.memory_error_func = dis_asm_memory_error; 354 di.print_address_func = dis_asm_print_address; 355 /* NOTE: cagney/2003-04-28: The original code, from the old Insight 356 disassembler had a local optomization here. By default it would 357 access the executable file, instead of the target memory (there 358 was a growing list of exceptions though). Unfortunately, the 359 heuristic was flawed. Commands like "disassemble &variable" 360 didn't work as they relied on the access going to the target. 361 Further, it has been supperseeded by trust-read-only-sections 362 (although that should be superseeded by target_trust..._p()). */ 363 di.read_memory_func = dis_asm_read_memory; 364 di.arch = gdbarch_bfd_arch_info (gdbarch)->arch; 365 di.mach = gdbarch_bfd_arch_info (gdbarch)->mach; 366 di.endian = gdbarch_byte_order (gdbarch); 367 di.endian_code = gdbarch_byte_order_for_code (gdbarch); 368 di.application_data = gdbarch; 369 disassemble_init_for_target (&di); 370 return di; 371 } 372 373 void 374 gdb_disassembly (struct gdbarch *gdbarch, struct ui_out *uiout, 375 char *file_string, 376 int flags, 377 int how_many, CORE_ADDR low, CORE_ADDR high) 378 { 379 struct ui_stream *stb = ui_out_stream_new (uiout); 380 struct cleanup *cleanups = make_cleanup_ui_out_stream_delete (stb); 381 struct disassemble_info di = gdb_disassemble_info (gdbarch, stb->stream); 382 /* To collect the instruction outputted from opcodes. */ 383 struct symtab *symtab = NULL; 384 struct linetable_entry *le = NULL; 385 int nlines = -1; 386 387 /* Assume symtab is valid for whole PC range */ 388 symtab = find_pc_symtab (low); 389 390 if (symtab != NULL && symtab->linetable != NULL) 391 { 392 /* Convert the linetable to a bunch of my_line_entry's. */ 393 le = symtab->linetable->item; 394 nlines = symtab->linetable->nitems; 395 } 396 397 if (!(flags & DISASSEMBLY_SOURCE) || nlines <= 0 398 || symtab == NULL || symtab->linetable == NULL) 399 do_assembly_only (gdbarch, uiout, &di, low, high, how_many, flags, stb); 400 401 else if (flags & DISASSEMBLY_SOURCE) 402 do_mixed_source_and_assembly (gdbarch, uiout, &di, nlines, le, low, 403 high, symtab, how_many, flags, stb); 404 405 do_cleanups (cleanups); 406 gdb_flush (gdb_stdout); 407 } 408 409 /* Print the instruction at address MEMADDR in debugged memory, 410 on STREAM. Returns the length of the instruction, in bytes, 411 and, if requested, the number of branch delay slot instructions. */ 412 413 int 414 gdb_print_insn (struct gdbarch *gdbarch, CORE_ADDR memaddr, 415 struct ui_file *stream, int *branch_delay_insns) 416 { 417 struct disassemble_info di; 418 int length; 419 420 di = gdb_disassemble_info (gdbarch, stream); 421 length = gdbarch_print_insn (gdbarch, memaddr, &di); 422 if (branch_delay_insns) 423 { 424 if (di.insn_info_valid) 425 *branch_delay_insns = di.branch_delay_insns; 426 else 427 *branch_delay_insns = 0; 428 } 429 return length; 430 } 431