[binutils.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"

/* 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,
		     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, 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, 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");
	}
      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, 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);
}

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);
  disassemble_info di;
  /* To collect the instruction outputted from opcodes. */
  struct symtab *symtab = NULL;
  struct linetable_entry *le = NULL;
  int nlines = -1;

  INIT_DISASSEMBLE_INFO_NO_ARCH (di, stb->stream,
				 (fprintf_ftype) fprintf_unfiltered);
  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).  Unfortunatly, 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.mach = gdbarch_bfd_arch_info (current_gdbarch)->mach;
  di.endian = gdbarch_byte_order (current_gdbarch);

  /* 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);
}

\f
/* FIXME: cagney/2003-04-28: This global deprecated_tm_print_insn_info
   is going away.  */
disassemble_info deprecated_tm_print_insn_info;

extern void _initialize_disasm (void);

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