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

/* Disassembly display.

   Copyright 1998, 1999, 2000, 2001, 2002, 2003 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 "value.h"
#include "source.h"
#include "disasm.h"

#include "tui.h"
#include "tuiData.h"
#include "tuiWin.h"
#include "tuiLayout.h"
#include "tuiSourceWin.h"
#include "tuiStack.h"
#include "tui-file.h"

#ifdef HAVE_NCURSES_H       
#include <ncurses.h>
#else
#ifdef HAVE_CURSES_H
#include <curses.h>
#endif
#endif

struct tui_asm_line 
{
  CORE_ADDR addr;
  char* addr_string;
  char* insn;
};

/* Function to set the disassembly window's content.
   Disassemble count lines starting at pc.
   Return address of the count'th instruction after pc.  */
static CORE_ADDR
tui_disassemble (struct tui_asm_line* lines, CORE_ADDR pc, int count)
{
  struct ui_file *gdb_dis_out;

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

  /* Now construct each line */
  for (; count > 0; count--, lines++)
    {
      if (lines->addr_string)
        xfree (lines->addr_string);
      if (lines->insn)
        xfree (lines->insn);
      
      print_address (pc, gdb_dis_out);
      lines->addr = pc;
      lines->addr_string = xstrdup (tui_file_get_strbuf (gdb_dis_out));

      ui_file_rewind (gdb_dis_out);

      pc = pc + gdb_print_insn (pc, gdb_dis_out);

      lines->insn = xstrdup (tui_file_get_strbuf (gdb_dis_out));

      /* reset the buffer to empty */
      ui_file_rewind (gdb_dis_out);
    }
  ui_file_delete (gdb_dis_out);
  return pc;
}

/* Find the disassembly address that corresponds to FROM lines
   above or below the PC.  Variable sized instructions are taken
   into account by the algorithm.  */
static CORE_ADDR
tui_find_disassembly_address (CORE_ADDR pc, int from)
{
  register CORE_ADDR newLow;
  int maxLines;
  int i;
  struct tui_asm_line* lines;

  maxLines = (from > 0) ? from : - from;
  if (maxLines <= 1)
     return pc;

  lines = (struct tui_asm_line*) alloca (sizeof (struct tui_asm_line)
                                         * maxLines);
  memset (lines, 0, sizeof (struct tui_asm_line) * maxLines);

  newLow = pc;
  if (from > 0)
    {
      tui_disassemble (lines, pc, maxLines);
      newLow = lines[maxLines - 1].addr;
    }
  else
    {
      CORE_ADDR last_addr;
      int pos;
      struct minimal_symbol* msymbol;
              
      /* Find backward an address which is a symbol
         and for which disassembling from that address will fill
         completely the window.  */
      pos = maxLines - 1;
      do {
         newLow -= 1 * maxLines;
         msymbol = lookup_minimal_symbol_by_pc_section (newLow, 0);

         if (msymbol)
            newLow = SYMBOL_VALUE_ADDRESS (msymbol);
         else
            newLow += 1 * maxLines;

         tui_disassemble (lines, newLow, maxLines);
         last_addr = lines[pos].addr;
      } while (last_addr > pc && msymbol);

      /* Scan forward disassembling one instruction at a time
         until the last visible instruction of the window
         matches the pc.  We keep the disassembled instructions
         in the 'lines' window and shift it downward (increasing
         its addresses).  */
      if (last_addr < pc)
        do
          {
            CORE_ADDR next_addr;
                 
            pos++;
            if (pos >= maxLines)
              pos = 0;

            next_addr = tui_disassemble (&lines[pos], last_addr, 1);

            /* If there are some problems while disassembling exit.  */
            if (next_addr <= last_addr)
              break;
            last_addr = next_addr;
          } while (last_addr <= pc);
      pos++;
      if (pos >= maxLines)
         pos = 0;
      newLow = lines[pos].addr;
    }
  for (i = 0; i < maxLines; i++)
    {
      xfree (lines[i].addr_string);
      xfree (lines[i].insn);
    }
  return newLow;
}

