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

/* This file has been modified by Data General Corporation, November 1989. */

#include <stdio.h>
#include "m88k-opcode.h"
#include "defs.h"
#include "symtab.h"

void sprint_address ();

/* Changed hashtab to hashtable to avoid naming conflict
   with libdc.o (used for tdesc) for m88k.
*/

INSTAB  *hashtable[HASHVAL] = {0};

/*
*		Disassemble an M88000 Instruction
*
*
*       This module decodes the first instruction in inbuf.  It uses the pc
*	to display pc-relative displacements.  It writes the disassembled
*	instruction in outbuf.
*
*			Revision History
*
*       Revision 1.0    11/08/85        Creation date by Motorola
*			05/11/89	R. Trawick adapted to GDB interface.
*/
#define MAXLEN 20

print_insn (memaddr, stream)
     CORE_ADDR memaddr;
     FILE *stream;
{
  unsigned char buffer[MAXLEN];
  /* should be expanded if disassembler prints symbol names */
  char outbuf[100];
  int n;

  /* Instruction addresses may have low two bits set. Clear them.	*/
  memaddr&= 0xfffffffc;
  read_memory (memaddr, buffer, MAXLEN);

  n = m88kdis ((int)memaddr, buffer, outbuf);

  fputs (outbuf, stream);

  return (n);
}

/*
 * disassemble the first instruction in 'inbuf'.
 * 'pc' should be the address of this instruction, it will
 *   be used to print the target address if this is a relative jump or call
 * 'outbuf' gets filled in with the disassembled instruction.  It should
 *   be long enough to hold the longest disassembled instruction.
 *   100 bytes is certainly enough, unless symbol printing is added later
 * The function returns the length of this instruction in bytes.
 */

int m88kdis( pc, inbuf, outbuf )

    int		pc;
    int	        *inbuf;
    char	*outbuf;

{   static		ihashtab_initialized = 0;
    int			instruction;
    unsigned int	opcode;
    INSTAB		*entry_ptr;
    int	        	opmask;
    int			class;

    instruction= *inbuf;

    if (!ihashtab_initialized) {
	init_disasm();
    }

    /* create a the appropriate mask to isolate the opcode */
    opmask= DEFMASK;
    class= instruction & DEFMASK;
    if ((class >= SFU0) && (class <= SFU7)) {
	if (instruction < SFU1) {
	    opmask= CTRLMASK;
	} else {
	    opmask= SFUMASK;
	}
    } else if (class == RRR) {
	opmask= RRRMASK;
    } else if (class == RRI10) {
	opmask= RRI10MASK;
    }

    /* isolate the opcode */
    opcode= instruction & opmask;

    /* search the hash table with the isolated opcode */
    for (entry_ptr= hashtable[ opcode % HASHVAL ];
	 (entry_ptr != NULL) && (entry_ptr->opcode != opcode);
	 entry_ptr= entry_ptr->next) {
    }

    if (entry_ptr == NULL) {
	sprintf( outbuf, "word\t%08x", instruction );
    } else {
	sprintf( outbuf, "%s\t", entry_ptr->mnemonic );
	sprintop( &outbuf[strlen(outbuf)], &(entry_ptr->op1), instruction, pc, 1 );
	sprintop( &outbuf[strlen(outbuf)], &(entry_ptr->op2), instruction, pc, 0 );
	sprintop( &outbuf[strlen(outbuf)], &(entry_ptr->op3), instruction, pc, 0 );
    }


    return 4;
}
\f

/*
*                      Decode an Operand of an Instruction
*
*			Functional Description
*
*       This module formats and writes an operand of an instruction to buf
*       based on the operand specification.  When the first flag is set this
*       is the first operand of an instruction.  Undefined operand types
*       cause a <dis error> message.
*
*			Parameters
*	char	*buf		buffer where the operand may be printed
*       OPSPEC  *opptr          Pointer to an operand specification
*       UINT    inst            Instruction from which operand is extracted
*	UINT    pc		PC of instruction; used for pc-relative disp.
*       int     first           Flag which if nonzero indicates the first
*                               operand of an instruction
*
*			Output
*
*       The operand specified is extracted from the instruction and is
*       written to buf in the format specified. The operand is preceded
*       by a comma if it is not the first operand of an instruction and it
*       is not a register indirect form.  Registers are preceded by 'r' and
*       hex values by '0x'.
*
*			Revision History
*
*       Revision 1.0    11/08/85        Creation date
*/

