1 /* Disassemble support for GDB.
3 Copyright (C) 2000-2017 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
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. */
34 /* This structure is used to store line number information for the
36 We need a different sort of line table from the normal one cuz we can't
37 depend upon implicit line-end pc's for lines to do the
38 reordering in this function. */
40 struct deprecated_dis_line_entry
47 /* This Structure is used to store line number information.
48 We need a different sort of line table from the normal one cuz we can't
49 depend upon implicit line-end pc's for lines to do the
50 reordering in this function. */
54 struct symtab
*symtab
;
58 /* Hash function for dis_line_entry. */
61 hash_dis_line_entry (const void *item
)
63 const struct dis_line_entry
*dle
= (const struct dis_line_entry
*) item
;
65 return htab_hash_pointer (dle
->symtab
) + dle
->line
;
68 /* Equal function for dis_line_entry. */
71 eq_dis_line_entry (const void *item_lhs
, const void *item_rhs
)
73 const struct dis_line_entry
*lhs
= (const struct dis_line_entry
*) item_lhs
;
74 const struct dis_line_entry
*rhs
= (const struct dis_line_entry
*) item_rhs
;
76 return (lhs
->symtab
== rhs
->symtab
77 && lhs
->line
== rhs
->line
);
80 /* Create the table to manage lines for mixed source/disassembly. */
83 allocate_dis_line_table (void)
85 return htab_create_alloc (41,
86 hash_dis_line_entry
, eq_dis_line_entry
,
87 xfree
, xcalloc
, xfree
);
90 /* Add a new dis_line_entry containing SYMTAB and LINE to TABLE. */
93 add_dis_line_entry (htab_t table
, struct symtab
*symtab
, int line
)
96 struct dis_line_entry dle
, *dlep
;
100 slot
= htab_find_slot (table
, &dle
, INSERT
);
103 dlep
= XNEW (struct dis_line_entry
);
104 dlep
->symtab
= symtab
;
110 /* Return non-zero if SYMTAB, LINE are in TABLE. */
113 line_has_code_p (htab_t table
, struct symtab
*symtab
, int line
)
115 struct dis_line_entry dle
;
119 return htab_find (table
, &dle
) != NULL
;
122 /* Wrapper of target_read_code. */
125 gdb_disassembler::dis_asm_read_memory (bfd_vma memaddr
, gdb_byte
*myaddr
,
127 struct disassemble_info
*info
)
129 return target_read_code (memaddr
, myaddr
, len
);
132 /* Wrapper of memory_error. */
135 gdb_disassembler::dis_asm_memory_error (int err
, bfd_vma memaddr
,
136 struct disassemble_info
*info
)
138 gdb_disassembler
*self
139 = static_cast<gdb_disassembler
*>(info
->application_data
);
141 self
->m_err_memaddr
= memaddr
;
144 /* Wrapper of print_address. */
147 gdb_disassembler::dis_asm_print_address (bfd_vma addr
,
148 struct disassemble_info
*info
)
150 gdb_disassembler
*self
151 = static_cast<gdb_disassembler
*>(info
->application_data
);
153 print_address (self
->arch (), addr
, self
->stream ());
157 compare_lines (const void *mle1p
, const void *mle2p
)
159 struct deprecated_dis_line_entry
*mle1
, *mle2
;
162 mle1
= (struct deprecated_dis_line_entry
*) mle1p
;
163 mle2
= (struct deprecated_dis_line_entry
*) mle2p
;
165 /* End of sequence markers have a line number of 0 but don't want to
166 be sorted to the head of the list, instead sort by PC. */
167 if (mle1
->line
== 0 || mle2
->line
== 0)
169 val
= mle1
->start_pc
- mle2
->start_pc
;
171 val
= mle1
->line
- mle2
->line
;
175 val
= mle1
->line
- mle2
->line
;
177 val
= mle1
->start_pc
- mle2
->start_pc
;
185 gdb_pretty_print_insn (struct gdbarch
*gdbarch
, struct ui_out
*uiout
,
186 const struct disasm_insn
*insn
,
189 /* parts of the symbolic representation of the address */
194 struct cleanup
*ui_out_chain
;
195 char *filename
= NULL
;
199 ui_out_chain
= make_cleanup_ui_out_tuple_begin_end (uiout
, NULL
);
202 if (insn
->number
!= 0)
204 uiout
->field_fmt ("insn-number", "%u", insn
->number
);
208 if ((flags
& DISASSEMBLY_SPECULATIVE
) != 0)
210 if (insn
->is_speculative
)
212 uiout
->field_string ("is-speculative", "?");
214 /* The speculative execution indication overwrites the first
215 character of the PC prefix.
216 We assume a PC prefix length of 3 characters. */
217 if ((flags
& DISASSEMBLY_OMIT_PC
) == 0)
218 uiout
->text (pc_prefix (pc
) + 1);
222 else if ((flags
& DISASSEMBLY_OMIT_PC
) == 0)
223 uiout
->text (pc_prefix (pc
));
227 else if ((flags
& DISASSEMBLY_OMIT_PC
) == 0)
228 uiout
->text (pc_prefix (pc
));
229 uiout
->field_core_addr ("address", gdbarch
, pc
);
231 if (!build_address_symbolic (gdbarch
, pc
, 0, &name
, &offset
, &filename
,
234 /* We don't care now about line, filename and unmapped. But we might in
237 if ((flags
& DISASSEMBLY_OMIT_FNAME
) == 0)
238 uiout
->field_string ("func-name", name
);
240 uiout
->field_int ("offset", offset
);
241 uiout
->text (">:\t");
246 if (filename
!= NULL
)
251 struct ui_file
*stb
= mem_fileopen ();
252 make_cleanup_ui_file_delete (stb
);
254 if (flags
& DISASSEMBLY_RAW_INSN
)
259 const char *spacer
= "";
261 /* Build the opcodes using a temporary stream so we can
262 write them out in a single go for the MI. */
263 struct ui_file
*opcode_stream
= mem_fileopen ();
264 struct cleanup
*cleanups
=
265 make_cleanup_ui_file_delete (opcode_stream
);
267 size
= gdb_print_insn (gdbarch
, pc
, stb
, NULL
);
270 for (;pc
< end_pc
; ++pc
)
272 read_code (pc
, &data
, 1);
273 fprintf_filtered (opcode_stream
, "%s%02x",
274 spacer
, (unsigned) data
);
278 uiout
->field_stream ("opcodes", opcode_stream
);
281 do_cleanups (cleanups
);
284 size
= gdb_print_insn (gdbarch
, pc
, stb
, NULL
);
286 uiout
->field_stream ("inst", stb
);
287 do_cleanups (ui_out_chain
);
294 dump_insns (struct gdbarch
*gdbarch
,
295 struct ui_out
*uiout
, CORE_ADDR low
, CORE_ADDR high
,
296 int how_many
, int flags
, CORE_ADDR
*end_pc
)
298 struct disasm_insn insn
;
299 int num_displayed
= 0;
301 memset (&insn
, 0, sizeof (insn
));
304 while (insn
.addr
< high
&& (how_many
< 0 || num_displayed
< how_many
))
308 size
= gdb_pretty_print_insn (gdbarch
, uiout
, &insn
, flags
);
315 /* Allow user to bail out with ^C. */
322 return num_displayed
;
325 /* The idea here is to present a source-O-centric view of a
326 function to the user. This means that things are presented
327 in source order, with (possibly) out of order assembly
328 immediately following.
330 N.B. This view is deprecated. */
333 do_mixed_source_and_assembly_deprecated
334 (struct gdbarch
*gdbarch
, struct ui_out
*uiout
,
335 struct symtab
*symtab
,
336 CORE_ADDR low
, CORE_ADDR high
,
337 int how_many
, int flags
)
341 struct linetable_entry
*le
;
342 struct deprecated_dis_line_entry
*mle
;
343 struct symtab_and_line sal
;
345 int out_of_order
= 0;
347 int num_displayed
= 0;
348 print_source_lines_flags psl_flags
= 0;
349 struct cleanup
*ui_out_chain
;
350 struct cleanup
*ui_out_tuple_chain
= make_cleanup (null_cleanup
, 0);
351 struct cleanup
*ui_out_list_chain
= make_cleanup (null_cleanup
, 0);
353 gdb_assert (symtab
!= NULL
&& SYMTAB_LINETABLE (symtab
) != NULL
);
355 nlines
= SYMTAB_LINETABLE (symtab
)->nitems
;
356 le
= SYMTAB_LINETABLE (symtab
)->item
;
358 if (flags
& DISASSEMBLY_FILENAME
)
359 psl_flags
|= PRINT_SOURCE_LINES_FILENAME
;
361 mle
= (struct deprecated_dis_line_entry
*)
362 alloca (nlines
* sizeof (struct deprecated_dis_line_entry
));
364 /* Copy linetable entries for this function into our data
365 structure, creating end_pc's and setting out_of_order as
368 /* First, skip all the preceding functions. */
370 for (i
= 0; i
< nlines
- 1 && le
[i
].pc
< low
; i
++);
372 /* Now, copy all entries before the end of this function. */
374 for (; i
< nlines
- 1 && le
[i
].pc
< high
; i
++)
376 if (le
[i
].line
== le
[i
+ 1].line
&& le
[i
].pc
== le
[i
+ 1].pc
)
377 continue; /* Ignore duplicates. */
379 /* Skip any end-of-function markers. */
383 mle
[newlines
].line
= le
[i
].line
;
384 if (le
[i
].line
> le
[i
+ 1].line
)
386 mle
[newlines
].start_pc
= le
[i
].pc
;
387 mle
[newlines
].end_pc
= le
[i
+ 1].pc
;
391 /* If we're on the last line, and it's part of the function,
392 then we need to get the end pc in a special way. */
394 if (i
== nlines
- 1 && le
[i
].pc
< high
)
396 mle
[newlines
].line
= le
[i
].line
;
397 mle
[newlines
].start_pc
= le
[i
].pc
;
398 sal
= find_pc_line (le
[i
].pc
, 0);
399 mle
[newlines
].end_pc
= sal
.end
;
403 /* Now, sort mle by line #s (and, then by addresses within lines). */
406 qsort (mle
, newlines
, sizeof (struct deprecated_dis_line_entry
),
409 /* Now, for each line entry, emit the specified lines (unless
410 they have been emitted before), followed by the assembly code
413 ui_out_chain
= make_cleanup_ui_out_list_begin_end (uiout
, "asm_insns");
415 for (i
= 0; i
< newlines
; i
++)
417 /* Print out everything from next_line to the current line. */
418 if (mle
[i
].line
>= next_line
)
422 /* Just one line to print. */
423 if (next_line
== mle
[i
].line
)
426 = make_cleanup_ui_out_tuple_begin_end (uiout
,
428 print_source_lines (symtab
, next_line
, mle
[i
].line
+ 1, psl_flags
);
432 /* Several source lines w/o asm instructions associated. */
433 for (; next_line
< mle
[i
].line
; next_line
++)
435 struct cleanup
*ui_out_list_chain_line
;
436 struct cleanup
*ui_out_tuple_chain_line
;
438 ui_out_tuple_chain_line
439 = make_cleanup_ui_out_tuple_begin_end (uiout
,
441 print_source_lines (symtab
, next_line
, next_line
+ 1,
443 ui_out_list_chain_line
444 = make_cleanup_ui_out_list_begin_end (uiout
,
446 do_cleanups (ui_out_list_chain_line
);
447 do_cleanups (ui_out_tuple_chain_line
);
449 /* Print the last line and leave list open for
450 asm instructions to be added. */
452 = make_cleanup_ui_out_tuple_begin_end (uiout
,
454 print_source_lines (symtab
, next_line
, mle
[i
].line
+ 1, psl_flags
);
460 = make_cleanup_ui_out_tuple_begin_end (uiout
,
462 print_source_lines (symtab
, mle
[i
].line
, mle
[i
].line
+ 1, psl_flags
);
465 next_line
= mle
[i
].line
+ 1;
467 = make_cleanup_ui_out_list_begin_end (uiout
, "line_asm_insn");
470 num_displayed
+= dump_insns (gdbarch
, uiout
,
471 mle
[i
].start_pc
, mle
[i
].end_pc
,
472 how_many
, flags
, NULL
);
474 /* When we've reached the end of the mle array, or we've seen the last
475 assembly range for this source line, close out the list/tuple. */
476 if (i
== (newlines
- 1) || mle
[i
+ 1].line
> mle
[i
].line
)
478 do_cleanups (ui_out_list_chain
);
479 do_cleanups (ui_out_tuple_chain
);
480 ui_out_tuple_chain
= make_cleanup (null_cleanup
, 0);
481 ui_out_list_chain
= make_cleanup (null_cleanup
, 0);
484 if (how_many
>= 0 && num_displayed
>= how_many
)
487 do_cleanups (ui_out_chain
);
490 /* The idea here is to present a source-O-centric view of a
491 function to the user. This means that things are presented
492 in source order, with (possibly) out of order assembly
493 immediately following. */
496 do_mixed_source_and_assembly (struct gdbarch
*gdbarch
,
497 struct ui_out
*uiout
,
498 struct symtab
*main_symtab
,
499 CORE_ADDR low
, CORE_ADDR high
,
500 int how_many
, int flags
)
502 const struct linetable_entry
*le
, *first_le
;
504 int num_displayed
= 0;
505 print_source_lines_flags psl_flags
= 0;
506 struct cleanup
*ui_out_chain
;
507 struct cleanup
*ui_out_tuple_chain
;
508 struct cleanup
*ui_out_list_chain
;
510 struct symtab
*last_symtab
;
513 gdb_assert (main_symtab
!= NULL
&& SYMTAB_LINETABLE (main_symtab
) != NULL
);
515 /* First pass: collect the list of all source files and lines.
516 We do this so that we can only print lines containing code once.
517 We try to print the source text leading up to the next instruction,
518 but if that text is for code that will be disassembled later, then
519 we'll want to defer printing it until later with its associated code. */
521 htab_up
dis_line_table (allocate_dis_line_table ());
525 /* The prologue may be empty, but there may still be a line number entry
526 for the opening brace which is distinct from the first line of code.
527 If the prologue has been eliminated find_pc_line may return the source
528 line after the opening brace. We still want to print this opening brace.
529 first_le is used to implement this. */
531 nlines
= SYMTAB_LINETABLE (main_symtab
)->nitems
;
532 le
= SYMTAB_LINETABLE (main_symtab
)->item
;
535 /* Skip all the preceding functions. */
536 for (i
= 0; i
< nlines
&& le
[i
].pc
< low
; i
++)
539 if (i
< nlines
&& le
[i
].pc
< high
)
542 /* Add lines for every pc value. */
545 struct symtab_and_line sal
;
548 sal
= find_pc_line (pc
, 0);
549 length
= gdb_insn_length (gdbarch
, pc
);
552 if (sal
.symtab
!= NULL
)
553 add_dis_line_entry (dis_line_table
.get (), sal
.symtab
, sal
.line
);
556 /* Second pass: print the disassembly.
558 Output format, from an MI perspective:
559 The result is a ui_out list, field name "asm_insns", where elements have
560 name "src_and_asm_line".
561 Each element is a tuple of source line specs (field names line, file,
562 fullname), and field "line_asm_insn" which contains the disassembly.
563 Field "line_asm_insn" is a list of tuples: address, func-name, offset,
566 CLI output works on top of this because MI ignores ui_out_text output,
567 which is where we put file name and source line contents output.
571 Handles the outer "asm_insns" list.
573 The tuples for each group of consecutive disassemblies.
575 List of consecutive source lines or disassembled insns. */
577 if (flags
& DISASSEMBLY_FILENAME
)
578 psl_flags
|= PRINT_SOURCE_LINES_FILENAME
;
580 ui_out_chain
= make_cleanup_ui_out_list_begin_end (uiout
, "asm_insns");
582 ui_out_tuple_chain
= NULL
;
583 ui_out_list_chain
= NULL
;
591 struct symtab_and_line sal
;
593 int start_preceding_line_to_display
= 0;
594 int end_preceding_line_to_display
= 0;
595 int new_source_line
= 0;
597 sal
= find_pc_line (pc
, 0);
599 if (sal
.symtab
!= last_symtab
)
601 /* New source file. */
604 /* If this is the first line of output, check for any preceding
608 && first_le
->line
< sal
.line
)
610 start_preceding_line_to_display
= first_le
->line
;
611 end_preceding_line_to_display
= sal
.line
;
616 /* Same source file as last time. */
617 if (sal
.symtab
!= NULL
)
619 if (sal
.line
> last_line
+ 1 && last_line
!= 0)
623 /* Several preceding source lines. Print the trailing ones
624 not associated with code that we'll print later. */
625 for (l
= sal
.line
- 1; l
> last_line
; --l
)
627 if (line_has_code_p (dis_line_table
.get (),
631 if (l
< sal
.line
- 1)
633 start_preceding_line_to_display
= l
+ 1;
634 end_preceding_line_to_display
= sal
.line
;
637 if (sal
.line
!= last_line
)
641 /* Same source line as last time. This can happen, depending
642 on the debug info. */
649 /* Skip the newline if this is the first instruction. */
652 if (ui_out_tuple_chain
!= NULL
)
654 gdb_assert (ui_out_list_chain
!= NULL
);
655 do_cleanups (ui_out_list_chain
);
656 do_cleanups (ui_out_tuple_chain
);
658 if (sal
.symtab
!= last_symtab
659 && !(flags
& DISASSEMBLY_FILENAME
))
661 /* Remember MI ignores ui_out_text.
662 We don't have to do anything here for MI because MI
663 output includes the source specs for each line. */
664 if (sal
.symtab
!= NULL
)
666 uiout
->text (symtab_to_filename_for_display (sal
.symtab
));
669 uiout
->text ("unknown");
672 if (start_preceding_line_to_display
> 0)
674 /* Several source lines w/o asm instructions associated.
675 We need to preserve the structure of the output, so output
676 a bunch of line tuples with no asm entries. */
678 struct cleanup
*ui_out_list_chain_line
;
679 struct cleanup
*ui_out_tuple_chain_line
;
681 gdb_assert (sal
.symtab
!= NULL
);
682 for (l
= start_preceding_line_to_display
;
683 l
< end_preceding_line_to_display
;
686 ui_out_tuple_chain_line
687 = make_cleanup_ui_out_tuple_begin_end (uiout
,
689 print_source_lines (sal
.symtab
, l
, l
+ 1, psl_flags
);
690 ui_out_list_chain_line
691 = make_cleanup_ui_out_list_begin_end (uiout
,
693 do_cleanups (ui_out_list_chain_line
);
694 do_cleanups (ui_out_tuple_chain_line
);
698 = make_cleanup_ui_out_tuple_begin_end (uiout
, "src_and_asm_line");
699 if (sal
.symtab
!= NULL
)
700 print_source_lines (sal
.symtab
, sal
.line
, sal
.line
+ 1, psl_flags
);
702 uiout
->text (_("--- no source info for this pc ---\n"));
704 = make_cleanup_ui_out_list_begin_end (uiout
, "line_asm_insn");
708 /* Here we're appending instructions to an existing line.
709 By construction the very first insn will have a symtab
710 and follow the new_source_line path above. */
711 gdb_assert (ui_out_tuple_chain
!= NULL
);
712 gdb_assert (ui_out_list_chain
!= NULL
);
716 end_pc
= std::min (sal
.end
, high
);
719 num_displayed
+= dump_insns (gdbarch
, uiout
, pc
, end_pc
,
720 how_many
, flags
, &end_pc
);
723 if (how_many
>= 0 && num_displayed
>= how_many
)
726 last_symtab
= sal
.symtab
;
727 last_line
= sal
.line
;
730 do_cleanups (ui_out_chain
);
734 do_assembly_only (struct gdbarch
*gdbarch
, struct ui_out
*uiout
,
735 CORE_ADDR low
, CORE_ADDR high
,
736 int how_many
, int flags
)
738 struct cleanup
*ui_out_chain
;
740 ui_out_chain
= make_cleanup_ui_out_list_begin_end (uiout
, "asm_insns");
742 dump_insns (gdbarch
, uiout
, low
, high
, how_many
, flags
, NULL
);
744 do_cleanups (ui_out_chain
);
747 /* Initialize the disassemble info struct ready for the specified
750 static int ATTRIBUTE_PRINTF (2, 3)
751 fprintf_disasm (void *stream
, const char *format
, ...)
755 va_start (args
, format
);
756 vfprintf_filtered ((struct ui_file
*) stream
, format
, args
);
758 /* Something non -ve. */
762 gdb_disassembler::gdb_disassembler (struct gdbarch
*gdbarch
,
763 struct ui_file
*file
,
764 di_read_memory_ftype read_memory_func
)
765 : m_gdbarch (gdbarch
),
768 init_disassemble_info (&m_di
, file
, fprintf_disasm
);
769 m_di
.flavour
= bfd_target_unknown_flavour
;
770 m_di
.memory_error_func
= dis_asm_memory_error
;
771 m_di
.print_address_func
= dis_asm_print_address
;
772 /* NOTE: cagney/2003-04-28: The original code, from the old Insight
773 disassembler had a local optomization here. By default it would
774 access the executable file, instead of the target memory (there
775 was a growing list of exceptions though). Unfortunately, the
776 heuristic was flawed. Commands like "disassemble &variable"
777 didn't work as they relied on the access going to the target.
778 Further, it has been supperseeded by trust-read-only-sections
779 (although that should be superseeded by target_trust..._p()). */
780 m_di
.read_memory_func
= read_memory_func
;
781 m_di
.arch
= gdbarch_bfd_arch_info (gdbarch
)->arch
;
782 m_di
.mach
= gdbarch_bfd_arch_info (gdbarch
)->mach
;
783 m_di
.endian
= gdbarch_byte_order (gdbarch
);
784 m_di
.endian_code
= gdbarch_byte_order_for_code (gdbarch
);
785 m_di
.application_data
= this;
786 disassemble_init_for_target (&m_di
);
790 gdb_disassembler::print_insn (CORE_ADDR memaddr
,
791 int *branch_delay_insns
)
795 int length
= gdbarch_print_insn (arch (), memaddr
, &m_di
);
798 memory_error (TARGET_XFER_E_IO
, m_err_memaddr
);
800 if (branch_delay_insns
!= NULL
)
802 if (m_di
.insn_info_valid
)
803 *branch_delay_insns
= m_di
.branch_delay_insns
;
805 *branch_delay_insns
= 0;
811 gdb_disassembly (struct gdbarch
*gdbarch
, struct ui_out
*uiout
,
812 int flags
, int how_many
,
813 CORE_ADDR low
, CORE_ADDR high
)
815 struct symtab
*symtab
;
818 /* Assume symtab is valid for whole PC range. */
819 symtab
= find_pc_line_symtab (low
);
821 if (symtab
!= NULL
&& SYMTAB_LINETABLE (symtab
) != NULL
)
822 nlines
= SYMTAB_LINETABLE (symtab
)->nitems
;
824 if (!(flags
& (DISASSEMBLY_SOURCE_DEPRECATED
| DISASSEMBLY_SOURCE
))
826 do_assembly_only (gdbarch
, uiout
, low
, high
, how_many
, flags
);
828 else if (flags
& DISASSEMBLY_SOURCE
)
829 do_mixed_source_and_assembly (gdbarch
, uiout
, symtab
, low
, high
,
832 else if (flags
& DISASSEMBLY_SOURCE_DEPRECATED
)
833 do_mixed_source_and_assembly_deprecated (gdbarch
, uiout
, symtab
,
834 low
, high
, how_many
, flags
);
836 gdb_flush (gdb_stdout
);
839 /* Print the instruction at address MEMADDR in debugged memory,
840 on STREAM. Returns the length of the instruction, in bytes,
841 and, if requested, the number of branch delay slot instructions. */
844 gdb_print_insn (struct gdbarch
*gdbarch
, CORE_ADDR memaddr
,
845 struct ui_file
*stream
, int *branch_delay_insns
)
848 gdb_disassembler
di (gdbarch
, stream
);
850 return di
.print_insn (memaddr
, branch_delay_insns
);
853 /* Return the length in bytes of the instruction at address MEMADDR in
857 gdb_insn_length (struct gdbarch
*gdbarch
, CORE_ADDR addr
)
859 return gdb_print_insn (gdbarch
, addr
, null_stream (), NULL
);
862 /* fprintf-function for gdb_buffered_insn_length. This function is a
863 nop, we don't want to print anything, we just want to compute the
864 length of the insn. */
866 static int ATTRIBUTE_PRINTF (2, 3)
867 gdb_buffered_insn_length_fprintf (void *stream
, const char *format
, ...)
872 /* Initialize a struct disassemble_info for gdb_buffered_insn_length. */
875 gdb_buffered_insn_length_init_dis (struct gdbarch
*gdbarch
,
876 struct disassemble_info
*di
,
877 const gdb_byte
*insn
, int max_len
,
880 init_disassemble_info (di
, NULL
, gdb_buffered_insn_length_fprintf
);
882 /* init_disassemble_info installs buffer_read_memory, etc.
883 so we don't need to do that here.
884 The cast is necessary until disassemble_info is const-ified. */
885 di
->buffer
= (gdb_byte
*) insn
;
886 di
->buffer_length
= max_len
;
887 di
->buffer_vma
= addr
;
889 di
->arch
= gdbarch_bfd_arch_info (gdbarch
)->arch
;
890 di
->mach
= gdbarch_bfd_arch_info (gdbarch
)->mach
;
891 di
->endian
= gdbarch_byte_order (gdbarch
);
892 di
->endian_code
= gdbarch_byte_order_for_code (gdbarch
);
894 disassemble_init_for_target (di
);
897 /* Return the length in bytes of INSN. MAX_LEN is the size of the
898 buffer containing INSN. */
901 gdb_buffered_insn_length (struct gdbarch
*gdbarch
,
902 const gdb_byte
*insn
, int max_len
, CORE_ADDR addr
)
904 struct disassemble_info di
;
906 gdb_buffered_insn_length_init_dis (gdbarch
, &di
, insn
, max_len
, addr
);
908 return gdbarch_print_insn (gdbarch
, addr
, &di
);