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

/* Disassemble support for GDB.

   Copyright 2000, 2001, 2002, 2003 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 2 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, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */

#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, bfd_byte *myaddr, unsigned int len,
		     struct disassemble_info *info)
{
  return target_read_memory (memaddr, (char *) 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 += TARGET_PRINT_INSN (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;

  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++)
    {
      struct cleanup *ui_out_tuple_chain = NULL;
      struct cleanup *ui_out_list_chain = NULL;
      int close_list = 1;
      
      /* 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");
	  /* Don't close the list if the lines are not in order. */
	  if (i < (newlines - 1) && mle[i + 1].line <= mle[i].line)
	    close_list = 0;
	}

      num_displayed += dump_insns (uiout, di, mle[i].start_pc, mle[i].end_pc,
				   how_many, stb);
      if (close_list)
	{
	  do_cleanups (ui_out_list_chain);
	  do_cleanups (ui_out_tuple_chain);
	  ui_out_text (uiout, "\n");
	  close_list = 0;
	}
      if (how_many >= 0)
	if (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
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);
  return di;
}

void
gdb_disassembly (struct ui_out *uiout,
		char *file_string,
		int line_num,
		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 length of the instruction, in bytes.  */

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