[deliverable/binutils-gdb.git] / gdb / tui / tuiDisassem.c

/* Disassembly display.
   Copyright 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
   Contributed by Hewlett-Packard Company.

   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 "symtab.h"
#include "breakpoint.h"
#include "frame.h"

#include "tui.h"
#include "tuiData.h"
#include "tuiLayout.h"
#include "tuiSourceWin.h"
#include "tuiStack.h"


/*****************************************
** STATIC LOCAL FUNCTIONS FORWARD DECLS    **
******************************************/

static struct breakpoint *_hasBreak (CORE_ADDR);


/*****************************************
** PUBLIC FUNCTIONS                        **
******************************************/

/*
   ** tuiSetDisassemContent().
   **        Function to set the disassembly window's content.
 */
TuiStatus
tuiSetDisassemContent (struct symtab *s, Opaque startAddr)
{
  TuiStatus ret = TUI_FAILURE;
  struct ui_file *gdb_dis_out;

  if (startAddr != (Opaque) NULL)
    {
      register int i, desc;

      if ((ret = tuiAllocSourceBuffer (disassemWin)) == TUI_SUCCESS)
	{
	  register int offset = disassemWin->detail.sourceInfo.horizontalOffset;
	  register int threshold, curLine = 0, lineWidth, maxLines;
	  CORE_ADDR newpc, pc;
	  disassemble_info asmInfo;
	  TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
extern void strcat_address (CORE_ADDR, char *, int);
extern void strcat_address_numeric (CORE_ADDR, int, char *, int);
	  int curLen = 0;
	  int tab_len = tuiDefaultTabLen ();

	  maxLines = disassemWin->generic.height - 2;	/* account for hilite */
	  lineWidth = disassemWin->generic.width - 1;
	  threshold = (lineWidth - 1) + offset;

	  /* now init the ui_file structure */
	  gdb_dis_out = tui_sfileopen (threshold);

	  INIT_DISASSEMBLE_INFO_NO_ARCH (asmInfo, gdb_dis_out, (fprintf_ftype) fprintf_filtered);
	  asmInfo.read_memory_func = dis_asm_read_memory;
	  asmInfo.memory_error_func = dis_asm_memory_error;

	  disassemWin->detail.sourceInfo.startLineOrAddr.addr = startAddr;

	  /* Now construct each line */
	  for (curLine = 0, pc = (CORE_ADDR) startAddr; (curLine < maxLines);)
	    {
	      TuiWinElementPtr element = (TuiWinElementPtr) disassemWin->generic.content[curLine];
	      struct breakpoint *bp;

	      print_address (pc, gdb_dis_out);

	      curLen = strlen (tui_file_get_strbuf (gdb_dis_out));
	      i = curLen - ((curLen / tab_len) * tab_len);

	      /* adjust buffer length if necessary */
	      tui_file_adjust_strbuf ((tab_len - i > 0) ? (tab_len - i) : 0, gdb_dis_out);

	      /* Add spaces to make the instructions start onthe same column */
	      while (i < tab_len)
		{
		  tui_file_get_strbuf (gdb_dis_out)[curLen] = ' ';
		  i++;
		  curLen++;
		}
	      tui_file_get_strbuf (gdb_dis_out)[curLen] = '\0';

	      newpc = pc + ((*tm_print_insn) (pc, &asmInfo));

	      /* Now copy the line taking the offset into account */
	      if (strlen (tui_file_get_strbuf (gdb_dis_out)) > offset)
		strcpy (element->whichElement.source.line,
			&(tui_file_get_strbuf (gdb_dis_out)[offset]));
	      else
		element->whichElement.source.line[0] = '\0';
	      element->whichElement.source.lineOrAddr.addr = (Opaque) pc;
	      element->whichElement.source.isExecPoint =
		(pc == (CORE_ADDR) ((TuiWinElementPtr) locator->content[0])->whichElement.locator.addr);
	      bp = _hasBreak (pc);
	      element->whichElement.source.hasBreak =
		(bp != (struct breakpoint *) NULL &&
		 (!element->whichElement.source.isExecPoint ||
		  (bp->disposition != del || bp->hit_count <= 0)));
	      curLine++;
	      pc = newpc;
	      /* reset the buffer to empty */
	      tui_file_get_strbuf (gdb_dis_out)[0] = '\0';
	    }
	  ui_file_delete (gdb_dis_out);
	  gdb_dis_out = NULL;
	  disassemWin->generic.contentSize = curLine;
	  ret = TUI_SUCCESS;
	}
    }

  return ret;
}				/* tuiSetDisassemContent */