sprintop( buf, opptr, inst, pc, first )

   char   *buf;
   OPSPEC *opptr;
   UINT   inst;
   int	  pc;
   int    first;

{  int	  extracted_field;
   char	  *cond_mask_sym;
   char	  cond_mask_sym_buf[6];

   if (opptr->width == 0)
      return;

   switch(opptr->type) {
      case CRREG:
		       if (!first)
			   *buf++= ',';
		       sprintf( buf, "cr%d", UEXT(inst,opptr->offset,opptr->width));
		       break;

      case FCRREG:
		       if (!first)
			   *buf++= ',';
		       sprintf( buf, "fcr%d", UEXT(inst,opptr->offset,opptr->width));
		       break;

      case REGSC:
		       sprintf( buf, "[r%d]", UEXT(inst,opptr->offset,opptr->width));
		       break;

      case REG:
		       if (!first)
			   *buf++= ',';
		       sprintf( buf, "r%d", UEXT(inst,opptr->offset,opptr->width));
		       break;

      case HEX:
		        if (!first)
			   *buf++= ',';
		        extracted_field= UEXT(inst, opptr->offset, opptr->width);
		        if (extracted_field == 0) {
			    sprintf( buf, "0" );
		        } else {
			    sprintf( buf, "0x%02x", extracted_field );
		        }
		        break;

      case CONDMASK:
		        if (!first)
			   *buf++= ',';
		        extracted_field= UEXT(inst, opptr->offset, opptr->width);
		        switch (extracted_field & 0x0f) {
			  case 0x1:	cond_mask_sym= "gt0";
					break;
			  case 0x2:	cond_mask_sym= "eq0";
					break;
			  case 0x3:	cond_mask_sym= "ge0";
					break;
			  case 0xc:	cond_mask_sym= "lt0";
					break;
			  case 0xd:	cond_mask_sym= "ne0";
					break;
			  case 0xe:	cond_mask_sym= "le0";
					break;
			  default:	cond_mask_sym= cond_mask_sym_buf;
					sprintf( cond_mask_sym_buf,
						 "%x",
						 extracted_field );
					break;
			}
			strcpy( buf, cond_mask_sym );
			break;
			
      case PCREL:
		        if (!first)
			   *buf++= ',';
			sprint_address( pc + 4*(SEXT(inst,opptr->offset,opptr->width)),
					buf );
		        break;

      case CONT:
		       sprintf( buf,
				"%d,r%d",
				UEXT(inst,opptr->offset,5),
			        UEXT(inst,(opptr->offset)+5,5) );
		       break;

      case BF:
		       if (!first)
			   *buf++= ',';
		       sprintf( buf,
				"%d<%d>",
				UEXT(inst,(opptr->offset)+5,5),
			        UEXT(inst,opptr->offset,5));
		       break;

      default:
		       sprintf( buf, "<dis error: %08x>", inst );
    }

}

/*
*                 Initialize the Disassembler Instruction Table
*
*       Initialize the hash table and instruction table for the disassembler.
*       This should be called once before the first call to disasm().
*
*			Parameters
*
*			Output
*
*       If the debug option is selected, certain statistics about the hashing
*       distribution are written to stdout.
*
*			Revision History
*
*       Revision 1.0    11/08/85        Creation date
*/

init_disasm()
{
   int i,size;

   for (i=0 ; i < HASHVAL ; i++)
      hashtable[i] = NULL;

   for (i=0, size =  sizeof(instructions) / sizeof(INSTAB) ; i < size ;
       install(&instructions[i++]));

}

