[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)
{
  print_address (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 ui_out *uiout, struct disassemble_info * di,
	    CORE_ADDR low, CORE_ADDR high,
	    int how_many, 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_field_core_addr (uiout, "address", 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);
      pc += gdbarch_print_insn (current_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 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, 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 (uiout, di, mle[i].start_pc, mle[i].end_pc,
				   how_many, 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 ui_out *uiout, struct disassemble_info * di,
		  CORE_ADDR low, CORE_ADDR high,
		  int how_many, 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 (uiout, di, low, high, how_many, 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);
  disassemble_init_for_target (&di);
  return di;
}

void
gdb_disassembly (struct ui_out *uiout,
		char *file_string,
		int mixed_source_and_assembly,
		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 (current_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 (!mixed_source_and_assembly || nlines <= 0
      || symtab == NULL || symtab->linetable == NULL)
    do_assembly_only (uiout, &di, low, high, how_many, stb);

  else if (mixed_source_and_assembly)
    do_mixed_source_and_assembly (uiout, &di, nlines, le, low,
				  high, symtab, how_many, 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 (CORE_ADDR memaddr, struct ui_file *stream,
		int *branch_delay_insns)
{
  struct disassemble_info di;
  int length;

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