mirror of
https://github.com/darlinghq/darling-gdb.git
synced 2024-11-25 05:00:01 +00:00
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);
|
||
}
|