/*
   ** tuiShowDisassem().
   **        Function to display the disassembly window with disassembled code.
 */
void
tuiShowDisassem (Opaque startAddr)
{
  struct symtab *s = find_pc_symtab ((CORE_ADDR) startAddr);
  TuiWinInfoPtr winWithFocus = tuiWinWithFocus ();

  tuiAddWinToLayout (DISASSEM_WIN);
  tuiUpdateSourceWindow (disassemWin, s, startAddr, FALSE);
  /*
     ** if the focus was in the src win, put it in the asm win, if the
     ** source view isn't split
   */
  if (currentLayout () != SRC_DISASSEM_COMMAND && winWithFocus == srcWin)
    tuiSetWinFocusTo (disassemWin);

  return;
}				/* tuiShowDisassem */


/*
   ** tuiShowDisassemAndUpdateSource().
   **        Function to display the disassembly window.
 */
void
tuiShowDisassemAndUpdateSource (Opaque startAddr)
{
  struct symtab_and_line sal;

  tuiShowDisassem (startAddr);
  if (currentLayout () == SRC_DISASSEM_COMMAND)
    {
      TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
      /*
         ** Update what is in the source window if it is displayed too,
         ** note that it follows what is in the disassembly window and visa-versa
       */
      sal = find_pc_line ((CORE_ADDR) startAddr, 0);
      current_source_symtab = sal.symtab;
      tuiUpdateSourceWindow (srcWin, sal.symtab, (Opaque) sal.line, TRUE);
      tuiUpdateLocatorFilename (sal.symtab->filename);
    }

  return;
}				/* tuiShowDisassemAndUpdateSource */


/*
   ** tuiShowDisassemAsIs().
   **        Function to display the disassembly window.  This function shows
   **        the disassembly as specified by the horizontal offset.
 */
void
tuiShowDisassemAsIs (Opaque addr)
{
  tuiAddWinToLayout (DISASSEM_WIN);
  tuiUpdateSourceWindowAsIs (disassemWin, (struct symtab *) NULL, addr, FALSE);
  /*
     ** Update what is in the source window if it is displayed too, not that it
     ** follows what is in the disassembly window and visa-versa
   */
  if (currentLayout () == SRC_DISASSEM_COMMAND)
    tuiShowSourceContent (srcWin);	/*????  Need to do more? */

  return;
}				/* tuiShowDisassem */


/*
   ** tuiGetBeginAsmAddress().
 */
Opaque
tuiGetBeginAsmAddress (void)
{
  TuiGenWinInfoPtr locator;
  TuiLocatorElementPtr element;
  Opaque addr;

  locator = locatorWinInfoPtr ();
  element = &((TuiWinElementPtr) locator->content[0])->whichElement.locator;

  if (element->addr == (Opaque) 0)
    {
      /*the target is not executing, because the pc is 0 */

      addr = (Opaque) parse_and_eval_address ("main");

      if (addr == (Opaque) 0)
	addr = (Opaque) parse_and_eval_address ("MAIN");

    }
  else				/* the target is executing */
    addr = element->addr;

  return addr;
}				/* tuiGetBeginAsmAddress */


/*
   ** tuiVerticalDisassemScroll().
   **      Scroll the disassembly forward or backward vertically
 */
void
tuiVerticalDisassemScroll (TuiScrollDirection scrollDirection,
                           int numToScroll)
{
  if (disassemWin->generic.content != (OpaquePtr) NULL)
    {
      Opaque pc, lowAddr;
      TuiWinContent content;
      struct symtab *s;

      content = (TuiWinContent) disassemWin->generic.content;
      if (current_source_symtab == (struct symtab *) NULL)
	s = find_pc_symtab (selected_frame->pc);
      else
	s = current_source_symtab;

      pc = content[0]->whichElement.source.lineOrAddr.addr;
      if (find_pc_partial_function ((CORE_ADDR) pc,
				    (char **) NULL,
				    (CORE_ADDR *) & lowAddr,
				    (CORE_ADDR) NULL) == 0)
	error ("No function contains prgram counter for selected frame.\n");
      else
	{
	  register int line = 0;
	  register Opaque newLow;
	  bfd_byte buffer[4];

	  newLow = pc;
	  if (scrollDirection == FORWARD_SCROLL)
	    {
	      for (; line < numToScroll; line++)
		newLow += sizeof (bfd_getb32 (buffer));
	    }
	  else
	    {
	      for (; newLow >= (Opaque) 0 && line < numToScroll; line++)
		newLow -= sizeof (bfd_getb32 (buffer));
	    }
	  tuiUpdateSourceWindowAsIs (disassemWin, s, newLow, FALSE);
	}
    }

  return;
}				/* tuiVerticalDisassemScroll */


