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

/* Print IBM RS/6000 instructions for GNU software.
   Copyright 1991 Free Software Foundation, Inc.
   Contributed by IBM Corporation.

This file is part of GDB and the GNU binutils.

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 "defs.h"
#include "opcode/rs6k.h"

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

int
print_insn (memaddr, stream)
  CORE_ADDR memaddr;
  GDB_FILE *stream;
{
	int  pop, eop, probable_eop;	/* primary and extended opcodes */
	int  min, max;
	int  best = -1;			/* found best opcode index	*/
	int  oldbest = -1;
	unsigned int the_insn;

	read_memory (memaddr, &the_insn, sizeof (the_insn));
	pop = (unsigned)(the_insn >> 26);
	min = 0, max = NOPCODES-1;

	while (min < max) {
	  best = (min + max) / 2;

	  /* see if we are running in loops */
	  if (best == oldbest)
	    goto not_found;
	  oldbest = best;

	  if (pop < rs6k_ops [best].p_opcode)
	    max = best;

	  else if (pop > rs6k_ops [best].p_opcode)
	    min = best;

	  else {
	    /* Opcode matched, check extended opcode. */

	    if (rs6k_ops [best].e_opcode == -1) {
	      /* there is no valid extended opcode, what we've got is
		 just fine. */
	      goto insn_found;
	    }

	    /* Largest possible value of extended opcode. */
	    probable_eop = ((the_insn) >> 1) & 0x3ff;

	    eop = probable_eop & eopMask [rs6k_ops [best].format];

	    if (eop < rs6k_ops [best].e_opcode) {

	      while (pop == rs6k_ops [best].p_opcode) {
		if (eop == rs6k_ops [best].e_opcode)	/* found it! */
		  goto insn_found;
	        --best;
	        eop = probable_eop & eopMask [rs6k_ops [best].format];
	      }
	      goto not_found;
	    }

	    else if (eop > rs6k_ops [best].e_opcode) {

	      while (pop == rs6k_ops [best].p_opcode) {
		if (eop == rs6k_ops [best].e_opcode)	/* found it! */
		  goto insn_found;
	        ++best;
	        eop = probable_eop & eopMask [rs6k_ops [best].format];
	      }
	      goto not_found;
	    }

	    else /*  eop == rs6k_ops [best].e_opcode */
	      goto insn_found;
	  }
	}	

	best = min;
	if (pop == rs6k_ops [best].p_opcode &&
           (rs6k_ops [best].e_opcode == -1 || rs6k_ops [best].e_opcode == eop))
	    goto insn_found;

	else
	  goto not_found;


insn_found:
	print_operator (stream, memaddr, the_insn, best);
	return 4;

not_found:
	fprintf_unfiltered (stream, "0x%08x", the_insn);
	return 4;
}


/* condition code names */
static char *cond_code [] = {
  "lt", "gt", "eq", "so", "ge", "le", "ne", "ns", "nl", "ng", "z", "nz" };