/* Function to set the disassembly window's content.  */
TuiStatus
tuiSetDisassemContent (CORE_ADDR pc)
{
  TuiStatus ret = TUI_FAILURE;
  register int i;
  register int offset = disassemWin->detail.sourceInfo.horizontalOffset;
  register int lineWidth, maxLines;
  CORE_ADDR cur_pc;
  TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
  int tab_len = tuiDefaultTabLen ();
  struct tui_asm_line* lines;
  int insn_pos;
  int addr_size, max_size;
  char* line;
  
  if (pc == 0)
    return TUI_FAILURE;

  ret = tuiAllocSourceBuffer (disassemWin);
  if (ret != TUI_SUCCESS)
    return ret;

  disassemWin->detail.sourceInfo.startLineOrAddr.addr = pc;
  cur_pc = (CORE_ADDR)
    (((TuiWinElementPtr) locator->content[0])->whichElement.locator.addr);

  maxLines = disassemWin->generic.height - 2;	/* account for hilite */

  /* Get temporary table that will hold all strings (addr & insn).  */
  lines = (struct tui_asm_line*) alloca (sizeof (struct tui_asm_line)
                                         * maxLines);
  memset (lines, 0, sizeof (struct tui_asm_line) * maxLines);

  lineWidth = disassemWin->generic.width - 1;

  tui_disassemble (lines, pc, maxLines);

  /* See what is the maximum length of an address and of a line.  */
  addr_size = 0;
  max_size = 0;
  for (i = 0; i < maxLines; i++)
    {
      size_t len = strlen (lines[i].addr_string);
      if (len > addr_size)
        addr_size = len;

      len = strlen (lines[i].insn) + tab_len;
      if (len > max_size)
        max_size = len;
    }
  max_size += addr_size + tab_len;

  /* Allocate memory to create each line.  */
  line = (char*) alloca (max_size);
  insn_pos = (1 + (addr_size / tab_len)) * tab_len;

  /* Now construct each line */
  for (i = 0; i < maxLines; i++)
    {
      TuiWinElementPtr element;
      TuiSourceElement* src;
      int curLen;

      element = (TuiWinElementPtr) disassemWin->generic.content[i];
      src = &element->whichElement.source;
      strcpy (line, lines[i].addr_string);
      curLen = strlen (line);

      /* Add spaces to make the instructions start on the same column */
      while (curLen < insn_pos)
        {
          strcat (line, " ");
          curLen++;
        }

      strcat (line, lines[i].insn);

      /* Now copy the line taking the offset into account */
      if (strlen (line) > offset)
        strcpy (src->line, &line[offset]);
      else
        src->line[0] = '\0';

      src->lineOrAddr.addr = lines[i].addr;
      src->isExecPoint = lines[i].addr == cur_pc;

      /* See whether there is a breakpoint installed.  */
      src->hasBreak = (!src->isExecPoint
                       && breakpoint_here_p (pc) != no_breakpoint_here);

      xfree (lines[i].addr_string);
      xfree (lines[i].insn);
    }
  disassemWin->generic.contentSize = i;
  return TUI_SUCCESS;
}


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

  val.addr = startAddr;
  tuiAddWinToLayout (DISASSEM_WIN);
  tuiUpdateSourceWindow (disassemWin, s, val, 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 (CORE_ADDR startAddr)
{
  struct symtab_and_line sal;

  tuiShowDisassem (startAddr);
  if (currentLayout () == SRC_DISASSEM_COMMAND)
    {
      TuiLineOrAddress val;

      /*
         ** 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 (startAddr, 0);
      val.lineNo = sal.line;
      tuiUpdateSourceWindow (srcWin, sal.symtab, val, TRUE);
      if (sal.symtab)
	{
	  set_current_source_symtab_and_line (&sal);
	  tuiUpdateLocatorFilename (sal.symtab->filename);
	}
      else
	tuiUpdateLocatorFilename ("?");
    }

  return;
}				/* tuiShowDisassemAndUpdateSource */

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

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

  if (element->addr == 0)
    {
      struct minimal_symbol *main_symbol;

      /* Find address of the start of program.
         Note: this should be language specific.  */
      main_symbol = lookup_minimal_symbol ("main", NULL, NULL);
      if (main_symbol == 0)
        main_symbol = lookup_minimal_symbol ("MAIN", NULL, NULL);
      if (main_symbol == 0)
        main_symbol = lookup_minimal_symbol ("_start", NULL, NULL);
      if (main_symbol)
        addr = SYMBOL_VALUE_ADDRESS (main_symbol);
      else
        addr = 0;
    }
  else				/* the target is executing */
    addr = element->addr;

  return addr;
}				/* tuiGetBeginAsmAddress */

/* Determine what the low address will be to display in the TUI's
   disassembly window.  This may or may not be the same as the
   low address input.  */
CORE_ADDR
tuiGetLowDisassemblyAddress (CORE_ADDR low, CORE_ADDR pc)
{
  int pos;

  /* Determine where to start the disassembly so that the pc is about in the
     middle of the viewport.  */
  pos = tuiDefaultWinViewportHeight (DISASSEM_WIN, DISASSEM_COMMAND) / 2;
  pc = tui_find_disassembly_address (pc, -pos);

  if (pc < low)
    pc = low;
  return pc;
}

/*
   ** tuiVerticalDisassemScroll().
   **      Scroll the disassembly forward or backward vertically
 */
void
tuiVerticalDisassemScroll (TuiScrollDirection scrollDirection,
                           int numToScroll)
{
  if (disassemWin->generic.content != (OpaquePtr) NULL)
    {
      CORE_ADDR pc;
      TuiWinContent content;
      struct symtab *s;
      TuiLineOrAddress val;
      int maxLines, dir;
      struct symtab_and_line cursal = get_current_source_symtab_and_line ();

      content = (TuiWinContent) disassemWin->generic.content;
      if (cursal.symtab == (struct symtab *) NULL)
	s = find_pc_symtab (get_frame_pc (deprecated_selected_frame));
      else
	s = cursal.symtab;

      /* account for hilite */
      maxLines = disassemWin->generic.height - 2;
      pc = content[0]->whichElement.source.lineOrAddr.addr;
      dir = (scrollDirection == FORWARD_SCROLL) ? maxLines : - maxLines;

      val.addr = tui_find_disassembly_address (pc, dir);
      tuiUpdateSourceWindowAsIs (disassemWin, s, val, FALSE);
    }
}
Commit	Line	Data
f377b406	1	/* Disassembly display.
f33c6cbf	2
96ec9981	3	Copyright 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation,
f33c6cbf AC	4	Inc.
f33c6cbf AC	5
f377b406 SC	6	Contributed by Hewlett-Packard Company.
	7
	8	This file is part of GDB.
	9
	10	This program is free software; you can redistribute it and/or modify
	11	it under the terms of the GNU General Public License as published by
	12	the Free Software Foundation; either version 2 of the License, or
	13	(at your option) any later version.
	14
	15	This program is distributed in the hope that it will be useful,
	16	but WITHOUT ANY WARRANTY; without even the implied warranty of
	17	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	18	GNU General Public License for more details.
	19
	20	You should have received a copy of the GNU General Public License
	21	along with this program; if not, write to the Free Software
	22	Foundation, Inc., 59 Temple Place - Suite 330,
	23	Boston, MA 02111-1307, USA. */
c906108c SS	24
	25	#include "defs.h"
	26	#include "symtab.h"
	27	#include "breakpoint.h"
	28	#include "frame.h"
fd0407d6	29	#include "value.h"
52575520	30	#include "source.h"
f70a7d61	31	#include "disasm.h"
c906108c SS	32
	33	#include "tui.h"
	34	#include "tuiData.h"
a8080b7f	35	#include "tuiWin.h"
c906108c SS	36	#include "tuiLayout.h"
	37	#include "tuiSourceWin.h"
	38	#include "tuiStack.h"
a8080b7f	39	#include "tui-file.h"
c906108c	40
96ec9981 DJ	41	#ifdef HAVE_NCURSES_H
	42	#include <ncurses.h>
	43	#else
	44	#ifdef HAVE_CURSES_H
	45	#include <curses.h>
	46	#endif
	47	#endif
	48
aec2f747 SC	49	struct tui_asm_line
	50	{
	51	CORE_ADDR addr;
	52	char* addr_string;
	53	char* insn;
	54	};
	55
	56	/* Function to set the disassembly window's content.
	57	Disassemble count lines starting at pc.
	58	Return address of the count'th instruction after pc. */
	59	static CORE_ADDR
	60	tui_disassemble (struct tui_asm_line* lines, CORE_ADDR pc, int count)
	61	{
	62	struct ui_file *gdb_dis_out;
c906108c	63
aec2f747 SC	64	/* now init the ui_file structure */
	65	gdb_dis_out = tui_sfileopen (256);
	66
aec2f747 SC	67	/* Now construct each line */
	68	for (; count > 0; count--, lines++)
	69	{
	70	if (lines->addr_string)
	71	xfree (lines->addr_string);
	72	if (lines->insn)
	73	xfree (lines->insn);
	74
	75	print_address (pc, gdb_dis_out);
	76	lines->addr = pc;
	77	lines->addr_string = xstrdup (tui_file_get_strbuf (gdb_dis_out));
	78
	79	ui_file_rewind (gdb_dis_out);
	80
92bf2b80	81	pc = pc + gdb_print_insn (pc, gdb_dis_out);
aec2f747 SC	82
	83	lines->insn = xstrdup (tui_file_get_strbuf (gdb_dis_out));
	84
	85	/* reset the buffer to empty */
	86	ui_file_rewind (gdb_dis_out);
	87	}
	88	ui_file_delete (gdb_dis_out);
	89	return pc;
	90	}
	91
	92	/* Find the disassembly address that corresponds to FROM lines
	93	above or below the PC. Variable sized instructions are taken
	94	into account by the algorithm. */
	95	static CORE_ADDR
	96	tui_find_disassembly_address (CORE_ADDR pc, int from)
	97	{
	98	register CORE_ADDR newLow;
	99	int maxLines;
	100	int i;
	101	struct tui_asm_line* lines;
	102
	103	maxLines = (from > 0) ? from : - from;
	104	if (maxLines <= 1)
	105	return pc;
	106
	107	lines = (struct tui_asm_line*) alloca (sizeof (struct tui_asm_line)
	108	* maxLines);
	109	memset (lines, 0, sizeof (struct tui_asm_line) * maxLines);
	110
	111	newLow = pc;
	112	if (from > 0)
	113	{
	114	tui_disassemble (lines, pc, maxLines);
	115	newLow = lines[maxLines - 1].addr;
	116	}
	117	else
	118	{
	119	CORE_ADDR last_addr;
	120	int pos;
	121	struct minimal_symbol* msymbol;
	122
	123	/* Find backward an address which is a symbol
	124	and for which disassembling from that address will fill
	125	completely the window. */
	126	pos = maxLines - 1;
	127	do {
	128	newLow -= 1 * maxLines;
	129	msymbol = lookup_minimal_symbol_by_pc_section (newLow, 0);
	130
	131	if (msymbol)
	132	newLow = SYMBOL_VALUE_ADDRESS (msymbol);
	133	else
	134	newLow += 1 * maxLines;
	135
	136	tui_disassemble (lines, newLow, maxLines);
	137	last_addr = lines[pos].addr;
	138	} while (last_addr > pc && msymbol);
	139
	140	/* Scan forward disassembling one instruction at a time
	141	until the last visible instruction of the window
	142	matches the pc. We keep the disassembled instructions
	143	in the 'lines' window and shift it downward (increasing
	144	its addresses). */
	145	if (last_addr < pc)
146	do
147	{
148	CORE_ADDR next_addr;
149
150	pos++;
151	if (pos >= maxLines)
152	pos = 0;
153
154	next_addr = tui_disassemble (&lines[pos], last_addr, 1);
155
156	/* If there are some problems while disassembling exit. */
157	if (next_addr <= last_addr)
158	break;
159	last_addr = next_addr;
160	} while (last_addr <= pc);
161	pos++;
162	if (pos >= maxLines)
163	pos = 0;
164	newLow = lines[pos].addr;
165	}
166	for (i = 0; i < maxLines; i++)
167	{
168	xfree (lines[i].addr_string);
169	xfree (lines[i].insn);
170	}
171	return newLow;
172	}
173
174	/* Function to set the disassembly window's content. */
c906108c	175	TuiStatus
aec2f747	176	tuiSetDisassemContent (CORE_ADDR pc)
c906108c SS	177	{
c906108c SS	178	TuiStatus ret = TUI_FAILURE;
aec2f747 SC	179	register int i;
	180	register int offset = disassemWin->detail.sourceInfo.horizontalOffset;
	181	register int lineWidth, maxLines;
	182	CORE_ADDR cur_pc;
	183	TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
	184	int tab_len = tuiDefaultTabLen ();
	185	struct tui_asm_line* lines;
	186	int insn_pos;
	187	int addr_size, max_size;
	188	char* line;
	189
	190	if (pc == 0)
	191	return TUI_FAILURE;
	192
	193	ret = tuiAllocSourceBuffer (disassemWin);
	194	if (ret != TUI_SUCCESS)
	195	return ret;
	196
	197	disassemWin->detail.sourceInfo.startLineOrAddr.addr = pc;
	198	cur_pc = (CORE_ADDR)
	199	(((TuiWinElementPtr) locator->content[0])->whichElement.locator.addr);
	200
	201	maxLines = disassemWin->generic.height - 2; /* account for hilite */
	202
	203	/* Get temporary table that will hold all strings (addr & insn). */
	204	lines = (struct tui_asm_line*) alloca (sizeof (struct tui_asm_line)
	205	* maxLines);
	206	memset (lines, 0, sizeof (struct tui_asm_line) * maxLines);
	207
	208	lineWidth = disassemWin->generic.width - 1;
	209
	210	tui_disassemble (lines, pc, maxLines);
	211
	212	/* See what is the maximum length of an address and of a line. */
	213	addr_size = 0;
	214	max_size = 0;
	215	for (i = 0; i < maxLines; i++)
c906108c	216	{
aec2f747 SC	217	size_t len = strlen (lines[i].addr_string);
	218	if (len > addr_size)
	219	addr_size = len;
c906108c	220
aec2f747 SC	221	len = strlen (lines[i].insn) + tab_len;
	222	if (len > max_size)
	223	max_size = len;
c906108c	224	}
aec2f747 SC	225	max_size += addr_size + tab_len;
	226
	227	/* Allocate memory to create each line. */
	228	line = (char*) alloca (max_size);
	229	insn_pos = (1 + (addr_size / tab_len)) * tab_len;
	230
	231	/* Now construct each line */
	232	for (i = 0; i < maxLines; i++)
	233	{
	234	TuiWinElementPtr element;
	235	TuiSourceElement* src;
	236	int curLen;
	237
	238	element = (TuiWinElementPtr) disassemWin->generic.content[i];
	239	src = &element->whichElement.source;
	240	strcpy (line, lines[i].addr_string);
	241	curLen = strlen (line);
	242
	243	/* Add spaces to make the instructions start on the same column */
	244	while (curLen < insn_pos)
	245	{
	246	strcat (line, " ");
	247	curLen++;
	248	}
	249
	250	strcat (line, lines[i].insn);
	251
	252	/* Now copy the line taking the offset into account */
	253	if (strlen (line) > offset)
	254	strcpy (src->line, &line[offset]);
	255	else
	256	src->line[0] = '\0';
	257
	258	src->lineOrAddr.addr = lines[i].addr;
	259	src->isExecPoint = lines[i].addr == cur_pc;
	260
	261	/* See whether there is a breakpoint installed. */
	262	src->hasBreak = (!src->isExecPoint
	263	&& breakpoint_here_p (pc) != no_breakpoint_here);
c906108c	264
aec2f747 SC	265	xfree (lines[i].addr_string);
	266	xfree (lines[i].insn);
	267	}
	268	disassemWin->generic.contentSize = i;
	269	return TUI_SUCCESS;
	270	}
c906108c SS	271
	272
	273	/*
c5aa993b JM	274	** tuiShowDisassem().
	275	** Function to display the disassembly window with disassembled code.
	276	*/
c906108c	277	void
c774cec6	278	tuiShowDisassem (CORE_ADDR startAddr)
c906108c	279	{
c774cec6	280	struct symtab *s = find_pc_symtab (startAddr);
c906108c	281	TuiWinInfoPtr winWithFocus = tuiWinWithFocus ();
a4b99e53	282	TuiLineOrAddress val;
c906108c	283
a4b99e53	284	val.addr = startAddr;
c906108c	285	tuiAddWinToLayout (DISASSEM_WIN);
a4b99e53	286	tuiUpdateSourceWindow (disassemWin, s, val, FALSE);
c906108c	287	/*
c5aa993b JM	288	** if the focus was in the src win, put it in the asm win, if the
	289	** source view isn't split
	290	*/
c906108c SS	291	if (currentLayout () != SRC_DISASSEM_COMMAND && winWithFocus == srcWin)
	292	tuiSetWinFocusTo (disassemWin);
	293
	294	return;
	295	} /* tuiShowDisassem */
	296
	297
	298	/*
c5aa993b JM	299	** tuiShowDisassemAndUpdateSource().
	300	** Function to display the disassembly window.
	301	*/
c906108c	302	void
c774cec6	303	tuiShowDisassemAndUpdateSource (CORE_ADDR startAddr)
c906108c SS	304	{
	305	struct symtab_and_line sal;
	306
	307	tuiShowDisassem (startAddr);
	308	if (currentLayout () == SRC_DISASSEM_COMMAND)
	309	{
a4b99e53	310	TuiLineOrAddress val;
aec2f747	311
c906108c	312	/*
c5aa993b JM	313	** Update what is in the source window if it is displayed too,
	314	** note that it follows what is in the disassembly window and visa-versa
	315	*/
c774cec6	316	sal = find_pc_line (startAddr, 0);
a4b99e53 SC	317	val.lineNo = sal.line;
a4b99e53 SC	318	tuiUpdateSourceWindow (srcWin, sal.symtab, val, TRUE);
3024f13a SC	319	if (sal.symtab)
3024f13a SC	320	{
52575520	321	set_current_source_symtab_and_line (&sal);
3024f13a SC	322	tuiUpdateLocatorFilename (sal.symtab->filename);
	323	}
	324	else
	325	tuiUpdateLocatorFilename ("?");
c906108c SS	326	}
	327
	328	return;
	329	} /* tuiShowDisassemAndUpdateSource */
	330
c906108c	331	/*
c5aa993b JM	332	** tuiGetBeginAsmAddress().
c5aa993b JM	333	*/
c774cec6	334	CORE_ADDR
c906108c	335	tuiGetBeginAsmAddress (void)
c906108c SS	336	{
	337	TuiGenWinInfoPtr locator;
	338	TuiLocatorElementPtr element;
c774cec6	339	CORE_ADDR addr;
c906108c SS	340
	341	locator = locatorWinInfoPtr ();
	342	element = &((TuiWinElementPtr) locator->content[0])->whichElement.locator;
	343
c774cec6	344	if (element->addr == 0)
c906108c	345	{
0510ab86 SC	346	struct minimal_symbol *main_symbol;
	347
	348	/* Find address of the start of program.
	349	Note: this should be language specific. */
	350	main_symbol = lookup_minimal_symbol ("main", NULL, NULL);
	351	if (main_symbol == 0)
	352	main_symbol = lookup_minimal_symbol ("MAIN", NULL, NULL);
	353	if (main_symbol == 0)
	354	main_symbol = lookup_minimal_symbol ("_start", NULL, NULL);
	355	if (main_symbol)
	356	addr = SYMBOL_VALUE_ADDRESS (main_symbol);
	357	else
	358	addr = 0;
c906108c SS	359	}
	360	else /* the target is executing */
	361	addr = element->addr;
	362
	363	return addr;
aec2f747	364	} /* tuiGetBeginAsmAddress */
c906108c	365
77cad3ba SC	366	/* Determine what the low address will be to display in the TUI's
	367	disassembly window. This may or may not be the same as the
	368	low address input. */
	369	CORE_ADDR
	370	tuiGetLowDisassemblyAddress (CORE_ADDR low, CORE_ADDR pc)
	371	{
	372	int pos;
	373
	374	/* Determine where to start the disassembly so that the pc is about in the
	375	middle of the viewport. */
	376	pos = tuiDefaultWinViewportHeight (DISASSEM_WIN, DISASSEM_COMMAND) / 2;
	377	pc = tui_find_disassembly_address (pc, -pos);
	378
	379	if (pc < low)
	380	pc = low;
	381	return pc;
	382	}
	383
c906108c	384	/*
c5aa993b JM	385	** tuiVerticalDisassemScroll().
	386	** Scroll the disassembly forward or backward vertically
	387	*/
c906108c	388	void
eca6576c SC	389	tuiVerticalDisassemScroll (TuiScrollDirection scrollDirection,
eca6576c SC	390	int numToScroll)
c906108c SS	391	{
	392	if (disassemWin->generic.content != (OpaquePtr) NULL)
	393	{
aec2f747	394	CORE_ADDR pc;
c906108c SS	395	TuiWinContent content;
c906108c SS	396	struct symtab *s;
aec2f747 SC	397	TuiLineOrAddress val;
aec2f747 SC	398	int maxLines, dir;
52575520	399	struct symtab_and_line cursal = get_current_source_symtab_and_line ();
c906108c SS	400
c906108c SS	401	content = (TuiWinContent) disassemWin->generic.content;
52575520	402	if (cursal.symtab == (struct symtab *) NULL)
f70a7d61	403	s = find_pc_symtab (get_frame_pc (deprecated_selected_frame));
c906108c	404	else
52575520	405	s = cursal.symtab;
c906108c	406
aec2f747 SC	407	/* account for hilite */
aec2f747 SC	408	maxLines = disassemWin->generic.height - 2;
c906108c	409	pc = content[0]->whichElement.source.lineOrAddr.addr;
aec2f747	410	dir = (scrollDirection == FORWARD_SCROLL) ? maxLines : - maxLines;
c906108c	411
aec2f747 SC	412	val.addr = tui_find_disassembly_address (pc, dir);
	413	tuiUpdateSourceWindowAsIs (disassemWin, s, val, FALSE);
	414	}
	415	}