/*****************************************
** STATIC LOCAL FUNCTIONS                 **
******************************************/
/*
   ** _hasBreak().
   **      Answer whether there is a break point at the input line in the
   **      source file indicated
 */
static struct breakpoint *
_hasBreak (CORE_ADDR addr)
{
  struct breakpoint *bpWithBreak = (struct breakpoint *) NULL;
  struct breakpoint *bp;
  extern struct breakpoint *breakpoint_chain;


  for (bp = breakpoint_chain;
       (bp != (struct breakpoint *) NULL &&
	bpWithBreak == (struct breakpoint *) NULL);
       bp = bp->next)
    if (addr == bp->address)
      bpWithBreak = bp;

  return bpWithBreak;
}				/* _hasBreak */
Commit	Line	Data
f377b406 SC	1	/* Disassembly display.
	2	Copyright 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
	3	Contributed by Hewlett-Packard Company.
	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. */
c906108c SS	21
	22	#include "defs.h"
	23	#include "symtab.h"
	24	#include "breakpoint.h"
	25	#include "frame.h"
	26
	27	#include "tui.h"
	28	#include "tuiData.h"
	29	#include "tuiLayout.h"
	30	#include "tuiSourceWin.h"
	31	#include "tuiStack.h"
	32
	33
	34	/*****************************************
	35	STATIC LOCAL FUNCTIONS FORWARD DECLS
	36	******************************************/
	37
a14ed312	38	static struct breakpoint *_hasBreak (CORE_ADDR);
c906108c SS	39
	40
	41	/*****************************************
	42	PUBLIC FUNCTIONS
	43	******************************************/
	44
	45	/*
c5aa993b JM	46	** tuiSetDisassemContent().
	47	** Function to set the disassembly window's content.
	48	*/
c906108c	49	TuiStatus
eca6576c	50	tuiSetDisassemContent (struct symtab *s, Opaque startAddr)
c906108c SS	51	{
c906108c SS	52	TuiStatus ret = TUI_FAILURE;
d9fcf2fb	53	struct ui_file *gdb_dis_out;
c906108c SS	54
	55	if (startAddr != (Opaque) NULL)
	56	{
	57	register int i, desc;
	58
	59	if ((ret = tuiAllocSourceBuffer (disassemWin)) == TUI_SUCCESS)
	60	{
	61	register int offset = disassemWin->detail.sourceInfo.horizontalOffset;
	62	register int threshold, curLine = 0, lineWidth, maxLines;
	63	CORE_ADDR newpc, pc;
	64	disassemble_info asmInfo;
	65	TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
a14ed312 KB	66	extern void strcat_address (CORE_ADDR, char *, int);
a14ed312 KB	67	extern void strcat_address_numeric (CORE_ADDR, int, char *, int);
c906108c SS	68	int curLen = 0;
	69	int tab_len = tuiDefaultTabLen ();
	70
	71	maxLines = disassemWin->generic.height - 2; /* account for hilite */
	72	lineWidth = disassemWin->generic.width - 1;
	73	threshold = (lineWidth - 1) + offset;
	74
d9fcf2fb	75	/* now init the ui_file structure */
11cf8741	76	gdb_dis_out = tui_sfileopen (threshold);
c906108c SS	77
	78	INIT_DISASSEMBLE_INFO_NO_ARCH (asmInfo, gdb_dis_out, (fprintf_ftype) fprintf_filtered);
	79	asmInfo.read_memory_func = dis_asm_read_memory;
	80	asmInfo.memory_error_func = dis_asm_memory_error;
	81
	82	disassemWin->detail.sourceInfo.startLineOrAddr.addr = startAddr;
	83
	84	/* Now construct each line */
	85	for (curLine = 0, pc = (CORE_ADDR) startAddr; (curLine < maxLines);)
	86	{
c5aa993b	87	TuiWinElementPtr element = (TuiWinElementPtr) disassemWin->generic.content[curLine];
c906108c SS	88	struct breakpoint *bp;
	89
	90	print_address (pc, gdb_dis_out);
	91
11cf8741	92	curLen = strlen (tui_file_get_strbuf (gdb_dis_out));
c906108c SS	93	i = curLen - ((curLen / tab_len) * tab_len);
c906108c SS	94
c5aa993b	95	/* adjust buffer length if necessary */
11cf8741	96	tui_file_adjust_strbuf ((tab_len - i > 0) ? (tab_len - i) : 0, gdb_dis_out);
c5aa993b	97
c906108c SS	98	/* Add spaces to make the instructions start onthe same column */
	99	while (i < tab_len)
	100	{
11cf8741	101	tui_file_get_strbuf (gdb_dis_out)[curLen] = ' ';
c906108c SS	102	i++;
	103	curLen++;
	104	}
11cf8741	105	tui_file_get_strbuf (gdb_dis_out)[curLen] = '\0';
c906108c SS	106
	107	newpc = pc + ((*tm_print_insn) (pc, &asmInfo));
	108
	109	/* Now copy the line taking the offset into account */
11cf8741	110	if (strlen (tui_file_get_strbuf (gdb_dis_out)) > offset)
c906108c	111	strcpy (element->whichElement.source.line,
11cf8741	112	&(tui_file_get_strbuf (gdb_dis_out)[offset]));
c906108c SS	113	else
	114	element->whichElement.source.line[0] = '\0';
	115	element->whichElement.source.lineOrAddr.addr = (Opaque) pc;
	116	element->whichElement.source.isExecPoint =
c5aa993b	117	(pc == (CORE_ADDR) ((TuiWinElementPtr) locator->content[0])->whichElement.locator.addr);
c906108c SS	118	bp = _hasBreak (pc);
	119	element->whichElement.source.hasBreak =
	120	(bp != (struct breakpoint *) NULL &&
	121	(!element->whichElement.source.isExecPoint \|\|
	122	(bp->disposition != del \|\| bp->hit_count <= 0)));
	123	curLine++;
	124	pc = newpc;
c5aa993b	125	/* reset the buffer to empty */
11cf8741	126	tui_file_get_strbuf (gdb_dis_out)[0] = '\0';
c906108c	127	}
d9fcf2fb	128	ui_file_delete (gdb_dis_out);
11cf8741	129	gdb_dis_out = NULL;
c906108c SS	130	disassemWin->generic.contentSize = curLine;
	131	ret = TUI_SUCCESS;
	132	}
	133	}
	134
	135	return ret;
	136	} /* tuiSetDisassemContent */
	137
	138
	139	/*
c5aa993b JM	140	** tuiShowDisassem().
	141	** Function to display the disassembly window with disassembled code.
	142	*/