print_operator (stream, memaddr, insn_word, insn_no)
FILE	*stream;
long	memaddr;
long	insn_word;
int	insn_no;
{
  char buf [20];
  char *qq = buf;
  char *pp = rs6k_ops[insn_no].opr_ext;
  int tmp;
  int nocomma = 0;			/* true if no comma needed */

  if (pp) {
    while (*pp) {

      switch ( *pp ) {
	case '.':
	  if (insn_word & 0x1)
	    *qq++ = '.';
	  break;

	case 'l':
	  if (insn_word & 0x1)
	   *qq++ = 'l';
	  break;

	case 't':
	  if ((insn_word & 0x03e00000) == 0x01800000)
	   *qq++ = 't';
	  break;

	case 'f':
	  if ((insn_word & 0x03e00000) == 0x00800000)
	   *qq++ = 'f';
	  break;

	case 'a':
	  if (insn_word & 0x2)
	   *qq++ = 'a';
	  break;

	case 'o':
	  if (insn_word & 0x4000)
	   *qq++ = 'o';
	  break;

	case '1':		/* exception #1 for bb/bc ambiguity */
	  tmp = (insn_word >> 21) & 0x1f;	/* extract BO	*/
	  if (tmp != 0xc && tmp != 0x4) {
	    /* you can't use `bb' now. switch to `bc' */
	    *(qq-1) = 'c';
	    ++insn_no;
	    pp = rs6k_ops[insn_no].opr_ext;
	    continue;
	  }
	  break;

	default:
	  abort ();
      }
      ++pp;
    }
  }
  *qq = '\0';

  fprintf_unfiltered (stream, "%s%s\t", rs6k_ops[insn_no].operator, buf);

  /* parse the operand now. */
  pp = rs6k_ops[insn_no].oprnd_format;

  while (*pp != 0) {
    switch (*pp) {
      case TO	:
	fprintf_unfiltered (stream, "%d", (insn_word >> 21) & 0x1f);
	break;

      case RT	:
      case RS	:
	fprintf_unfiltered (stream, "r%d", (insn_word >> 21) & 0x1f);
	break;

      case LI	:
	tmp  = (insn_word >> 16) & 0x1f;
#if 0
	/* This is wrong, wrong, wrong.  The condition code only goes
	   from 0 to 3 (for the instructions which can use extended
	   mnemonics of this type), and the XX (lt, gt, eq etc.) goes
	   into the mnemonic, not as an operand.

	   Probably the best way to get this right in both assembler
	   and disassembler is to switch to a match/lose style opcode
	   table like the sparc.  */
	if (tmp > 11) {
	  fprintf_unfiltered (stream, "{unknown cond code: 0x%x}", insn_word);
	  tmp = 0;
	}
	fprintf_unfiltered (stream, "%s", cond_code [tmp]);
#else
	/* So for just always use the "bbf/bbt" form.  This is perfectly
	   correct, just not necessarily as legible.

	   If tmp is not in the range 0-3, we can't use an XX form anyway.  */
	fprintf_unfiltered (stream, "%d", tmp);
#endif
	break;

      case A2	:
      case TA14	:
	tmp = (insn_word & 0xfffc);
	if (tmp & 0x8000)		/* fix sign extension	*/
	  tmp -= 0x10000;

	if ((insn_word & 0x2) == 0)	/* if AA not set	*/
	  tmp += memaddr;

        print_address (tmp, stream);
	break;

      case TA24	:
	tmp = insn_word & 0x03fffffc;
	if (tmp & 0x2000000)
	  tmp -= 0x4000000;
	
	if ((insn_word & 0x2) == 0)		/* if no AA bit set */
	  tmp += memaddr;

        print_address (tmp, stream);
	break;

      case LEV	:			/* for svc only */
	if (insn_word & 0x2) {		/* SA is set	*/
	  nocomma = 1;
	}
	else
          fprintf_unfiltered (stream, "%d", (insn_word >> 5) & 0x7f);
	break;

      case FL1	:			/* for svc only */
	if (insn_word & 0x2) {		/* SA is set	*/
	  nocomma = 1;
	}
	else
          fprintf_unfiltered (stream, "%d", (insn_word >> 12) & 0xf);
	break;

      case FL2	:			/* for svc only	*/
	nocomma = 0;
	if (insn_word & 0x2)		/* SA is set	*/
	  fprintf_unfiltered (stream, "%d", (insn_word >> 2) & 0x3fff);
	else
          fprintf_unfiltered (stream, "%d", (insn_word >> 2) & 0x7);
	break;

      case RA	:
	if (nocomma) {
	  fprintf_unfiltered (stream, "r%d)", (insn_word >> 16) & 0x1f);
	  nocomma = 0;
	}
	else
	  fprintf_unfiltered (stream, "r%d", (insn_word >> 16) & 0x1f);
	break;

      case RB	:
	fprintf_unfiltered (stream, "r%d", (insn_word >> 11) & 0x1f);
	break;

      case SI	:
	tmp = insn_word & 0xffff;
	if (tmp & 0x8000)
	  tmp -= 0x10000;
	fprintf_unfiltered (stream, "%d", tmp);
	break;

      case UI	:
	fprintf_unfiltered (stream, "%d", insn_word & 0xffff);
	break;

      case BF	:
	fprintf_unfiltered (stream, "%d", (insn_word >> 23) & 0x7);
	break;

      case BFA	:
	fprintf_unfiltered (stream, "%d", (insn_word >> 18) & 0x7);
	break;

      case BT	:
	fprintf_unfiltered (stream, "%d", (insn_word >> 21) & 0x1f);
	break;

      case BA	:
	fprintf_unfiltered (stream, "%d", (insn_word >> 16) & 0x1f);
	break;

      case BB	:
	fprintf_unfiltered (stream, "%d", (insn_word >> 11) & 0x1f);
	break;

      case BO	:
	fprintf_unfiltered (stream, "%d", (insn_word >> 21) & 0x1f);
	break;

      case BI	:
	fprintf_unfiltered (stream, "%d", (insn_word >> 16) & 0x1f);
	break;

      case SH	:
	fprintf_unfiltered (stream, "%d", (insn_word >> 11) & 0x1f);
	break;

      case MB	:
	fprintf_unfiltered (stream, "0x%x", (insn_word >> 6) & 0x1f);
	break;

      case ME	:
	fprintf_unfiltered (stream, "0x%x", (insn_word >> 1) & 0x1f);
	break;

      case SPR	:
	fprintf_unfiltered (stream, "%d", (insn_word >> 16) & 0x1f);
	break;

      case DIS	:
	nocomma = 1;
	tmp = insn_word & 0xffff;
	if (tmp & 0x8000)
	  tmp -= 0x10000;
	fprintf_unfiltered (stream, "%d(", tmp);
	break;

      case FXM	:
	fprintf_unfiltered (stream, "0x%x", (insn_word >> 12) & 0xff);
	break;

      case FRT	:
      case FRS	:
	fprintf_unfiltered (stream, "f%d", (insn_word >> 21) & 0x1f);
	break;

      case FRA	:
	fprintf_unfiltered (stream, "f%d", (insn_word >> 16) & 0x1f);
	break;

      case FRB	:
	fprintf_unfiltered (stream, "f%d", (insn_word >> 11) & 0x1f);
	break;

      case FRC	:
	fprintf_unfiltered (stream, "f%d", (insn_word >> 6) & 0x1f);
	break;

      case FLM	:
	fprintf_unfiltered (stream, "0x%x", (insn_word >> 17) & 0xff);
	break;

      case NB	:
	fprintf_unfiltered (stream, "%d", (insn_word >> 11) & 0x1f);
	break;

      case I	:
	fprintf_unfiltered (stream, "%d", (insn_word >> 12) & 0xf);
	break;

      default	:
	fprintf_unfiltered (stream,
		 "{Internal error: Unknown operand format identifier %d}",
		 *pp);
    }
    ++pp;

    if (*pp != '\0' && !nocomma)
      fputc_unfiltered(',', stream);
  }
}
Commit	Line	Data
6373dbe3 JG	1	/* Print IBM RS/6000 instructions for GNU software.
	2	Copyright 1991 Free Software Foundation, Inc.
	3	Contributed by IBM Corporation.
41abdfbd	4
6373dbe3 JG	5	This file is part of GDB and the GNU binutils.
	6
	7	This program is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
	9	the Free Software Foundation; either version 2 of the License, or
	10	(at your option) any later version.
	11
	12	This program is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with this program; if not, write to the Free Software
	19	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
41abdfbd	20
41abdfbd	21	#include "defs.h"
14832b2e	22	#include "opcode/rs6k.h"
41abdfbd	23
41abdfbd JG	24	/* Print the rs6k instruction at address MEMADDR in debugged memory,
	25	on STREAM. Returns length of the instruction, in bytes. */
	26
	27	int
	28	print_insn (memaddr, stream)
	29	CORE_ADDR memaddr;
