[binutils.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_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);
5af949e3	116	ui_out_field_core_addr (uiout, "address", gdbarch, pc);
92df71f0 FN	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	}
13adf674 DJ	129	else
	130	ui_out_text (uiout, ":\t");
	131
92df71f0 FN	132	if (filename != NULL)
	133	xfree (filename);
	134	if (name != NULL)
	135	xfree (name);
	136
	137	ui_file_rewind (stb->stream);
e6158f16 HZ	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);
92df71f0 FN	155	ui_out_field_stream (uiout, "inst", stb);
92df71f0 FN	156	ui_file_rewind (stb->stream);
3b31d625	157	do_cleanups (ui_out_chain);
92df71f0 FN	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
13274fc3	168	do_mixed_source_and_assembly (struct gdbarch gdbarch, struct ui_out uiout,
92df71f0 FN	169	struct disassemble_info *di, int nlines,
	170	struct linetable_entry *le,
	171	CORE_ADDR low, CORE_ADDR high,
	172	struct symtab *symtab,
e6158f16	173	int how_many, int flags, struct ui_stream *stb)
92df71f0 FN	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;
3b31d625	183	struct cleanup *ui_out_chain;
0127c0d3 JJ	184	struct cleanup *ui_out_tuple_chain = make_cleanup (null_cleanup, 0);
0127c0d3 JJ	185	struct cleanup *ui_out_list_chain = make_cleanup (null_cleanup, 0);
92df71f0 FN	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
3b31d625	239	ui_out_chain = make_cleanup_ui_out_list_begin_end (uiout, "asm_insns");
92df71f0 FN	240
	241	for (i = 0; i < newlines; i++)
	242	{
92df71f0 FN	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	{
3b31d625 EZ	251	ui_out_tuple_chain
	252	= make_cleanup_ui_out_tuple_begin_end (uiout,
	253	"src_and_asm_line");
92df71f0 FN	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	{
3b31d625 EZ	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");
92df71f0 FN	267	print_source_lines (symtab, next_line, next_line + 1,
92df71f0 FN	268	0);
3b31d625 EZ	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);
92df71f0 FN	274	}
	275	/* Print the last line and leave list open for
	276	asm instructions to be added. */
3b31d625 EZ	277	ui_out_tuple_chain
	278	= make_cleanup_ui_out_tuple_begin_end (uiout,
	279	"src_and_asm_line");
92df71f0 FN	280	print_source_lines (symtab, next_line, mle[i].line + 1, 0);
	281	}
	282	}
	283	else
	284	{
3b31d625 EZ	285	ui_out_tuple_chain
3b31d625 EZ	286	= make_cleanup_ui_out_tuple_begin_end (uiout, "src_and_asm_line");
92df71f0 FN	287	print_source_lines (symtab, mle[i].line, mle[i].line + 1, 0);
	288	}
	289
	290	next_line = mle[i].line + 1;
3b31d625 EZ	291	ui_out_list_chain
3b31d625 EZ	292	= make_cleanup_ui_out_list_begin_end (uiout, "line_asm_insn");
92df71f0 FN	293	}
92df71f0 FN	294
13274fc3 UW	295	num_displayed += dump_insns (gdbarch, uiout, di,
13274fc3 UW	296	mle[i].start_pc, mle[i].end_pc,
e6158f16	297	how_many, flags, stb);
0127c0d3 JJ	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)
92df71f0	302	{
3b31d625 EZ	303	do_cleanups (ui_out_list_chain);
3b31d625 EZ	304	do_cleanups (ui_out_tuple_chain);
0127c0d3 JJ	305	ui_out_tuple_chain = make_cleanup (null_cleanup, 0);
0127c0d3 JJ	306	ui_out_list_chain = make_cleanup (null_cleanup, 0);
92df71f0	307	ui_out_text (uiout, "\n");
92df71f0	308	}
0127c0d3 JJ	309	if (how_many >= 0 && num_displayed >= how_many)
0127c0d3 JJ	310	break;
92df71f0	311	}
3b31d625	312	do_cleanups (ui_out_chain);
92df71f0 FN	313	}
	314
	315
	316	static void
