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