[deliverable/binutils-gdb.git] / gdb / gould-tdep.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])

/* Both gcc and cc return small structs in registers (i.e. in GDB
   terminology, small structs don't use the struct return convention).  */
int
gould_use_struct_convention (gcc_p, type)
     int gcc_p;
     struct type *type;
{
  return (TYPE_LENGTH(type) > 8);
}


\f
/* 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);
}
Commit	Line	Data
18b46e7c	1	/* GOULD RISC target-dependent code for GDB, the GNU debugger.
7d9884b9	2	Copyright 1986, 1987, 1989, 1991 Free Software Foundation, Inc.
dd3b648e RP	3
	4	This file is part of GDB.
	5
99a7de40	6	This program is free software; you can redistribute it and/or modify
dd3b648e	7	it under the terms of the GNU General Public License as published by
99a7de40 JG	8	the Free Software Foundation; either version 2 of the License, or
99a7de40 JG	9	(at your option) any later version.
dd3b648e	10
99a7de40	11	This program is distributed in the hope that it will be useful,
dd3b648e RP	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	GNU General Public License for more details.
	15
	16	You should have received a copy of the GNU General Public License
99a7de40	17	along with this program; if not, write to the Free Software
6c9638b4	18	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
dd3b648e	19
dd3b648e	20	#include "defs.h"
dd3b648e RP	21	#include "symtab.h"
dd3b648e RP	22	#include "frame.h"
7d9884b9	23	#include "gdbcore.h"
dd3b648e	24	#if defined GOULD_PN
aab77d5f	25	#include "opcode/pn.h"
dd3b648e	26	#else
aab77d5f	27	#include "opcode/np1.h"
dd3b648e RP	28	#endif
	29
	30	/* GOULD RISC instructions are never longer than this many bytes. */
	31	#define MAXLEN 4
	32
	33	/* Number of elements in the opcode table. */
	34	#define NOPCODES (sizeof gld_opcodes / sizeof gld_opcodes[0])
	35
98760eab AC	36	/* Both gcc and cc return small structs in registers (i.e. in GDB
	37	terminology, small structs don't use the struct return convention). */
	38	int
	39	gould_use_struct_convention (gcc_p, type)
	40	int gcc_p;
	41	struct type *type;
	42	{
	43	return (TYPE_LENGTH(type) > 8);
	44	}
	45
	46
dd3b648e RP	47	\f
	48	/* Print the GOULD instruction at address MEMADDR in debugged memory,
	49	on STREAM. Returns length of the instruction, in bytes. */
	50
	51	int
18b46e7c SS	52	gould_print_insn (memaddr, stream)
	53	CORE_ADDR memaddr;
	54	FILE *stream;
