[deliverable/binutils-gdb.git] / gdb / gould-pinsn.c

/* Print GOULD RISC instructions for GDB, the GNU debugger.
   Copyright (C) 1986, 1987, 1989 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., 675 Mass Ave, Cambridge, MA 02139, USA.  */

#include <stdio.h>
#include "gdbcore.h"

#include "defs.h"
#include "param.h"
#include "symtab.h"
#include "frame.h"
#if defined GOULD_PN
#include "pn-opcode.h"
#else
#include "np1-opcode.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])

\f
/* Print the GOULD instruction at address MEMADDR in debugged memory,
   on STREAM.  Returns length of the instruction, in bytes.  */

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