/*
*       Insert an instruction into the disassembler table by hashing the
*       opcode and inserting it into the linked list for that hash value.
*
*			Parameters
*
*       INSTAB *instptr         Pointer to the entry in the instruction table
*                               to be installed
*
*       Revision 1.0    11/08/85        Creation date
*			05/11/89	R. TRAWICK ADAPTED FROM MOTOROLA
*/

install(instptr)
   INSTAB *instptr;
{
   UINT i;

   i = (instptr->opcode) % HASHVAL;
   instptr->next = hashtable[i];
   hashtable[i] = instptr;
}
\f

/* adapted from print_address in printcmd by R. Trawick 5/15/89.  The two should
   be combined.
 */

void sprint_address (addr, buffer)

     CORE_ADDR  addr;
     char	*buffer;

{
	register int	i;
	struct symbol	*fs;
	char		*name;
	int		name_location;

	sprintf ( buffer, "0x%x", addr);

	fs = find_pc_function (addr);

	if (!fs) {
	    i = find_pc_misc_function (addr);

	    if (i < 0) return;	/* If nothing comes through, don't
				   print anything symbolic */

	    name = misc_function_vector[i].name;
	    name_location = misc_function_vector[i].address;
	} else {
	    name = fs->name;
	    name_location = BLOCK_START (SYMBOL_BLOCK_VALUE (fs));
	}

	if (addr - name_location)
	    sprintf (buffer, " <%s+%d>", name, addr - name_location);
	else
	    sprintf (buffer, " <%s>", name);
}
Commit	Line	Data
8aa13b87 JK	1	/* This file has been modified by Data General Corporation, November 1989. */
	2
	3	#include <stdio.h>
	4	#include "m88k-opcode.h"
	5	#include "defs.h"
	6	#include "symtab.h"
	7
	8	void sprint_address ();
	9
	10	/* Changed hashtab to hashtable to avoid naming conflict
	11	with libdc.o (used for tdesc) for m88k.
	12	*/
	13
	14	INSTAB *hashtable[HASHVAL] = {0};
	15
	16	/*
	17	* Disassemble an M88000 Instruction
	18	*
	19	*
	20	* This module decodes the first instruction in inbuf. It uses the pc
	21	* to display pc-relative displacements. It writes the disassembled
	22	* instruction in outbuf.
	23	*
	24	* Revision History
	25	*
	26	* Revision 1.0 11/08/85 Creation date by Motorola
	27	* 05/11/89 R. Trawick adapted to GDB interface.
	28	*/
	29	#define MAXLEN 20
	30
	31	print_insn (memaddr, stream)
	32	CORE_ADDR memaddr;
	33	FILE *stream;
	34	{
	35	unsigned char buffer[MAXLEN];
	36	/* should be expanded if disassembler prints symbol names */
	37	char outbuf[100];
	38	int n;
	39
	40	/* Instruction addresses may have low two bits set. Clear them. */
	41	memaddr&= 0xfffffffc;
	42	read_memory (memaddr, buffer, MAXLEN);
	43
	44	n = m88kdis ((int)memaddr, buffer, outbuf);
	45
	46	fputs (outbuf, stream);
	47
	48	return (n);
	49	}
	50
	51	/*
	52	* disassemble the first instruction in 'inbuf'.
	53	* 'pc' should be the address of this instruction, it will
	54	* be used to print the target address if this is a relative jump or call
	55	* 'outbuf' gets filled in with the disassembled instruction. It should
	56	* be long enough to hold the longest disassembled instruction.
	57	* 100 bytes is certainly enough, unless symbol printing is added later
	58	* The function returns the length of this instruction in bytes.
	59	*/
	60
	61	int m88kdis( pc, inbuf, outbuf )
	62
	63	int pc;
	64	int *inbuf;
