[deliverable/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"

/* 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");
	}
      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, 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 disassemble_info
gdb_disassemble_info (struct gdbarch *gdbarch, struct ui_file *file)
{
  disassemble_info di;
  INIT_DISASSEMBLE_INFO_NO_ARCH (di, file,
				 (fprintf_ftype) fprintf_filtered);
  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 (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);
  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)
{
  disassemble_info di = gdb_disassemble_info (current_gdbarch, stream);
  return TARGET_PRINT_INSN (memaddr, &di);
}

\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	}
13adf674 DJ	126	else
	127	ui_out_text (uiout, ":\t");
	128
92df71f0 FN	129	if (filename != NULL)
	130	xfree (filename);
	131	if (name != NULL)
	132	xfree (name);
	133
	134	ui_file_rewind (stb->stream);
	135	pc += TARGET_PRINT_INSN (pc, di);
	136	ui_out_field_stream (uiout, "inst", stb);
	137	ui_file_rewind (stb->stream);
3b31d625	138	do_cleanups (ui_out_chain);
92df71f0 FN	139	ui_out_text (uiout, "\n");
	140	}
	141	return num_displayed;
	142	}
	143
	144	/* The idea here is to present a source-O-centric view of a
	145	function to the user. This means that things are presented
	146	in source order, with (possibly) out of order assembly
	147	immediately following. */
	148	static void
	149	do_mixed_source_and_assembly (struct ui_out *uiout,
	150	struct disassemble_info *di, int nlines,
	151	struct linetable_entry *le,
	152	CORE_ADDR low, CORE_ADDR high,
	153	struct symtab *symtab,
	154	int how_many, struct ui_stream *stb)
	155	{
	156	int newlines = 0;
	157	struct dis_line_entry *mle;
	158	struct symtab_and_line sal;
	159	int i;
	160	int out_of_order = 0;
	161	int next_line = 0;
	162	CORE_ADDR pc;
	163	int num_displayed = 0;
3b31d625	164	struct cleanup *ui_out_chain;
92df71f0 FN	165
	166	mle = (struct dis_line_entry *) alloca (nlines
	167	* sizeof (struct dis_line_entry));
	168
	169	/* Copy linetable entries for this function into our data
	170	structure, creating end_pc's and setting out_of_order as
	171	appropriate. */
	172
	173	/* First, skip all the preceding functions. */
	174
	175	for (i = 0; i < nlines - 1 && le[i].pc < low; i++);
	176
	177	/* Now, copy all entries before the end of this function. */
	178
	179	for (; i < nlines - 1 && le[i].pc < high; i++)
	180	{
	181	if (le[i].line == le[i + 1].line && le[i].pc == le[i + 1].pc)
	182	continue; /* Ignore duplicates */
	183
	184	/* Skip any end-of-function markers. */
	185	if (le[i].line == 0)
	186	continue;
	187
	188	mle[newlines].line = le[i].line;
	189	if (le[i].line > le[i + 1].line)
	190	out_of_order = 1;
	191	mle[newlines].start_pc = le[i].pc;
	192	mle[newlines].end_pc = le[i + 1].pc;
	193	newlines++;
	194	}
	195
	196	/* If we're on the last line, and it's part of the function,
	197	then we need to get the end pc in a special way. */
	198
	199	if (i == nlines - 1 && le[i].pc < high)
	200	{
	201	mle[newlines].line = le[i].line;
	202	mle[newlines].start_pc = le[i].pc;
	203	sal = find_pc_line (le[i].pc, 0);
	204	mle[newlines].end_pc = sal.end;
	205	newlines++;
	206	}
	207
	208	/* Now, sort mle by line #s (and, then by addresses within
	209	lines). */
	210
	211	if (out_of_order)
	212	qsort (mle, newlines, sizeof (struct dis_line_entry), compare_lines);
	213
	214	/* Now, for each line entry, emit the specified lines (unless
	215	they have been emitted before), followed by the assembly code
	216	for that line. */
	217
3b31d625	218	ui_out_chain = make_cleanup_ui_out_list_begin_end (uiout, "asm_insns");
92df71f0 FN	219
	220	for (i = 0; i < newlines; i++)
	221	{
3b31d625 EZ	222	struct cleanup *ui_out_tuple_chain = NULL;
3b31d625 EZ	223	struct cleanup *ui_out_list_chain = NULL;
92df71f0	224	int close_list = 1;
3b31d625	225
92df71f0 FN	226	/* Print out everything from next_line to the current line. */
	227	if (mle[i].line >= next_line)
	228	{
	229	if (next_line != 0)
	230	{
	231	/* Just one line to print. */
	232	if (next_line == mle[i].line)
	233	{
3b31d625 EZ	234	ui_out_tuple_chain
	235	= make_cleanup_ui_out_tuple_begin_end (uiout,
	236	"src_and_asm_line");
92df71f0 FN	237	print_source_lines (symtab, next_line, mle[i].line + 1, 0);
	238	}
	239	else
	240	{
	241	/* Several source lines w/o asm instructions associated. */
	242	for (; next_line < mle[i].line; next_line++)
	243	{
3b31d625 EZ	244	struct cleanup *ui_out_list_chain_line;
	245	struct cleanup *ui_out_tuple_chain_line;
	246
	247	ui_out_tuple_chain_line
	248	= make_cleanup_ui_out_tuple_begin_end (uiout,
	249	"src_and_asm_line");
92df71f0 FN	250	print_source_lines (symtab, next_line, next_line + 1,
92df71f0 FN	251	0);
3b31d625 EZ	252	ui_out_list_chain_line
	253	= make_cleanup_ui_out_list_begin_end (uiout,
	254	"line_asm_insn");
	255	do_cleanups (ui_out_list_chain_line);
	256	do_cleanups (ui_out_tuple_chain_line);
92df71f0 FN	257	}
	258	/* Print the last line and leave list open for
	259	asm instructions to be added. */
3b31d625 EZ	260	ui_out_tuple_chain
	261	= make_cleanup_ui_out_tuple_begin_end (uiout,
	262	"src_and_asm_line");
92df71f0 FN	263	print_source_lines (symtab, next_line, mle[i].line + 1, 0);
	264	}
	265	}
	266	else
	267	{
3b31d625 EZ	268	ui_out_tuple_chain
3b31d625 EZ	269	= make_cleanup_ui_out_tuple_begin_end (uiout, "src_and_asm_line");
92df71f0 FN	270	print_source_lines (symtab, mle[i].line, mle[i].line + 1, 0);
	271	}
	272
	273	next_line = mle[i].line + 1;
3b31d625 EZ	274	ui_out_list_chain
3b31d625 EZ	275	= make_cleanup_ui_out_list_begin_end (uiout, "line_asm_insn");
92df71f0 FN	276	/* Don't close the list if the lines are not in order. */
	277	if (i < (newlines - 1) && mle[i + 1].line <= mle[i].line)
	278	close_list = 0;
	279	}
	280
	281	num_displayed += dump_insns (uiout, di, mle[i].start_pc, mle[i].end_pc,
	282	how_many, stb);
	283	if (close_list)
	284	{
3b31d625 EZ	285	do_cleanups (ui_out_list_chain);
3b31d625 EZ	286	do_cleanups (ui_out_tuple_chain);
92df71f0 FN	287	ui_out_text (uiout, "\n");
	288	close_list = 0;
	289	}
	290	if (how_many >= 0)
	291	if (num_displayed >= how_many)
	292	break;
	293	}
3b31d625	294	do_cleanups (ui_out_chain);
92df71f0 FN	295	}
	296
	297
	298	static void
	299	do_assembly_only (struct ui_out uiout, disassemble_info di,
	300	CORE_ADDR low, CORE_ADDR high,
	301	int how_many, struct ui_stream *stb)
	302	{
	303	int num_displayed = 0;
3b31d625	304	struct cleanup *ui_out_chain;
92df71f0	305
3b31d625	306	ui_out_chain = make_cleanup_ui_out_list_begin_end (uiout, "asm_insns");
92df71f0 FN	307
	308	num_displayed = dump_insns (uiout, di, low, high, how_many, stb);
	309
3b31d625	310	do_cleanups (ui_out_chain);
92df71f0 FN	311	}
92df71f0 FN	312
92bf2b80 AC	313	/* Initialize the disassemble info struct ready for the specified
	314	stream. */
	315
	316	static disassemble_info
	317	gdb_disassemble_info (struct gdbarch gdbarch, struct ui_file file)
92df71f0	318	{
2b6fd0d8	319	disassemble_info di;
92bf2b80	320	INIT_DISASSEMBLE_INFO_NO_ARCH (di, file,
3c23e6fb	321	(fprintf_ftype) fprintf_filtered);
2b6fd0d8 AC	322	di.flavour = bfd_target_unknown_flavour;
	323	di.memory_error_func = dis_asm_memory_error;
	324	di.print_address_func = dis_asm_print_address;
	325	/* NOTE: cagney/2003-04-28: The original code, from the old Insight
	326	disassembler had a local optomization here. By default it would
	327	access the executable file, instead of the target memory (there
	328	was a growing list of exceptions though). Unfortunatly, the
	329	heuristic was flawed. Commands like "disassemble &variable"
	330	didn't work as they relied on the access going to the target.
	331	Further, it has been supperseeded by trust-read-only-sections
	332	(although that should be superseeded by target_trust..._p()). */
	333	di.read_memory_func = dis_asm_read_memory;
92bf2b80 AC	334	di.mach = gdbarch_bfd_arch_info (gdbarch)->mach;
	335	di.endian = gdbarch_byte_order (gdbarch);
	336	return di;
	337	}
	338
	339	void
	340	gdb_disassembly (struct ui_out *uiout,
	341	char *file_string,
	342	int line_num,
	343	int mixed_source_and_assembly,
	344	int how_many, CORE_ADDR low, CORE_ADDR high)
	345	{
	346	struct ui_stream *stb = ui_out_stream_new (uiout);
	347	struct cleanup *cleanups = make_cleanup_ui_out_stream_delete (stb);
	348	disassemble_info di = gdb_disassemble_info (current_gdbarch, stb->stream);
	349	/* To collect the instruction outputted from opcodes. */
	350	struct symtab *symtab = NULL;
	351	struct linetable_entry *le = NULL;
	352	int nlines = -1;
92df71f0	353
92df71f0 FN	354	/* Assume symtab is valid for whole PC range */
	355	symtab = find_pc_symtab (low);
	356
	357	if (symtab != NULL && symtab->linetable != NULL)
	358	{
	359	/* Convert the linetable to a bunch of my_line_entry's. */
	360	le = symtab->linetable->item;
	361	nlines = symtab->linetable->nitems;
	362	}
	363
	364	if (!mixed_source_and_assembly \|\| nlines <= 0
	365	\|\| symtab == NULL \|\| symtab->linetable == NULL)
	366	do_assembly_only (uiout, &di, low, high, how_many, stb);
	367
	368	else if (mixed_source_and_assembly)
	369	do_mixed_source_and_assembly (uiout, &di, nlines, le, low,
	370	high, symtab, how_many, stb);
	371
2b6fd0d8	372	do_cleanups (cleanups);
92df71f0 FN	373	gdb_flush (gdb_stdout);
92df71f0 FN	374	}
810ecf9f	375
92bf2b80 AC	376	/* Print the instruction at address MEMADDR in debugged memory,
	377	on STREAM. Returns length of the instruction, in bytes. */
	378
	379	int
	380	gdb_print_insn (CORE_ADDR memaddr, struct ui_file *stream)
	381	{
	382	disassemble_info di = gdb_disassemble_info (current_gdbarch, stream);
	383	return TARGET_PRINT_INSN (memaddr, &di);
	384	}
	385
810ecf9f AC	386	\f
	387	/* FIXME: cagney/2003-04-28: This global deprecated_tm_print_insn_info
	388	is going away. */
	389	disassemble_info deprecated_tm_print_insn_info;
	390
	391	extern void _initialize_disasm (void);
	392
	393	void
	394	_initialize_disasm (void)
	395	{
92bf2b80	396
810ecf9f AC	397	INIT_DISASSEMBLE_INFO_NO_ARCH (deprecated_tm_print_insn_info, gdb_stdout,
	398	(fprintf_ftype)fprintf_filtered);
	399	deprecated_tm_print_insn_info.flavour = bfd_target_unknown_flavour;
	400	deprecated_tm_print_insn_info.read_memory_func = dis_asm_read_memory;
	401	deprecated_tm_print_insn_info.memory_error_func = dis_asm_memory_error;
	402	deprecated_tm_print_insn_info.print_address_func = dis_asm_print_address;
	403	}