[deliverable/binutils-gdb.git] / gdb / disasm.c

/* Disassemble support for GDB.

   Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009
   Free Software Foundation, Inc.

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

#include "defs.h"
#include "target.h"
#include "value.h"
#include "ui-out.h"
#include "gdb_string.h"
#include "disasm.h"
#include "gdbcore.h"
#include "dis-asm.h"

/* Disassemble functions.
   FIXME: We should get rid of all the duplicate code in gdb that does
   the same thing: disassemble_command() and the gdbtk variation. */

/* This Structure is used to store line number information.
   We need a different sort of line table from the normal one cuz we can't
   depend upon implicit line-end pc's for lines to do the
   reordering in this function.  */

struct dis_line_entry
{
  int line;
  CORE_ADDR start_pc;
  CORE_ADDR end_pc;
};

/* Like target_read_memory, but slightly different parameters.  */
static int
dis_asm_read_memory (bfd_vma memaddr, gdb_byte *myaddr, unsigned int len,
		     struct disassemble_info *info)
{
  return target_read_memory (memaddr, myaddr, len);
}

/* Like memory_error with slightly different parameters.  */
static void
dis_asm_memory_error (int status, bfd_vma memaddr,
		      struct disassemble_info *info)
{
  memory_error (status, memaddr);
}

/* Like print_address with slightly different parameters.  */
static void
dis_asm_print_address (bfd_vma addr, struct disassemble_info *info)
{
  struct gdbarch *gdbarch = info->application_data;
  print_address (gdbarch, addr, info->stream);
}

static int
compare_lines (const void *mle1p, const void *mle2p)
{
  struct dis_line_entry *mle1, *mle2;
  int val;

  mle1 = (struct dis_line_entry *) mle1p;
  mle2 = (struct dis_line_entry *) mle2p;

  val = mle1->line - mle2->line;

  if (val != 0)
    return val;

  return mle1->start_pc - mle2->start_pc;
}

static int
dump_insns (struct gdbarch *gdbarch, struct ui_out *uiout,
	    struct disassemble_info * di,
	    CORE_ADDR low, CORE_ADDR high,
	    int how_many, int flags, struct ui_stream *stb)
{
  int num_displayed = 0;
  CORE_ADDR pc;

  /* parts of the symbolic representation of the address */
  int unmapped;
  int offset;
  int line;
  struct cleanup *ui_out_chain;

  for (pc = low; pc < high;)
    {
      char *filename = NULL;
      char *name = NULL;

      QUIT;
      if (how_many >= 0)
	{
	  if (num_displayed >= how_many)
	    break;
	  else
	    num_displayed++;
	}
      ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
      ui_out_text (uiout, pc_prefix (pc));
      ui_out_field_core_addr (uiout, "address", gdbarch, pc);

      if (!build_address_symbolic (pc, 0, &name, &offset, &filename,
				   &line, &unmapped))
	{
	  /* We don't care now about line, filename and
	     unmapped. But we might in the future. */
	  ui_out_text (uiout, " <");
	  ui_out_field_string (uiout, "func-name", name);
	  ui_out_text (uiout, "+");
	  ui_out_field_int (uiout, "offset", offset);
	  ui_out_text (uiout, ">:\t");
	}
      else
	ui_out_text (uiout, ":\t");

      if (filename != NULL)
	xfree (filename);
      if (name != NULL)
	xfree (name);

      ui_file_rewind (stb->stream);
      if (flags & DISASSEMBLY_RAW_INSN)
        {
          CORE_ADDR old_pc = pc;
          bfd_byte data;
          int status;
          pc += gdbarch_print_insn (gdbarch, pc, di);
          for (;old_pc < pc; old_pc++)
            {
              status = (*di->read_memory_func) (old_pc, &data, 1, di);
              if (status != 0)
                (*di->memory_error_func) (status, old_pc, di);
              ui_out_message (uiout, 0, " %02x", (unsigned)data);
            }
          ui_out_text (uiout, "\t");
        }
      else
        pc += gdbarch_print_insn (gdbarch, pc, di);
      ui_out_field_stream (uiout, "inst", stb);
      ui_file_rewind (stb->stream);
      do_cleanups (ui_out_chain);
      ui_out_text (uiout, "\n");
    }
  return num_displayed;
}