c906108c	143	void
eca6576c	144	tuiShowDisassem (Opaque startAddr)
c906108c SS	145	{
	146	struct symtab *s = find_pc_symtab ((CORE_ADDR) startAddr);
	147	TuiWinInfoPtr winWithFocus = tuiWinWithFocus ();
	148
	149	tuiAddWinToLayout (DISASSEM_WIN);
	150	tuiUpdateSourceWindow (disassemWin, s, startAddr, FALSE);
	151	/*
c5aa993b JM	152	** if the focus was in the src win, put it in the asm win, if the
	153	** source view isn't split
	154	*/
c906108c SS	155	if (currentLayout () != SRC_DISASSEM_COMMAND && winWithFocus == srcWin)
	156	tuiSetWinFocusTo (disassemWin);
	157
	158	return;
	159	} /* tuiShowDisassem */
	160
	161
	162	/*
c5aa993b JM	163	** tuiShowDisassemAndUpdateSource().
	164	** Function to display the disassembly window.
	165	*/
c906108c	166	void
eca6576c	167	tuiShowDisassemAndUpdateSource (Opaque startAddr)
c906108c SS	168	{
	169	struct symtab_and_line sal;
	170
	171	tuiShowDisassem (startAddr);
	172	if (currentLayout () == SRC_DISASSEM_COMMAND)
	173	{
	174	TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
	175	/*
c5aa993b JM	176	** Update what is in the source window if it is displayed too,
	177	** note that it follows what is in the disassembly window and visa-versa
	178	*/
c906108c SS	179	sal = find_pc_line ((CORE_ADDR) startAddr, 0);
	180	current_source_symtab = sal.symtab;
	181	tuiUpdateSourceWindow (srcWin, sal.symtab, (Opaque) sal.line, TRUE);
	182	tuiUpdateLocatorFilename (sal.symtab->filename);
	183	}
	184
	185	return;
	186	} /* tuiShowDisassemAndUpdateSource */
	187
	188
	189	/*
c5aa993b JM	190	** tuiShowDisassemAsIs().
	191	** Function to display the disassembly window. This function shows
	192	** the disassembly as specified by the horizontal offset.
	193	*/