199b2450	30	GDB_FILE *stream;
41abdfbd	31	{
d453b386	32	int pop, eop, probable_eop; /* primary and extended opcodes */
41abdfbd JG	33	int min, max;
	34	int best = -1; /* found best opcode index */
	35	int oldbest = -1;
	36	unsigned int the_insn;
	37
	38	read_memory (memaddr, &the_insn, sizeof (the_insn));
	39	pop = (unsigned)(the_insn >> 26);
41abdfbd JG	40	min = 0, max = NOPCODES-1;
	41
	42	while (min < max) {
	43	best = (min + max) / 2;
	44
	45	/* see if we are running in loops */
	46	if (best == oldbest)
	47	goto not_found;
	48	oldbest = best;
	49
	50	if (pop < rs6k_ops [best].p_opcode)
	51	max = best;
	52
	53	else if (pop > rs6k_ops [best].p_opcode)
	54	min = best;
	55
	56	else {
d453b386	57	/* Opcode matched, check extended opcode. */
41abdfbd JG	58
	59	if (rs6k_ops [best].e_opcode == -1) {
	60	/* there is no valid extended opcode, what we've got is
	61	just fine. */
	62	goto insn_found;
	63	}
	64
d453b386 PB	65	/* Largest possible value of extended opcode. */
	66	probable_eop = ((the_insn) >> 1) & 0x3ff;
	67
	68	eop = probable_eop & eopMask [rs6k_ops [best].format];
	69
	70	if (eop < rs6k_ops [best].e_opcode) {
41abdfbd JG	71
	72	while (pop == rs6k_ops [best].p_opcode) {
	73	if (eop == rs6k_ops [best].e_opcode) /* found it! */
	74	goto insn_found;
	75	--best;
d453b386	76	eop = probable_eop & eopMask [rs6k_ops [best].format];
41abdfbd JG	77	}
	78	goto not_found;
	79	}
	80
	81	else if (eop > rs6k_ops [best].e_opcode) {
	82
	83	while (pop == rs6k_ops [best].p_opcode) {
	84	if (eop == rs6k_ops [best].e_opcode) /* found it! */
	85	goto insn_found;
	86	++best;
d453b386	87	eop = probable_eop & eopMask [rs6k_ops [best].format];
41abdfbd JG	88	}
	89	goto not_found;
	90	}
	91
	92	else /* eop == rs6k_ops [best].e_opcode */
	93	goto insn_found;
	94	}
	95	}
	96
	97	best = min;
	98	if (pop == rs6k_ops [best].p_opcode &&
	99	(rs6k_ops [best].e_opcode == -1 \|\| rs6k_ops [best].e_opcode == eop))
	100	goto insn_found;
	101
	102	else
	103	goto not_found;
	104
	105
	106	insn_found:
	107	print_operator (stream, memaddr, the_insn, best);
	108	return 4;
	109
	110	not_found:
199b2450	111	fprintf_unfiltered (stream, "0x%08x", the_insn);
41abdfbd JG	112	return 4;
	113	}
	114
	115
	116
	117	/* condition code names */
	118	static char *cond_code [] = {
	119	"lt", "gt", "eq", "so", "ge", "le", "ne", "ns", "nl", "ng", "z", "nz" };
	120
	121
	122	print_operator (stream, memaddr, insn_word, insn_no)
	123	FILE *stream;
	124	long memaddr;
	125	long insn_word;
	126	int insn_no;
	127	{
9efdc2fe	128	char buf [20];
41abdfbd JG	129	char *qq = buf;
	130	char *pp = rs6k_ops[insn_no].opr_ext;
	131	int tmp;
	132	int nocomma = 0; /* true if no comma needed */
	133
41abdfbd JG	134	if (pp) {
	135	while (*pp) {
	136
	137	switch ( *pp ) {
	138	case '.':
	139	if (insn_word & 0x1)
9efdc2fe	140	*qq++ = '.';
41abdfbd JG	141	break;
	142
	143	case 'l':
	144	if (insn_word & 0x1)
	145	*qq++ = 'l';
	146	break;
	147
	148	case 't':
	149	if ((insn_word & 0x03e00000) == 0x01800000)
	150	*qq++ = 't';
	151	break;
	152
	153	case 'f':
	154	if ((insn_word & 0x03e00000) == 0x00800000)
	155	*qq++ = 'f';
	156	break;
	157
	158	case 'a':
	159	if (insn_word & 0x2)
	160	*qq++ = 'a';
	161	break;
	162
	163	case 'o':
	164	if (insn_word & 0x4000)
	165	*qq++ = 'o';
	166	break;
	167
	168	case '1': /* exception #1 for bb/bc ambiguity */
	169	tmp = (insn_word >> 21) & 0x1f; /* extract BO */
	170	if (tmp != 0xc && tmp != 0x4) {
	171	/* you can't use `bb' now. switch to `bc' */
	172	*(qq-1) = 'c';
	173	++insn_no;
	174	pp = rs6k_ops[insn_no].opr_ext;
	175	continue;
	176	}
	177	break;
	178
	179	default:
	180	abort ();
	181	}
	182	++pp;
	183	}
	184	}
9efdc2fe	185	*qq = '\0';
41abdfbd	186
199b2450	187	fprintf_unfiltered (stream, "%s%s\t", rs6k_ops[insn_no].operator, buf);
41abdfbd JG	188
	189	/* parse the operand now. */
	190	pp = rs6k_ops[insn_no].oprnd_format;
	191
944c1c2f	192	while (*pp != 0) {
41abdfbd JG	193	switch (*pp) {
41abdfbd JG	194	case TO :
199b2450	195	fprintf_unfiltered (stream, "%d", (insn_word >> 21) & 0x1f);
41abdfbd JG	196	break;
	197
	198	case RT :
	199	case RS :
199b2450	200	fprintf_unfiltered (stream, "r%d", (insn_word >> 21) & 0x1f);
41abdfbd JG	201	break;
	202
	203	case LI :
	204	tmp = (insn_word >> 16) & 0x1f;
944c1c2f JK	205	#if 0
	206	/* This is wrong, wrong, wrong. The condition code only goes
	207	from 0 to 3 (for the instructions which can use extended
	208	mnemonics of this type), and the XX (lt, gt, eq etc.) goes
	209	into the mnemonic, not as an operand.
	210
	211	Probably the best way to get this right in both assembler
	212	and disassembler is to switch to a match/lose style opcode
	213	table like the sparc. */
41abdfbd	214	if (tmp > 11) {
199b2450	215	fprintf_unfiltered (stream, "{unknown cond code: 0x%x}", insn_word);
41abdfbd JG	216	tmp = 0;
41abdfbd JG	217	}
199b2450	218	fprintf_unfiltered (stream, "%s", cond_code [tmp]);
944c1c2f JK	219	#else
	220	/* So for just always use the "bbf/bbt" form. This is perfectly
	221	correct, just not necessarily as legible.
	222
	223	If tmp is not in the range 0-3, we can't use an XX form anyway. */
199b2450	224	fprintf_unfiltered (stream, "%d", tmp);
944c1c2f	225	#endif
41abdfbd JG	226	break;
41abdfbd JG	227
41abdfbd JG	228	case A2 :
	229	case TA14 :
	230	tmp = (insn_word & 0xfffc);
	231	if (tmp & 0x8000) /* fix sign extension */
	232	tmp -= 0x10000;
	233
	234	if ((insn_word & 0x2) == 0) /* if AA not set */
	235	tmp += memaddr;
	236
9efdc2fe	237	print_address (tmp, stream);
41abdfbd JG	238	break;
	239
	240	case TA24 :
	241	tmp = insn_word & 0x03fffffc;
	242	if (tmp & 0x2000000)
	243	tmp -= 0x4000000;
	244
	245	if ((insn_word & 0x2) == 0) /* if no AA bit set */
	246	tmp += memaddr;
	247
9efdc2fe	248	print_address (tmp, stream);
41abdfbd JG	249	break;
	250
	251	case LEV : /* for svc only */
	252	if (insn_word & 0x2) { /* SA is set */
	253	nocomma = 1;
41abdfbd JG	254	}
41abdfbd JG	255	else
199b2450	256	fprintf_unfiltered (stream, "%d", (insn_word >> 5) & 0x7f);
41abdfbd JG	257	break;
	258
	259	case FL1 : /* for svc only */
	260	if (insn_word & 0x2) { /* SA is set */
	261	nocomma = 1;
41abdfbd JG	262	}
41abdfbd JG	263	else
199b2450	264	fprintf_unfiltered (stream, "%d", (insn_word >> 12) & 0xf);
41abdfbd JG	265	break;
	266
	267	case FL2 : /* for svc only */
	268	nocomma = 0;
	269	if (insn_word & 0x2) /* SA is set */
199b2450	270	fprintf_unfiltered (stream, "%d", (insn_word >> 2) & 0x3fff);
41abdfbd	271	else
199b2450	272	fprintf_unfiltered (stream, "%d", (insn_word >> 2) & 0x7);
41abdfbd JG	273	break;
	274
	275	case RA :
	276	if (nocomma) {
199b2450	277	fprintf_unfiltered (stream, "r%d)", (insn_word >> 16) & 0x1f);
41abdfbd JG	278	nocomma = 0;
	279	}
	280	else
199b2450	281	fprintf_unfiltered (stream, "r%d", (insn_word >> 16) & 0x1f);
41abdfbd JG	282	break;
	283
	284	case RB :
199b2450	285	fprintf_unfiltered (stream, "r%d", (insn_word >> 11) & 0x1f);
41abdfbd JG	286	break;
	287
	288	case SI :
	289	tmp = insn_word & 0xffff;
	290	if (tmp & 0x8000)
	291	tmp -= 0x10000;
199b2450	292	fprintf_unfiltered (stream, "%d", tmp);
41abdfbd JG	293	break;
	294
	295	case UI :
199b2450	296	fprintf_unfiltered (stream, "%d", insn_word & 0xffff);
41abdfbd JG	297	break;
	298
	299	case BF :
199b2450	300	fprintf_unfiltered (stream, "%d", (insn_word >> 23) & 0x7);
41abdfbd JG	301	break;
	302
	303	case BFA :
199b2450	304	fprintf_unfiltered (stream, "%d", (insn_word >> 18) & 0x7);
41abdfbd JG	305	break;
	306
	307	case BT :
199b2450	308	fprintf_unfiltered (stream, "%d", (insn_word >> 21) & 0x1f);
41abdfbd JG	309	break;
	310
	311	case BA :
199b2450	312	fprintf_unfiltered (stream, "%d", (insn_word >> 16) & 0x1f);
41abdfbd JG	313	break;
	314
	315	case BB :
199b2450	316	fprintf_unfiltered (stream, "%d", (insn_word >> 11) & 0x1f);
41abdfbd JG	317	break;
	318
	319	case BO :
199b2450	320	fprintf_unfiltered (stream, "%d", (insn_word >> 21) & 0x1f);
41abdfbd JG	321	break;
	322
	323	case BI :
199b2450	324	fprintf_unfiltered (stream, "%d", (insn_word >> 16) & 0x1f);
41abdfbd JG	325	break;
	326
	327	case SH :
199b2450	328	fprintf_unfiltered (stream, "%d", (insn_word >> 11) & 0x1f);
41abdfbd JG	329	break;
	330
	331	case MB :
199b2450	332	fprintf_unfiltered (stream, "0x%x", (insn_word >> 6) & 0x1f);
41abdfbd JG	333	break;
	334
	335	case ME :
199b2450	336	fprintf_unfiltered (stream, "0x%x", (insn_word >> 1) & 0x1f);
41abdfbd JG	337	break;
	338
	339	case SPR :
199b2450	340	fprintf_unfiltered (stream, "%d", (insn_word >> 16) & 0x1f);
41abdfbd JG	341	break;
	342
	343	case DIS :
	344	nocomma = 1;
	345	tmp = insn_word & 0xffff;
	346	if (tmp & 0x8000)
	347	tmp -= 0x10000;
199b2450	348	fprintf_unfiltered (stream, "%d(", tmp);
41abdfbd JG	349	break;
	350
	351	case FXM :
199b2450	352	fprintf_unfiltered (stream, "0x%x", (insn_word >> 12) & 0xff);
41abdfbd JG	353	break;
	354
	355	case FRT :
	356	case FRS :
199b2450	357	fprintf_unfiltered (stream, "f%d", (insn_word >> 21) & 0x1f);
41abdfbd JG	358	break;
	359
	360	case FRA :
199b2450	361	fprintf_unfiltered (stream, "f%d", (insn_word >> 16) & 0x1f);
41abdfbd JG	362	break;
	363
	364	case FRB :
199b2450	365	fprintf_unfiltered (stream, "f%d", (insn_word >> 11) & 0x1f);
41abdfbd JG	366	break;
	367
	368	case FRC :
199b2450	369	fprintf_unfiltered (stream, "f%d", (insn_word >> 6) & 0x1f);
41abdfbd JG	370	break;
	371
	372	case FLM :
199b2450	373	fprintf_unfiltered (stream, "0x%x", (insn_word >> 17) & 0xff);
41abdfbd JG	374	break;
	375
	376	case NB :
199b2450	377	fprintf_unfiltered (stream, "%d", (insn_word >> 11) & 0x1f);
41abdfbd JG	378	break;
	379
	380	case I :
199b2450	381	fprintf_unfiltered (stream, "%d", (insn_word >> 12) & 0xf);
41abdfbd JG	382	break;
	383
	384	default :
199b2450	385	fprintf_unfiltered (stream,
9efdc2fe PB	386	"{Internal error: Unknown operand format identifier %d}",
9efdc2fe PB	387	*pp);
41abdfbd	388	}
41abdfbd JG	389	++pp;
41abdfbd JG	390
944c1c2f	391	if (*pp != '\0' && !nocomma)
199b2450	392	fputc_unfiltered(',', stream);
41abdfbd	393	}
41abdfbd	394	}