13274fc3 UW	317	do_assembly_only (struct gdbarch gdbarch, struct ui_out uiout,
13274fc3 UW	318	struct disassemble_info * di,
92df71f0	319	CORE_ADDR low, CORE_ADDR high,
e6158f16	320	int how_many, int flags, struct ui_stream *stb)
92df71f0 FN	321	{
92df71f0 FN	322	int num_displayed = 0;
3b31d625	323	struct cleanup *ui_out_chain;
92df71f0	324
3b31d625	325	ui_out_chain = make_cleanup_ui_out_list_begin_end (uiout, "asm_insns");
92df71f0	326
e6158f16 HZ	327	num_displayed = dump_insns (gdbarch, uiout, di, low, high, how_many,
e6158f16 HZ	328	flags, stb);
92df71f0	329
3b31d625	330	do_cleanups (ui_out_chain);
92df71f0 FN	331	}
92df71f0 FN	332
92bf2b80 AC	333	/* Initialize the disassemble info struct ready for the specified
	334	stream. */
	335
bee0189a	336	static int ATTR_FORMAT (printf, 2, 3)
242e8be5 AC	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
a89aa300	347	static struct disassemble_info
92bf2b80	348	gdb_disassemble_info (struct gdbarch gdbarch, struct ui_file file)
92df71f0	349	{
a89aa300	350	struct disassemble_info di;
242e8be5	351	init_disassemble_info (&di, file, fprintf_disasm);
2b6fd0d8 AC	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
ce2826aa	358	was a growing list of exceptions though). Unfortunately, the
2b6fd0d8 AC	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;
22b0d388	364	di.arch = gdbarch_bfd_arch_info (gdbarch)->arch;
92bf2b80 AC	365	di.mach = gdbarch_bfd_arch_info (gdbarch)->mach;
92bf2b80 AC	366	di.endian = gdbarch_byte_order (gdbarch);
9d4fde75	367	di.endian_code = gdbarch_byte_order_for_code (gdbarch);
5af949e3	368	di.application_data = gdbarch;
2877b4cc	369	disassemble_init_for_target (&di);
92bf2b80 AC	370	return di;
	371	}
	372
	373	void
13274fc3	374	gdb_disassembly (struct gdbarch gdbarch, struct ui_out uiout,
92bf2b80	375	char *file_string,
e6158f16	376	int flags,
92bf2b80 AC	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);
13274fc3	381	struct disassemble_info di = gdb_disassemble_info (gdbarch, stb->stream);
92bf2b80 AC	382	/* To collect the instruction outputted from opcodes. */
	383	struct symtab *symtab = NULL;
	384	struct linetable_entry *le = NULL;
	385	int nlines = -1;
92df71f0	386
92df71f0 FN	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
e6158f16	397	if (!(flags & DISASSEMBLY_SOURCE) \|\| nlines <= 0
92df71f0	398	\|\| symtab == NULL \|\| symtab->linetable == NULL)
e6158f16	399	do_assembly_only (gdbarch, uiout, &di, low, high, how_many, flags, stb);
92df71f0	400
e6158f16	401	else if (flags & DISASSEMBLY_SOURCE)
13274fc3	402	do_mixed_source_and_assembly (gdbarch, uiout, &di, nlines, le, low,
e6158f16	403	high, symtab, how_many, flags, stb);
92df71f0	404
2b6fd0d8	405	do_cleanups (cleanups);
92df71f0 FN	406	gdb_flush (gdb_stdout);
92df71f0 FN	407	}
810ecf9f	408
92bf2b80	409	/* Print the instruction at address MEMADDR in debugged memory,
a4642986 MR	410	on STREAM. Returns the length of the instruction, in bytes,
a4642986 MR	411	and, if requested, the number of branch delay slot instructions. */
92bf2b80 AC	412
92bf2b80 AC	413	int
13274fc3 UW	414	gdb_print_insn (struct gdbarch *gdbarch, CORE_ADDR memaddr,
13274fc3 UW	415	struct ui_file stream, int branch_delay_insns)
92bf2b80	416	{
a4642986 MR	417	struct disassemble_info di;
	418	int length;
	419
13274fc3 UW	420	di = gdb_disassemble_info (gdbarch, stream);
13274fc3 UW	421	length = gdbarch_print_insn (gdbarch, memaddr, &di);
a4642986 MR	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;
92bf2b80	430	}