c906108c	194	void
eca6576c	195	tuiShowDisassemAsIs (Opaque addr)
c906108c SS	196	{
	197	tuiAddWinToLayout (DISASSEM_WIN);
	198	tuiUpdateSourceWindowAsIs (disassemWin, (struct symtab *) NULL, addr, FALSE);
	199	/*
c5aa993b JM	200	** Update what is in the source window if it is displayed too, not that it
	201	** follows what is in the disassembly window and visa-versa
	202	*/
c906108c SS	203	if (currentLayout () == SRC_DISASSEM_COMMAND)
	204	tuiShowSourceContent (srcWin); /???? Need to do more? /
	205
	206	return;
	207	} /* tuiShowDisassem */
	208
	209
	210	/*
c5aa993b JM	211	** tuiGetBeginAsmAddress().
c5aa993b JM	212	*/
c906108c	213	Opaque
c906108c	214	tuiGetBeginAsmAddress (void)
c906108c SS	215	{
	216	TuiGenWinInfoPtr locator;
	217	TuiLocatorElementPtr element;
	218	Opaque addr;
	219
	220	locator = locatorWinInfoPtr ();
	221	element = &((TuiWinElementPtr) locator->content[0])->whichElement.locator;
	222
	223	if (element->addr == (Opaque) 0)
	224	{
c5aa993b	225	/the target is not executing, because the pc is 0 /
c906108c SS	226
	227	addr = (Opaque) parse_and_eval_address ("main");
	228
	229	if (addr == (Opaque) 0)
	230	addr = (Opaque) parse_and_eval_address ("MAIN");
	231
	232	}
	233	else /* the target is executing */
	234	addr = element->addr;
	235
	236	return addr;
	237	} /* tuiGetBeginAsmAddress */
	238
	239
	240	/*
c5aa993b JM	241	** tuiVerticalDisassemScroll().
	242	** Scroll the disassembly forward or backward vertically
	243	*/
c906108c	244	void
eca6576c SC	245	tuiVerticalDisassemScroll (TuiScrollDirection scrollDirection,
eca6576c SC	246	int numToScroll)
c906108c SS	247	{
	248	if (disassemWin->generic.content != (OpaquePtr) NULL)
	249	{
	250	Opaque pc, lowAddr;
	251	TuiWinContent content;
	252	struct symtab *s;
	253
	254	content = (TuiWinContent) disassemWin->generic.content;
	255	if (current_source_symtab == (struct symtab *) NULL)
	256	s = find_pc_symtab (selected_frame->pc);
	257	else
	258	s = current_source_symtab;
	259
	260	pc = content[0]->whichElement.source.lineOrAddr.addr;
	261	if (find_pc_partial_function ((CORE_ADDR) pc,
	262	(char **) NULL,
	263	(CORE_ADDR *) & lowAddr,
	264	(CORE_ADDR) NULL) == 0)
	265	error ("No function contains prgram counter for selected frame.\n");
	266	else
	267	{
	268	register int line = 0;
	269	register Opaque newLow;
	270	bfd_byte buffer[4];
	271
	272	newLow = pc;
	273	if (scrollDirection == FORWARD_SCROLL)
	274	{
	275	for (; line < numToScroll; line++)
	276	newLow += sizeof (bfd_getb32 (buffer));
	277	}
	278	else
	279	{
	280	for (; newLow >= (Opaque) 0 && line < numToScroll; line++)
	281	newLow -= sizeof (bfd_getb32 (buffer));
	282	}
	283	tuiUpdateSourceWindowAsIs (disassemWin, s, newLow, FALSE);
	284	}
	285	}
	286
	287	return;
	288	} /* tuiVerticalDisassemScroll */
	289
	290
	291
	292	/*****************************************
	293	STATIC LOCAL FUNCTIONS
	294	******************************************/
	295	/*
c5aa993b JM	296	** _hasBreak().
	297	** Answer whether there is a break point at the input line in the
	298	** source file indicated
	299	*/
c906108c	300	static struct breakpoint *
eca6576c	301	_hasBreak (CORE_ADDR addr)
c906108c SS	302	{
	303	struct breakpoint bpWithBreak = (struct breakpoint ) NULL;
	304	struct breakpoint *bp;
	305	extern struct breakpoint *breakpoint_chain;
	306
	307
	308	for (bp = breakpoint_chain;
	309	(bp != (struct breakpoint *) NULL &&
	310	bpWithBreak == (struct breakpoint *) NULL);
	311	bp = bp->next)
	312	if (addr == bp->address)
	313	bpWithBreak = bp;
	314
	315	return bpWithBreak;
	316	} /* _hasBreak */