dd3b648e RP	55	{
	56	unsigned char buffer[MAXLEN];
	57	register int i;
	58	register char *d;
	59	register int bestmask;
	60	unsigned best;
	61	int temp, index, bestlen;
	62
	63	read_memory (memaddr, buffer, MAXLEN);
	64
	65	bestmask = 0;
	66	index = -1;
	67	best = 0xffffffff;
	68	for (i = 0; i < NOPCODES; i++)
	69	{
	70	register unsigned int opcode = gld_opcodes[i].opcode;
	71	register unsigned int mask = gld_opcodes[i].mask;
	72	register unsigned int len = gld_opcodes[i].length;
	73	register unsigned int test;
	74
	75	/* Get possible opcode bytes into integer */
	76	test = buffer[0] << 24;
	77	test \|= buffer[1] << 16;
	78	test \|= buffer[2] << 8;
	79	test \|= buffer[3];
	80
	81	/* Mask with opcode and see if match */
	82	if ((opcode & mask) == (test & mask))
	83	{
	84	/* See if second or third match */
	85	if (index >= 0)
	86	{
	87	/* Take new one if it looks good */
	88	if (bestlen == MAXLEN && len == MAXLEN)
	89	{
	90	/* See if lower bits matched */
	91	if (((bestmask & 3) == 0) &&
	92	((mask & 3) != 0))
	93	{
	94	bestmask = mask;
	95	bestlen = len;
	96	best = test;
	97	index = i;
	98	}
	99	}
	100	}
	101	else
	102	{
	103	/* First match, save it */
	104	bestmask = mask;
	105	bestlen = len;
	106	best = test;
	107	index = i;
	108	}
	109	}
	110	}
	111
	112	/* Handle undefined instructions. */
	113	if (index < 0)
	114	{
	115	fprintf (stream, "undefined 0%o",(buffer[0]<<8)+buffer[1]);
	116	return 2;
	117	}
	118
119	/* Print instruction name */
120	fprintf (stream, "%-12s", gld_opcodes[index].name);
121
122	/* Adjust if short instruction */
123	if (gld_opcodes[index].length < 4)
124	{
125	best >>= 16;
126	i = 0;
127	}
128	else
129	{
130	i = 16;
131	}
132
133	/* Dump out instruction arguments */
134	for (d = gld_opcodes[index].args; *d; ++d)
135	{
136	switch (*d)
137	{
138	case 'f':
139	fprintf (stream, "%d", (best >> (7 + i)) & 7);
140	break;
141	case 'r':
142	fprintf (stream, "r%d", (best >> (7 + i)) & 7);
143	break;
144	case 'R':
145	fprintf (stream, "r%d", (best >> (4 + i)) & 7);
146	break;
147	case 'b':
148	fprintf (stream, "b%d", (best >> (7 + i)) & 7);
149	break;
150	case 'B':
151	fprintf (stream, "b%d", (best >> (4 + i)) & 7);
152	break;
153	case 'v':
154	fprintf (stream, "b%d", (best >> (7 + i)) & 7);
155	break;
156	case 'V':
157	fprintf (stream, "b%d", (best >> (4 + i)) & 7);
158	break;
159	case 'X':
160	temp = (best >> 20) & 7;
161	if (temp)
162	fprintf (stream, "r%d", temp);
163	else
164	putc ('0', stream);
165	break;
166	case 'A':
167	temp = (best >> 16) & 7;
168	if (temp)
169	fprintf (stream, "(b%d)", temp);
170	break;
171	case 'S':
172	fprintf (stream, "#%d", best & 0x1f);
173	break;
174	case 'I':
175	fprintf (stream, "#%x", best & 0xffff);
176	break;
177	case 'O':
178	fprintf (stream, "%x", best & 0xffff);
179	break;
180	case 'h':
181	fprintf (stream, "%d", best & 0xfffe);
182	break;
183	case 'd':
184	fprintf (stream, "%d", best & 0xfffc);
185	break;
186	case 'T':
187	fprintf (stream, "%d", (best >> 8) & 0xff);
188	break;
189	case 'N':
190	fprintf (stream, "%d", best & 0xff);
191	break;
192	default:
193	putc (*d, stream);
194	break;
195	}
196	}
197
198	/* Return length of instruction */
199	return (gld_opcodes[index].length);
200	}
201
202	/*
203	* Find the number of arguments to a function.
204	*/
205	findarg(frame)
206	struct frame_info *frame;
207	{
208	register struct symbol *func;
209	register unsigned pc;
210
211	#ifdef notdef
212	/* find starting address of frame function */
213	pc = get_pc_function_start (frame->pc);
214
215	/* find function symbol info */
216	func = find_pc_function (pc);
217
218	/* call blockframe code to look for match */
219	if (func != NULL)
220	return (func->value.block->nsyms / sizeof(int));
221	#endif
222
223	return (-1);
224	}
225
226	/*
227	* In the case of the NPL, the frame's norminal address is Br2 and the
228	* previous routines frame is up the stack X bytes. Finding out what
229	* 'X' is can be tricky.
230	*
231	* 1.) stored in the code function header xA(Br1).
232	* 2.) must be careful of recurssion.
233	*/
1dfc8dfb	234	CORE_ADDR
dd3b648e	235	findframe(thisframe)
1dfc8dfb	236	struct frame_info *thisframe;
dd3b648e	237	{
1dfc8dfb SS	238	register CORE_ADDR pointer;
1dfc8dfb SS	239	CORE_ADDR framechain();
dd3b648e RP	240	#if 0
	241	struct frame_info *frame;
	242
	243	/* Setup toplevel frame structure */
	244	frame->pc = read_pc();
	245	frame->next_frame = 0;
	246	frame->frame = read_register (SP_REGNUM); /* Br2 */
	247
	248	/* Search for this frame (start at current Br2) */
	249	do
	250	{
	251	pointer = framechain(frame);
	252	frame->next_frame = frame->frame;
	253	frame->frame = pointer;
	254	frame->pc = FRAME_SAVED_PC(frame);
	255	}
	256	while (frame->next_frame != thisframe);
	257	#endif
	258
	259	pointer = framechain (thisframe);
	260
	261	/* stop gap for now, end at __base3 */
	262	if (thisframe->pc == 0)
	263	return 0;
	264
	265	return pointer;
	266	}
	267
	268	/*
	269	* Gdb front-end and internal framechain routine.
	270	* Go back up stack one level. Tricky...
	271	*/
1dfc8dfb	272	CORE_ADDR
dd3b648e RP	273	framechain(frame)
	274	register struct frame_info *frame;
	275	{
	276	register CORE_ADDR func, prevsp;
	277	register unsigned value;
	278
	279	/* Get real function start address from internal frame address */
	280	func = get_pc_function_start(frame->pc);
	281
	282	/* If no stack given, read register Br1 "(sp)" */
	283	if (!frame->frame)
	284	prevsp = read_register (SP_REGNUM);
	285	else
	286	prevsp = frame->frame;
	287
	288	/* Check function header, case #2 */
	289	value = read_memory_integer (func, 4);
	290	if (value)
	291	{
	292	/* 32bit call push value stored in function header */
	293	prevsp += value;
	294	}
	295	else
	296	{
	297	/* read half-word from suabr at start of function */
	298	prevsp += read_memory_integer (func + 10, 2);
	299	}
	300
	301	return (prevsp);
	302	}