65	char *outbuf;
66
67	{ static ihashtab_initialized = 0;
68	int instruction;
69	unsigned int opcode;
70	INSTAB *entry_ptr;
71	int opmask;
72	int class;
73
74	instruction= *inbuf;
75
76	if (!ihashtab_initialized) {
77	init_disasm();
78	}
79
80	/* create a the appropriate mask to isolate the opcode */
81	opmask= DEFMASK;
82	class= instruction & DEFMASK;
83	if ((class >= SFU0) && (class <= SFU7)) {
84	if (instruction < SFU1) {
85	opmask= CTRLMASK;
86	} else {
87	opmask= SFUMASK;
88	}
89	} else if (class == RRR) {
90	opmask= RRRMASK;
91	} else if (class == RRI10) {
92	opmask= RRI10MASK;
93	}
94
95	/* isolate the opcode */
96	opcode= instruction & opmask;
97
98	/* search the hash table with the isolated opcode */
99	for (entry_ptr= hashtable[ opcode % HASHVAL ];
100	(entry_ptr != NULL) && (entry_ptr->opcode != opcode);
101	entry_ptr= entry_ptr->next) {
102	}
103
104	if (entry_ptr == NULL) {
105	sprintf( outbuf, "word\t%08x", instruction );
106	} else {
107	sprintf( outbuf, "%s\t", entry_ptr->mnemonic );
108	sprintop( &outbuf[strlen(outbuf)], &(entry_ptr->op1), instruction, pc, 1 );
109	sprintop( &outbuf[strlen(outbuf)], &(entry_ptr->op2), instruction, pc, 0 );
110	sprintop( &outbuf[strlen(outbuf)], &(entry_ptr->op3), instruction, pc, 0 );
111	}
112
113
114	return 4;
115	}
116	\f
117
118	/*
119	* Decode an Operand of an Instruction
120	*
121	* Functional Description
122	*
123	* This module formats and writes an operand of an instruction to buf
124	* based on the operand specification. When the first flag is set this
125	* is the first operand of an instruction. Undefined operand types
126	* cause a <dis error> message.
127	*
128	* Parameters
129	* char *buf buffer where the operand may be printed
130	* OPSPEC *opptr Pointer to an operand specification
131	* UINT inst Instruction from which operand is extracted
132	* UINT pc PC of instruction; used for pc-relative disp.
133	* int first Flag which if nonzero indicates the first
134	* operand of an instruction
135	*
136	* Output
137	*
138	* The operand specified is extracted from the instruction and is
139	* written to buf in the format specified. The operand is preceded
140	* by a comma if it is not the first operand of an instruction and it
141	* is not a register indirect form. Registers are preceded by 'r' and
142	* hex values by '0x'.
143	*
144	* Revision History
145	*
146	* Revision 1.0 11/08/85 Creation date
147	*/
148
149	sprintop( buf, opptr, inst, pc, first )
150
151	char *buf;
152	OPSPEC *opptr;
153	UINT inst;
154	int pc;
155	int first;
156
157	{ int extracted_field;
158	char *cond_mask_sym;
159	char cond_mask_sym_buf[6];
160
161	if (opptr->width == 0)
162	return;
163
164	switch(opptr->type) {
165	case CRREG:
166	if (!first)
167	*buf++= ',';
168	sprintf( buf, "cr%d", UEXT(inst,opptr->offset,opptr->width));
169	break;
170
171	case FCRREG:
172	if (!first)
173	*buf++= ',';
174	sprintf( buf, "fcr%d", UEXT(inst,opptr->offset,opptr->width));
175	break;
176
177	case REGSC:
178	sprintf( buf, "[r%d]", UEXT(inst,opptr->offset,opptr->width));
179	break;
180
181	case REG:
182	if (!first)
183	*buf++= ',';
184	sprintf( buf, "r%d", UEXT(inst,opptr->offset,opptr->width));
185	break;
186
187	case HEX:
188	if (!first)
189	*buf++= ',';
190	extracted_field= UEXT(inst, opptr->offset, opptr->width);
191	if (extracted_field == 0) {
192	sprintf( buf, "0" );
193	} else {
194	sprintf( buf, "0x%02x", extracted_field );
195	}
196	break;
197
198	case CONDMASK:
199	if (!first)
200	*buf++= ',';
201	extracted_field= UEXT(inst, opptr->offset, opptr->width);
202	switch (extracted_field & 0x0f) {
203	case 0x1: cond_mask_sym= "gt0";
204	break;
205	case 0x2: cond_mask_sym= "eq0";
206	break;
207	case 0x3: cond_mask_sym= "ge0";
208	break;
209	case 0xc: cond_mask_sym= "lt0";
210	break;
211	case 0xd: cond_mask_sym= "ne0";
212	break;
213	case 0xe: cond_mask_sym= "le0";
214	break;
215	default: cond_mask_sym= cond_mask_sym_buf;
216	sprintf( cond_mask_sym_buf,
217	"%x",
218	extracted_field );
219	break;
220	}
221	strcpy( buf, cond_mask_sym );
222	break;
223
224	case PCREL:
225	if (!first)
226	*buf++= ',';
227	sprint_address( pc + 4*(SEXT(inst,opptr->offset,opptr->width)),
228	buf );
229	break;
230
231	case CONT:
232	sprintf( buf,
233	"%d,r%d",
234	UEXT(inst,opptr->offset,5),
235	UEXT(inst,(opptr->offset)+5,5) );
236	break;
237
238	case BF:
239	if (!first)
240	*buf++= ',';
241	sprintf( buf,
242	"%d<%d>",
243	UEXT(inst,(opptr->offset)+5,5),
244	UEXT(inst,opptr->offset,5));
245	break;
246
247	default:
248	sprintf( buf, "<dis error: %08x>", inst );
249	}
250
251	}
252
253	/*
254	* Initialize the Disassembler Instruction Table
255	*
256	* Initialize the hash table and instruction table for the disassembler.
257	* This should be called once before the first call to disasm().
258	*
259	* Parameters
260	*
261	* Output
262	*
263	* If the debug option is selected, certain statistics about the hashing
264	* distribution are written to stdout.
265	*
266	* Revision History
267	*
268	* Revision 1.0 11/08/85 Creation date
269	*/
270
271	init_disasm()
272	{
273	int i,size;
274
275	for (i=0 ; i < HASHVAL ; i++)
276	hashtable[i] = NULL;
277
278	for (i=0, size = sizeof(instructions) / sizeof(INSTAB) ; i < size ;
279	install(&instructions[i++]));
280
281	}
282
283	/*
284	* Insert an instruction into the disassembler table by hashing the
285	* opcode and inserting it into the linked list for that hash value.
286	*
287	* Parameters
288	*
289	* INSTAB *instptr Pointer to the entry in the instruction table
290	* to be installed
291	*
292	* Revision 1.0 11/08/85 Creation date
293	* 05/11/89 R. TRAWICK ADAPTED FROM MOTOROLA
294	*/
295
296	install(instptr)
297	INSTAB *instptr;
298	{
299	UINT i;
300
301	i = (instptr->opcode) % HASHVAL;
302	instptr->next = hashtable[i];
303	hashtable[i] = instptr;
304	}
305	\f
306
307	/* adapted from print_address in printcmd by R. Trawick 5/15/89. The two should
308	be combined.
309	*/
310
311	void sprint_address (addr, buffer)
312
313	CORE_ADDR addr;
314	char *buffer;
315
316	{
317	register int i;
318	struct symbol *fs;
319	char *name;
320	int name_location;
321
322	sprintf ( buffer, "0x%x", addr);
323
324	fs = find_pc_function (addr);
325
326	if (!fs) {
327	i = find_pc_misc_function (addr);
328
329	if (i < 0) return; /* If nothing comes through, don't
330	print anything symbolic */
331
332	name = misc_function_vector[i].name;
333	name_location = misc_function_vector[i].address;
334	} else {
335	name = fs->name;
336	name_location = BLOCK_START (SYMBOL_BLOCK_VALUE (fs));
337	}
338
339	if (addr - name_location)
340	sprintf (buffer, " <%s+%d>", name, addr - name_location);
341	else
342	sprintf (buffer, " <%s>", name);
343	}