/* 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, int nlines,
			      struct linetable_entry *le,
			      CORE_ADDR low, CORE_ADDR high,
			      struct symtab *symtab,
			      int how_many, int flags, struct ui_stream *stb)
{
  int newlines = 0;
  struct dis_line_entry *mle;
  struct symtab_and_line sal;
  int i;
  int out_of_order = 0;
  int next_line = 0;
  CORE_ADDR pc;
  int num_displayed = 0;
  struct cleanup *ui_out_chain;
  struct cleanup *ui_out_tuple_chain = make_cleanup (null_cleanup, 0);
  struct cleanup *ui_out_list_chain = make_cleanup (null_cleanup, 0);

  mle = (struct dis_line_entry *) alloca (nlines
					  * sizeof (struct dis_line_entry));

  /* Copy linetable entries for this function into our data
     structure, creating end_pc's and setting out_of_order as
     appropriate.  */

  /* First, skip all the preceding functions.  */

  for (i = 0; i < nlines - 1 && le[i].pc < low; i++);

  /* Now, copy all entries before the end of this function.  */

  for (; i < nlines - 1 && le[i].pc < high; i++)
    {
      if (le[i].line == le[i + 1].line && le[i].pc == le[i + 1].pc)
	continue;		/* Ignore duplicates */

      /* Skip any end-of-function markers.  */
      if (le[i].line == 0)
	continue;

      mle[newlines].line = le[i].line;
      if (le[i].line > le[i + 1].line)
	out_of_order = 1;
      mle[newlines].start_pc = le[i].pc;
      mle[newlines].end_pc = le[i + 1].pc;
      newlines++;
    }

  /* If we're on the last line, and it's part of the function,
     then we need to get the end pc in a special way.  */

  if (i == nlines - 1 && le[i].pc < high)
    {
      mle[newlines].line = le[i].line;
      mle[newlines].start_pc = le[i].pc;
      sal = find_pc_line (le[i].pc, 0);
      mle[newlines].end_pc = sal.end;
      newlines++;
    }

  /* Now, sort mle by line #s (and, then by addresses within
     lines). */

  if (out_of_order)
    qsort (mle, newlines, sizeof (struct dis_line_entry), compare_lines);

  /* Now, for each line entry, emit the specified lines (unless
     they have been emitted before), followed by the assembly code
     for that line.  */

  ui_out_chain = make_cleanup_ui_out_list_begin_end (uiout, "asm_insns");

  for (i = 0; i < newlines; i++)
    {
      /* Print out everything from next_line to the current line.  */
      if (mle[i].line >= next_line)
	{
	  if (next_line != 0)
	    {
	      /* Just one line to print. */
	      if (next_line == mle[i].line)
		{
		  ui_out_tuple_chain
		    = make_cleanup_ui_out_tuple_begin_end (uiout,
							   "src_and_asm_line");
		  print_source_lines (symtab, next_line, mle[i].line + 1, 0);
		}
	      else
		{
		  /* Several source lines w/o asm instructions associated. */
		  for (; next_line < mle[i].line; next_line++)
		    {
		      struct cleanup *ui_out_list_chain_line;
		      struct cleanup *ui_out_tuple_chain_line;
		      
		      ui_out_tuple_chain_line
			= make_cleanup_ui_out_tuple_begin_end (uiout,
							       "src_and_asm_line");
		      print_source_lines (symtab, next_line, next_line + 1,
					  0);
		      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);
		    }
		  /* Print the last line and leave list open for
		     asm instructions to be added. */
		  ui_out_tuple_chain
		    = make_cleanup_ui_out_tuple_begin_end (uiout,
							   "src_and_asm_line");
		  print_source_lines (symtab, next_line, mle[i].line + 1, 0);
		}
	    }
	  else
	    {
	      ui_out_tuple_chain
		= make_cleanup_ui_out_tuple_begin_end (uiout, "src_and_asm_line");
	      print_source_lines (symtab, mle[i].line, mle[i].line + 1, 0);
	    }

	  next_line = mle[i].line + 1;
	  ui_out_list_chain
	    = make_cleanup_ui_out_list_begin_end (uiout, "line_asm_insn");
	}

      num_displayed += dump_insns (gdbarch, uiout, di,
				   mle[i].start_pc, mle[i].end_pc,
				   how_many, flags, stb);

      /* When we've reached the end of the mle array, or we've seen the last
         assembly range for this source line, close out the list/tuple.  */
      if (i == (newlines - 1) || mle[i + 1].line > mle[i].line)
	{
	  do_cleanups (ui_out_list_chain);
	  do_cleanups (ui_out_tuple_chain);
	  ui_out_tuple_chain = make_cleanup (null_cleanup, 0);
	  ui_out_list_chain = make_cleanup (null_cleanup, 0);
	  ui_out_text (uiout, "\n");
	}
      if (how_many >= 0 && num_displayed >= how_many)
	break;
    }
  do_cleanups (ui_out_chain);
}


