+/* The idea here is to present a source-O-centric view of a
+ function to the user. This means that things are presented
+ in source order, with (possibly) out of order assembly
+ immediately following. */
+
+static void
+do_mixed_source_and_assembly (struct gdbarch *gdbarch, struct ui_out *uiout,
+ struct disassemble_info *di,
+ struct symtab *main_symtab,
+ CORE_ADDR low, CORE_ADDR high,
+ int how_many, int flags, struct ui_file *stb)
+{
+ const struct linetable_entry *le, *first_le;
+ int i, nlines;
+ int num_displayed = 0;
+ print_source_lines_flags psl_flags = 0;
+ struct cleanup *cleanups;
+ struct cleanup *ui_out_chain;
+ struct cleanup *ui_out_tuple_chain;
+ struct cleanup *ui_out_list_chain;
+ CORE_ADDR pc;
+ struct symtab *last_symtab;
+ int last_line;
+ htab_t dis_line_table;
+
+ gdb_assert (main_symtab != NULL && SYMTAB_LINETABLE (main_symtab) != NULL);
+
+ /* First pass: collect the list of all source files and lines.
+ We do this so that we can only print lines containing code once.
+ We try to print the source text leading up to the next instruction,
+ but if that text is for code that will be disassembled later, then
+ we'll want to defer printing it until later with its associated code. */
+
+ dis_line_table = allocate_dis_line_table ();
+ cleanups = make_cleanup_htab_delete (dis_line_table);
+
+ pc = low;
+
+ /* The prologue may be empty, but there may still be a line number entry
+ for the opening brace which is distinct from the first line of code.
+ If the prologue has been eliminated find_pc_line may return the source
+ line after the opening brace. We still want to print this opening brace.
+ first_le is used to implement this. */
+
+ nlines = SYMTAB_LINETABLE (main_symtab)->nitems;
+ le = SYMTAB_LINETABLE (main_symtab)->item;
+ first_le = NULL;
+
+ /* Skip all the preceding functions. */
+ for (i = 0; i < nlines && le[i].pc < low; i++)
+ continue;
+
+ if (i < nlines && le[i].pc < high)
+ first_le = &le[i];
+
+ /* Add lines for every pc value. */
+ while (pc < high)
+ {
+ struct symtab_and_line sal;
+ int length;
+
+ sal = find_pc_line (pc, 0);
+ length = gdb_insn_length (gdbarch, pc);
+ pc += length;
+
+ if (sal.symtab != NULL)
+ add_dis_line_entry (dis_line_table, sal.symtab, sal.line);
+ }
+
+ /* Second pass: print the disassembly.
+
+ Output format, from an MI perspective:
+ The result is a ui_out list, field name "asm_insns", where elements have
+ name "src_and_asm_line".
+ Each element is a tuple of source line specs (field names line, file,
+ fullname), and field "line_asm_insn" which contains the disassembly.
+ Field "line_asm_insn" is a list of tuples: address, func-name, offset,
+ opcodes, inst.
+
+ CLI output works on top of this because MI ignores ui_out_text output,
+ which is where we put file name and source line contents output.
+
+ Cleanup usage:
+ cleanups:
+ For things created at the beginning of this function and need to be
+ kept until the end of this function.
+ ui_out_chain
+ Handles the outer "asm_insns" list.
+ ui_out_tuple_chain
+ The tuples for each group of consecutive disassemblies.
+ ui_out_list_chain
+ List of consecutive source lines or disassembled insns. */
+
+ if (flags & DISASSEMBLY_FILENAME)
+ psl_flags |= PRINT_SOURCE_LINES_FILENAME;
+
+ ui_out_chain = make_cleanup_ui_out_list_begin_end (uiout, "asm_insns");
+
+ ui_out_tuple_chain = NULL;
+ ui_out_list_chain = NULL;
+
+ last_symtab = NULL;
+ last_line = 0;
+ pc = low;
+
+ while (pc < high)
+ {
+ struct symtab_and_line sal;
+ CORE_ADDR end_pc;
+ int start_preceding_line_to_display = 0;
+ int end_preceding_line_to_display = 0;
+ int new_source_line = 0;
+
+ sal = find_pc_line (pc, 0);
+
+ if (sal.symtab != last_symtab)
+ {
+ /* New source file. */
+ new_source_line = 1;
+
+ /* If this is the first line of output, check for any preceding
+ lines. */
+ if (last_line == 0
+ && first_le != NULL
+ && first_le->line < sal.line)
+ {
+ start_preceding_line_to_display = first_le->line;
+ end_preceding_line_to_display = sal.line;
+ }
+ }
+ else
+ {
+ /* Same source file as last time. */
+ if (sal.symtab != NULL)
+ {
+ if (sal.line > last_line + 1 && last_line != 0)
+ {
+ int l;
+
+ /* Several preceding source lines. Print the trailing ones
+ not associated with code that we'll print later. */
+ for (l = sal.line - 1; l > last_line; --l)
+ {
+ if (line_has_code_p (dis_line_table, sal.symtab, l))
+ break;
+ }
+ if (l < sal.line - 1)
+ {
+ start_preceding_line_to_display = l + 1;
+ end_preceding_line_to_display = sal.line;
+ }
+ }
+ if (sal.line != last_line)
+ new_source_line = 1;
+ else
+ {
+ /* Same source line as last time. This can happen, depending
+ on the debug info. */
+ }
+ }
+ }
+
+ if (new_source_line)
+ {
+ /* Skip the newline if this is the first instruction. */
+ if (pc > low)
+ ui_out_text (uiout, "\n");
+ if (ui_out_tuple_chain != NULL)
+ {
+ gdb_assert (ui_out_list_chain != NULL);
+ do_cleanups (ui_out_list_chain);
+ do_cleanups (ui_out_tuple_chain);
+ }
+ if (sal.symtab != last_symtab
+ && !(flags & DISASSEMBLY_FILENAME))
+ {
+ /* Remember MI ignores ui_out_text.
+ We don't have to do anything here for MI because MI
+ output includes the source specs for each line. */
+ if (sal.symtab != NULL)
+ {
+ ui_out_text (uiout,
+ symtab_to_filename_for_display (sal.symtab));
+ }
+ else
+ ui_out_text (uiout, "unknown");
+ ui_out_text (uiout, ":\n");
+ }
+ if (start_preceding_line_to_display > 0)
+ {
+ /* Several source lines w/o asm instructions associated.
+ We need to preserve the structure of the output, so output
+ a bunch of line tuples with no asm entries. */
+ int l;
+ struct cleanup *ui_out_list_chain_line;
+ struct cleanup *ui_out_tuple_chain_line;
+
+ gdb_assert (sal.symtab != NULL);
+ for (l = start_preceding_line_to_display;
+ l < end_preceding_line_to_display;
+ ++l)
+ {
+ ui_out_tuple_chain_line
+ = make_cleanup_ui_out_tuple_begin_end (uiout,
+ "src_and_asm_line");
+ print_source_lines (sal.symtab, l, l + 1, psl_flags);
+ ui_out_list_chain_line
+ = make_cleanup_ui_out_list_begin_end (uiout,
+ "line_asm_insn");
+ do_cleanups (ui_out_list_chain_line);
+ do_cleanups (ui_out_tuple_chain_line);
+ }
+ }
+ ui_out_tuple_chain
+ = make_cleanup_ui_out_tuple_begin_end (uiout, "src_and_asm_line");
+ if (sal.symtab != NULL)
+ print_source_lines (sal.symtab, sal.line, sal.line + 1, psl_flags);
+ else
+ ui_out_text (uiout, _("--- no source info for this pc ---\n"));
+ ui_out_list_chain
+ = make_cleanup_ui_out_list_begin_end (uiout, "line_asm_insn");
+ }
+ else
+ {
+ /* Here we're appending instructions to an existing line.
+ By construction the very first insn will have a symtab
+ and follow the new_source_line path above. */
+ gdb_assert (ui_out_tuple_chain != NULL);
+ gdb_assert (ui_out_list_chain != NULL);
+ }
+
+ if (sal.end != 0)
+ end_pc = std::min (sal.end, high);
+ else
+ end_pc = pc + 1;
+ num_displayed += dump_insns (gdbarch, uiout, di, pc, end_pc,
+ how_many, flags, stb, &end_pc);
+ pc = end_pc;
+
+ if (how_many >= 0 && num_displayed >= how_many)
+ break;
+
+ last_symtab = sal.symtab;
+ last_line = sal.line;
+ }
+
+ do_cleanups (ui_out_chain);
+ do_cleanups (cleanups);
+}