292 lines
6.6 KiB
C
292 lines
6.6 KiB
C
|
/* GOULD RISC target-dependent code for GDB, the GNU debugger.
|
|||
|
|
Copyright 1986, 1987, 1989, 1991 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 "symtab.h"
|
|||
|
|
#include "frame.h"
|
|||
|
|
#include "gdbcore.h"
|
|||
|
|
#if defined GOULD_PN
|
|||
|
|
#include "opcode/pn.h"
|
|||
|
|
#else
|
|||
|
|
#include "opcode/np1.h"
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
/* GOULD RISC instructions are never longer than this many bytes. */
|
|||
|
|
#define MAXLEN 4
|
|||
|
|
|
|||
|
|
/* Number of elements in the opcode table. */
|
|||
|
|
#define NOPCODES (sizeof gld_opcodes / sizeof gld_opcodes[0])
|
|||
|
|
|
|||
|
|
|
|||
|
|
/* Print the GOULD instruction at address MEMADDR in debugged memory,
|
|||
|
|
on STREAM. Returns length of the instruction, in bytes. */
|
|||
|
|
|
|||
|
|
int
|
|||
|
|
gould_print_insn (memaddr, stream)
|
|||
|
|
CORE_ADDR memaddr;
|
|||
|
|
FILE *stream;
|
|||
|
|
{
|
|||
|
|
unsigned char buffer[MAXLEN];
|
|||
|
|
register int i;
|
|||
|
|
register char *d;
|
|||
|
|
register int bestmask;
|
|||
|
|
unsigned best;
|
|||
|
|
int temp, index, bestlen;
|
|||
|
|
|
|||
|
|
read_memory (memaddr, buffer, MAXLEN);
|
|||
|
|
|
|||
|
|
bestmask = 0;
|
|||
|
|
index = -1;
|
|||
|
|
best = 0xffffffff;
|
|||
|
|
for (i = 0; i < NOPCODES; i++)
|
|||
|
|
{
|
|||
|
|
register unsigned int opcode = gld_opcodes[i].opcode;
|
|||
|
|
register unsigned int mask = gld_opcodes[i].mask;
|
|||
|
|
register unsigned int len = gld_opcodes[i].length;
|
|||
|
|
register unsigned int test;
|
|||
|
|
|
|||
|
|
/* Get possible opcode bytes into integer */
|
|||
|
|
test = buffer[0] << 24;
|
|||
|
|
test |= buffer[1] << 16;
|
|||
|
|
test |= buffer[2] << 8;
|
|||
|
|
test |= buffer[3];
|
|||
|
|
|
|||
|
|
/* Mask with opcode and see if match */
|
|||
|
|
if ((opcode & mask) == (test & mask))
|
|||
|
|
{
|
|||
|
|
/* See if second or third match */
|
|||
|
|
if (index >= 0)
|
|||
|
|
{
|
|||
|
|
/* Take new one if it looks good */
|
|||
|
|
if (bestlen == MAXLEN && len == MAXLEN)
|
|||
|
|
{
|
|||
|
|
/* See if lower bits matched */
|
|||
|
|
if (((bestmask & 3) == 0) &&
|
|||
|
|
((mask & 3) != 0))
|
|||
|
|
{
|
|||
|
|
bestmask = mask;
|
|||
|
|
bestlen = len;
|
|||
|
|
best = test;
|
|||
|
|
index = i;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
/* First match, save it */
|
|||
|
|
bestmask = mask;
|
|||
|
|
bestlen = len;
|
|||
|
|
best = test;
|
|||
|
|
index = i;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/* Handle undefined instructions. */
|
|||
|
|
if (index < 0)
|
|||
|
|
{
|
|||
|
|
fprintf (stream, "undefined 0%o",(buffer[0]<<8)+buffer[1]);
|
|||
|
|
return 2;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/* Print instruction name */
|
|||
|
|
fprintf (stream, "%-12s", gld_opcodes[index].name);
|
|||
|
|
|
|||
|
|
/* Adjust if short instruction */
|
|||
|
|
if (gld_opcodes[index].length < 4)
|
|||
|
|
{
|
|||
|
|
best >>= 16;
|
|||
|
|
i = 0;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
i = 16;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/* Dump out instruction arguments */
|
|||
|
|
for (d = gld_opcodes[index].args; *d; ++d)
|
|||
|
|
{
|
|||
|
|
switch (*d)
|
|||
|
|
{
|
|||
|
|
case 'f':
|
|||
|
|
fprintf (stream, "%d", (best >> (7 + i)) & 7);
|
|||
|
|
break;
|
|||
|
|
case 'r':
|
|||
|
|
fprintf (stream, "r%d", (best >> (7 + i)) & 7);
|
|||
|
|
break;
|
|||
|
|
case 'R':
|
|||
|
|
fprintf (stream, "r%d", (best >> (4 + i)) & 7);
|
|||
|
|
break;
|
|||
|
|
case 'b':
|
|||
|
|
fprintf (stream, "b%d", (best >> (7 + i)) & 7);
|
|||
|
|
break;
|
|||
|
|
case 'B':
|
|||
|
|
fprintf (stream, "b%d", (best >> (4 + i)) & 7);
|
|||
|
|
break;
|
|||
|
|
case 'v':
|
|||
|
|
fprintf (stream, "b%d", (best >> (7 + i)) & 7);
|
|||
|
|
break;
|
|||
|
|
case 'V':
|
|||
|
|
fprintf (stream, "b%d", (best >> (4 + i)) & 7);
|
|||
|
|
break;
|
|||
|
|
case 'X':
|
|||
|
|
temp = (best >> 20) & 7;
|
|||
|
|
if (temp)
|
|||
|
|
fprintf (stream, "r%d", temp);
|
|||
|
|
else
|
|||
|
|
putc ('0', stream);
|
|||
|
|
break;
|
|||
|
|
case 'A':
|
|||
|
|
temp = (best >> 16) & 7;
|
|||
|
|
if (temp)
|
|||
|
|
fprintf (stream, "(b%d)", temp);
|
|||
|
|
break;
|
|||
|
|
case 'S':
|
|||
|
|
fprintf (stream, "#%d", best & 0x1f);
|
|||
|
|
break;
|
|||
|
|
case 'I':
|
|||
|
|
fprintf (stream, "#%x", best & 0xffff);
|
|||
|
|
break;
|
|||
|
|
case 'O':
|
|||
|
|
fprintf (stream, "%x", best & 0xffff);
|
|||
|
|
break;
|
|||
|
|
case 'h':
|
|||
|
|
fprintf (stream, "%d", best & 0xfffe);
|
|||
|
|
break;
|
|||
|
|
case 'd':
|
|||
|
|
fprintf (stream, "%d", best & 0xfffc);
|
|||
|
|
break;
|
|||
|
|
case 'T':
|
|||
|
|
fprintf (stream, "%d", (best >> 8) & 0xff);
|
|||
|
|
break;
|
|||
|
|
case 'N':
|
|||
|
|
fprintf (stream, "%d", best & 0xff);
|
|||
|
|
break;
|
|||
|
|
default:
|
|||
|
|
putc (*d, stream);
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/* Return length of instruction */
|
|||
|
|
return (gld_opcodes[index].length);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* Find the number of arguments to a function.
|
|||
|
|
*/
|
|||
|
|
findarg(frame)
|
|||
|
|
struct frame_info *frame;
|
|||
|
|
{
|
|||
|
|
register struct symbol *func;
|
|||
|
|
register unsigned pc;
|
|||
|
|
|
|||
|
|
#ifdef notdef
|
|||
|
|
/* find starting address of frame function */
|
|||
|
|
pc = get_pc_function_start (frame->pc);
|
|||
|
|
|
|||
|
|
/* find function symbol info */
|
|||
|
|
func = find_pc_function (pc);
|
|||
|
|
|
|||
|
|
/* call blockframe code to look for match */
|
|||
|
|
if (func != NULL)
|
|||
|
|
return (func->value.block->nsyms / sizeof(int));
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
return (-1);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* In the case of the NPL, the frame's norminal address is Br2 and the
|
|||
|
|
* previous routines frame is up the stack X bytes. Finding out what
|
|||
|
|
* 'X' is can be tricky.
|
|||
|
|
*
|
|||
|
|
* 1.) stored in the code function header xA(Br1).
|
|||
|
|
* 2.) must be careful of recurssion.
|
|||
|
|
*/
|
|||
|
|
CORE_ADDR
|
|||
|
|
findframe(thisframe)
|
|||
|
|
struct frame_info *thisframe;
|
|||
|
|
{
|
|||
|
|
register CORE_ADDR pointer;
|
|||
|
|
CORE_ADDR framechain();
|
|||
|
|
#if 0
|
|||
|
|
struct frame_info *frame;
|
|||
|
|
|
|||
|
|
/* Setup toplevel frame structure */
|
|||
|
|
frame->pc = read_pc();
|
|||
|
|
frame->next_frame = 0;
|
|||
|
|
frame->frame = read_register (SP_REGNUM); /* Br2 */
|
|||
|
|
|
|||
|
|
/* Search for this frame (start at current Br2) */
|
|||
|
|
do
|
|||
|
|
{
|
|||
|
|
pointer = framechain(frame);
|
|||
|
|
frame->next_frame = frame->frame;
|
|||
|
|
frame->frame = pointer;
|
|||
|
|
frame->pc = FRAME_SAVED_PC(frame);
|
|||
|
|
}
|
|||
|
|
while (frame->next_frame != thisframe);
|
|||
|
|
#endif
|
|||
|
|
|
|||
|
|
pointer = framechain (thisframe);
|
|||
|
|
|
|||
|
|
/* stop gap for now, end at __base3 */
|
|||
|
|
if (thisframe->pc == 0)
|
|||
|
|
return 0;
|
|||
|
|
|
|||
|
|
return pointer;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/*
|
|||
|
|
* Gdb front-end and internal framechain routine.
|
|||
|
|
* Go back up stack one level. Tricky...
|
|||
|
|
*/
|
|||
|
|
CORE_ADDR
|
|||
|
|
framechain(frame)
|
|||
|
|
register struct frame_info *frame;
|
|||
|
|
{
|
|||
|
|
register CORE_ADDR func, prevsp;
|
|||
|
|
register unsigned value;
|
|||
|
|
|
|||
|
|
/* Get real function start address from internal frame address */
|
|||
|
|
func = get_pc_function_start(frame->pc);
|
|||
|
|
|
|||
|
|
/* If no stack given, read register Br1 "(sp)" */
|
|||
|
|
if (!frame->frame)
|
|||
|
|
prevsp = read_register (SP_REGNUM);
|
|||
|
|
else
|
|||
|
|
prevsp = frame->frame;
|
|||
|
|
|
|||
|
|
/* Check function header, case #2 */
|
|||
|
|
value = read_memory_integer (func, 4);
|
|||
|
|
if (value)
|
|||
|
|
{
|
|||
|
|
/* 32bit call push value stored in function header */
|
|||
|
|
prevsp += value;
|
|||
|
|
}
|
|||
|
|
else
|
|||
|
|
{
|
|||
|
|
/* read half-word from suabr at start of function */
|
|||
|
|
prevsp += read_memory_integer (func + 10, 2);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
return (prevsp);
|
|||
|
|
}
|