static void
do_assembly_only (struct gdbarch *gdbarch, struct ui_out *uiout,
		  struct disassemble_info * di,
		  CORE_ADDR low, CORE_ADDR high,
		  int how_many, int flags, struct ui_stream *stb)
{
  int num_displayed = 0;
  struct cleanup *ui_out_chain;

  ui_out_chain = make_cleanup_ui_out_list_begin_end (uiout, "asm_insns");

  num_displayed = dump_insns (gdbarch, uiout, di, low, high, how_many,
                              flags, stb);

  do_cleanups (ui_out_chain);
}

/* Initialize the disassemble info struct ready for the specified
   stream.  */

static int ATTR_FORMAT (printf, 2, 3)
fprintf_disasm (void *stream, const char *format, ...)
{
  va_list args;
  va_start (args, format);
  vfprintf_filtered (stream, format, args);
  va_end (args);
  /* Something non -ve.  */
  return 0;
}

static struct disassemble_info
gdb_disassemble_info (struct gdbarch *gdbarch, struct ui_file *file)
{
  struct disassemble_info di;
  init_disassemble_info (&di, file, fprintf_disasm);
  di.flavour = bfd_target_unknown_flavour;
  di.memory_error_func = dis_asm_memory_error;
  di.print_address_func = dis_asm_print_address;
  /* NOTE: cagney/2003-04-28: The original code, from the old Insight
     disassembler had a local optomization here.  By default it would
     access the executable file, instead of the target memory (there
     was a growing list of exceptions though).  Unfortunately, the
     heuristic was flawed.  Commands like "disassemble &variable"
     didn't work as they relied on the access going to the target.
     Further, it has been supperseeded by trust-read-only-sections
     (although that should be superseeded by target_trust..._p()).  */
  di.read_memory_func = dis_asm_read_memory;
  di.arch = gdbarch_bfd_arch_info (gdbarch)->arch;
  di.mach = gdbarch_bfd_arch_info (gdbarch)->mach;
  di.endian = gdbarch_byte_order (gdbarch);
  di.endian_code = gdbarch_byte_order_for_code (gdbarch);
  di.application_data = gdbarch;
  disassemble_init_for_target (&di);
  return di;
}

void
gdb_disassembly (struct gdbarch *gdbarch, struct ui_out *uiout,
		char *file_string,
		int flags,
		int how_many, CORE_ADDR low, CORE_ADDR high)
{
  struct ui_stream *stb = ui_out_stream_new (uiout);
  struct cleanup *cleanups = make_cleanup_ui_out_stream_delete (stb);
  struct disassemble_info di = gdb_disassemble_info (gdbarch, stb->stream);
  /* To collect the instruction outputted from opcodes. */
  struct symtab *symtab = NULL;
  struct linetable_entry *le = NULL;
  int nlines = -1;

  /* Assume symtab is valid for whole PC range */
  symtab = find_pc_symtab (low);

  if (symtab != NULL && symtab->linetable != NULL)
    {
      /* Convert the linetable to a bunch of my_line_entry's.  */
      le = symtab->linetable->item;
      nlines = symtab->linetable->nitems;
    }

  if (!(flags & DISASSEMBLY_SOURCE) || nlines <= 0
      || symtab == NULL || symtab->linetable == NULL)
    do_assembly_only (gdbarch, uiout, &di, low, high, how_many, flags, stb);

  else if (flags & DISASSEMBLY_SOURCE)
    do_mixed_source_and_assembly (gdbarch, uiout, &di, nlines, le, low,
				  high, symtab, how_many, flags, stb);

  do_cleanups (cleanups);
  gdb_flush (gdb_stdout);
}

/* Print the instruction at address MEMADDR in debugged memory,
   on STREAM.  Returns the length of the instruction, in bytes,
   and, if requested, the number of branch delay slot instructions.  */

int
gdb_print_insn (struct gdbarch *gdbarch, CORE_ADDR memaddr,
		struct ui_file *stream, int *branch_delay_insns)
{
  struct disassemble_info di;
  int length;

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