[deliverable/binutils-gdb.git] / opcodes / spu-dis.c

/* Disassemble SPU instructions

   Copyright 2006, 2007 Free Software Foundation, Inc.

   This file is part of the GNU opcodes library.

   This library 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 3, or (at your option)
   any later version.

   It 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 file; see the file COPYING.  If not, write to the
   Free Software Foundation, 51 Franklin Street - Fifth Floor, Boston,
   MA 02110-1301, USA.  */

#include <stdio.h>
#include "sysdep.h"
#include "dis-asm.h"
#include "opcode/spu.h"

/* This file provides a disassembler function which uses
   the disassembler interface defined in dis-asm.h.   */

extern const struct spu_opcode spu_opcodes[];
extern const int spu_num_opcodes;

static const struct spu_opcode *spu_disassemble_table[(1<<11)];

static void
init_spu_disassemble (void)
{
  int i;

  /* If two instructions have the same opcode then we prefer the first
   * one.  In most cases it is just an alternate mnemonic. */
  for (i = 0; i < spu_num_opcodes; i++)
    {
      int o = spu_opcodes[i].opcode;
      if (o >= (1 << 11))
	abort ();
      if (spu_disassemble_table[o] == 0)
	spu_disassemble_table[o] = &spu_opcodes[i];
    }
}

/* Determine the instruction from the 10 least significant bits. */
static const struct spu_opcode *
get_index_for_opcode (unsigned int insn)
{
  const struct spu_opcode *index;
  unsigned int opcode = insn >> (32-11);

  /* Init the table.  This assumes that element 0/opcode 0 (currently
   * NOP) is always used */
  if (spu_disassemble_table[0] == 0)
    init_spu_disassemble ();

  if ((index = spu_disassemble_table[opcode & 0x780]) != 0
      && index->insn_type == RRR)
    return index;

  if ((index = spu_disassemble_table[opcode & 0x7f0]) != 0
      && (index->insn_type == RI18 || index->insn_type == LBT))
    return index;

  if ((index = spu_disassemble_table[opcode & 0x7f8]) != 0
      && index->insn_type == RI10)
    return index;

  if ((index = spu_disassemble_table[opcode & 0x7fc]) != 0
      && (index->insn_type == RI16))
    return index;

  if ((index = spu_disassemble_table[opcode & 0x7fe]) != 0
      && (index->insn_type == RI8))
    return index;

  if ((index = spu_disassemble_table[opcode & 0x7ff]) != 0)
    return index;

  return 0;
}

/* Print a Spu instruction.  */

int
print_insn_spu (bfd_vma memaddr, struct disassemble_info *info)
{
  bfd_byte buffer[4];
  int value;
  int hex_value;
  int status;
  unsigned int insn;
  const struct spu_opcode *index;
  enum spu_insns tag;

  status = (*info->read_memory_func) (memaddr, buffer, 4, info);
  if (status != 0)
    {
      (*info->memory_error_func) (status, memaddr, info);
      return -1;
    }

  insn = bfd_getb32 (buffer);

  index = get_index_for_opcode (insn);

  if (index == 0)
    {
      (*info->fprintf_func) (info->stream, ".long 0x%x", insn);
    }
  else
    {
      int i;
      int paren = 0;
      tag = (enum spu_insns)(index - spu_opcodes);
      (*info->fprintf_func) (info->stream, "%s", index->mnemonic);
      if (tag == M_BI || tag == M_BISL || tag == M_IRET || tag == M_BISLED
	  || tag == M_BIHNZ || tag == M_BIHZ || tag == M_BINZ || tag == M_BIZ
          || tag == M_SYNC || tag == M_HBR)
	{
	  int fb = (insn >> (32-18)) & 0x7f;
	  if (fb & 0x40)
	    (*info->fprintf_func) (info->stream, tag == M_SYNC ? "c" : "p");
	  if (fb & 0x20)
	    (*info->fprintf_func) (info->stream, "d");
	  if (fb & 0x10)
	    (*info->fprintf_func) (info->stream, "e");
	}
      if (index->arg[0] != 0)
	(*info->fprintf_func) (info->stream, "\t");
      hex_value = 0;
      for (i = 1;  i <= index->arg[0]; i++)
	{
	  int arg = index->arg[i];
	  if (arg != A_P && !paren && i > 1)
	    (*info->fprintf_func) (info->stream, ",");

	  switch (arg)
	    {
	    case A_T:
	      (*info->fprintf_func) (info->stream, "$%d",
				     DECODE_INSN_RT (insn));
	      break;
	    case A_A:
	      (*info->fprintf_func) (info->stream, "$%d",
				     DECODE_INSN_RA (insn));
	      break;
	    case A_B:
	      (*info->fprintf_func) (info->stream, "$%d",
				     DECODE_INSN_RB (insn));
	      break;
	    case A_C:
	      (*info->fprintf_func) (info->stream, "$%d",
				     DECODE_INSN_RC (insn));
	      break;
	    case A_S:
	      (*info->fprintf_func) (info->stream, "$sp%d",
				     DECODE_INSN_RA (insn));
	      break;
	    case A_H:
	      (*info->fprintf_func) (info->stream, "$ch%d",
				     DECODE_INSN_RA (insn));
	      break;
	    case A_P:
	      paren++;
	      (*info->fprintf_func) (info->stream, "(");
	      break;
	    case A_U7A:
	      (*info->fprintf_func) (info->stream, "%d",
				     173 - DECODE_INSN_U8 (insn));
	      break;
	    case A_U7B:
	      (*info->fprintf_func) (info->stream, "%d",
				     155 - DECODE_INSN_U8 (insn));
	      break;
	    case A_S3:
	    case A_S6:
	    case A_S7:
	    case A_S7N:
	    case A_U3:
	    case A_U5:
	    case A_U6:
	    case A_U7:
	      hex_value = DECODE_INSN_I7 (insn);
	      (*info->fprintf_func) (info->stream, "%d", hex_value);
	      break;
	    case A_S11:
	      (*info->print_address_func) (memaddr + DECODE_INSN_I9a (insn) * 4,
					   info);
	      break;
	    case A_S11I:
	      (*info->print_address_func) (memaddr + DECODE_INSN_I9b (insn) * 4,
					   info);
	      break;
	    case A_S10:
	    case A_S10B:
	      hex_value = DECODE_INSN_I10 (insn);
	      (*info->fprintf_func) (info->stream, "%d", hex_value);
	      break;
	    case A_S14:
	      hex_value = DECODE_INSN_I10 (insn) * 16;
	      (*info->fprintf_func) (info->stream, "%d", hex_value);
	      break;
	    case A_S16:
	      hex_value = DECODE_INSN_I16 (insn);
	      (*info->fprintf_func) (info->stream, "%d", hex_value);
	      break;
	    case A_X16:
	      hex_value = DECODE_INSN_U16 (insn);
	      (*info->fprintf_func) (info->stream, "%u", hex_value);
	      break;
	    case A_R18:
	      value = DECODE_INSN_I16 (insn) * 4;
	      if (value == 0)
		(*info->fprintf_func) (info->stream, "%d", value);
	      else
		{
		  hex_value = memaddr + value;
		  (*info->print_address_func) (hex_value & 0x3ffff, info);
		}
	      break;
	    case A_S18:
	      value = DECODE_INSN_U16 (insn) * 4;
	      if (value == 0)
		(*info->fprintf_func) (info->stream, "%d", value);
	      else
		(*info->print_address_func) (value, info);
	      break;
	    case A_U18:
	      value = DECODE_INSN_U18 (insn);
	      if (value == 0 || !(*info->symbol_at_address_func)(0, info))
		{
		  hex_value = value;
		  (*info->fprintf_func) (info->stream, "%u", value);
		}
	      else
		(*info->print_address_func) (value, info);
	      break;
	    case A_U14:
	      hex_value = DECODE_INSN_U14 (insn);
	      (*info->fprintf_func) (info->stream, "%u", hex_value);
	      break;
	    }
	  if (arg != A_P && paren)
	    {
	      (*info->fprintf_func) (info->stream, ")");
	      paren--;
	    }
	}
      if (hex_value > 16)
	(*info->fprintf_func) (info->stream, "\t# %x", hex_value);
    }
  return 4;
}
Commit	Line	Data
e9f53129 AM	1	/* Disassemble SPU instructions
e9f53129 AM	2
9b201bb5	3	Copyright 2006, 2007 Free Software Foundation, Inc.
e9f53129	4
9b201bb5	5	This file is part of the GNU opcodes library.
e9f53129	6
9b201bb5	7	This library is free software; you can redistribute it and/or modify
e9f53129	8	it under the terms of the GNU General Public License as published by
9b201bb5 NC	9	the Free Software Foundation; either version 3, or (at your option)
	10	any later version.
	11
	12	It is distributed in the hope that it will be useful, but WITHOUT
	13	ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
	14	or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
	15	License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with this file; see the file COPYING. If not, write to the
	19	Free Software Foundation, 51 Franklin Street - Fifth Floor, Boston,
	20	MA 02110-1301, USA. */
e9f53129 AM	21
	22	#include <stdio.h>
	23	#include "sysdep.h"
	24	#include "dis-asm.h"
	25	#include "opcode/spu.h"
	26
	27	/* This file provides a disassembler function which uses
	28	the disassembler interface defined in dis-asm.h. */
	29
	30	extern const struct spu_opcode spu_opcodes[];
	31	extern const int spu_num_opcodes;
	32
	33	static const struct spu_opcode *spu_disassemble_table[(1<<11)];
	34
	35	static void
	36	init_spu_disassemble (void)
	37	{
	38	int i;
	39
	40	/* If two instructions have the same opcode then we prefer the first
	41	* one. In most cases it is just an alternate mnemonic. */
	42	for (i = 0; i < spu_num_opcodes; i++)
	43	{
	44	int o = spu_opcodes[i].opcode;
	45	if (o >= (1 << 11))
	46	abort ();
	47	if (spu_disassemble_table[o] == 0)
	48	spu_disassemble_table[o] = &spu_opcodes[i];
	49	}
	50	}
	51
	52	/* Determine the instruction from the 10 least significant bits. */
	53	static const struct spu_opcode *
	54	get_index_for_opcode (unsigned int insn)
	55	{
	56	const struct spu_opcode *index;
	57	unsigned int opcode = insn >> (32-11);
	58
	59	/* Init the table. This assumes that element 0/opcode 0 (currently
	60	* NOP) is always used */
	61	if (spu_disassemble_table[0] == 0)
	62	init_spu_disassemble ();
	63
	64	if ((index = spu_disassemble_table[opcode & 0x780]) != 0
	65	&& index->insn_type == RRR)
	66	return index;
	67
	68	if ((index = spu_disassemble_table[opcode & 0x7f0]) != 0
	69	&& (index->insn_type == RI18 \|\| index->insn_type == LBT))
	70	return index;
	71
	72	if ((index = spu_disassemble_table[opcode & 0x7f8]) != 0
	73	&& index->insn_type == RI10)
	74	return index;
	75
	76	if ((index = spu_disassemble_table[opcode & 0x7fc]) != 0
	77	&& (index->insn_type == RI16))
	78	return index;
	79
	80	if ((index = spu_disassemble_table[opcode & 0x7fe]) != 0
	81	&& (index->insn_type == RI8))
	82	return index;
	83
	84	if ((index = spu_disassemble_table[opcode & 0x7ff]) != 0)
85	return index;
86
87	return 0;
88	}
89
90	/* Print a Spu instruction. */
91
92	int
93	print_insn_spu (bfd_vma memaddr, struct disassemble_info *info)
94	{
95	bfd_byte buffer[4];
96	int value;
97	int hex_value;
98	int status;
99	unsigned int insn;
100	const struct spu_opcode *index;
101	enum spu_insns tag;
102
103	status = (*info->read_memory_func) (memaddr, buffer, 4, info);
104	if (status != 0)
105	{
106	(*info->memory_error_func) (status, memaddr, info);
107	return -1;
108	}
109
110	insn = bfd_getb32 (buffer);
111
112	index = get_index_for_opcode (insn);
113
114	if (index == 0)
115	{
116	(*info->fprintf_func) (info->stream, ".long 0x%x", insn);
117	}
118	else
119	{
120	int i;
121	int paren = 0;
122	tag = (enum spu_insns)(index - spu_opcodes);
123	(*info->fprintf_func) (info->stream, "%s", index->mnemonic);
124	if (tag == M_BI \|\| tag == M_BISL \|\| tag == M_IRET \|\| tag == M_BISLED
125	\|\| tag == M_BIHNZ \|\| tag == M_BIHZ \|\| tag == M_BINZ \|\| tag == M_BIZ
126	\|\| tag == M_SYNC \|\| tag == M_HBR)
127	{
128	int fb = (insn >> (32-18)) & 0x7f;
129	if (fb & 0x40)
130	(*info->fprintf_func) (info->stream, tag == M_SYNC ? "c" : "p");
131	if (fb & 0x20)
132	(*info->fprintf_func) (info->stream, "d");
133	if (fb & 0x10)
134	(*info->fprintf_func) (info->stream, "e");
135	}
136	if (index->arg[0] != 0)
137	(*info->fprintf_func) (info->stream, "\t");
138	hex_value = 0;
139	for (i = 1; i <= index->arg[0]; i++)
140	{
141	int arg = index->arg[i];
142	if (arg != A_P && !paren && i > 1)
143	(*info->fprintf_func) (info->stream, ",");
144
145	switch (arg)
146	{
147	case A_T:
148	(*info->fprintf_func) (info->stream, "$%d",
149	DECODE_INSN_RT (insn));
150	break;
151	case A_A:
152	(*info->fprintf_func) (info->stream, "$%d",
153	DECODE_INSN_RA (insn));
154	break;
155	case A_B:
156	(*info->fprintf_func) (info->stream, "$%d",
157	DECODE_INSN_RB (insn));
158	break;
159	case A_C:
160	(*info->fprintf_func) (info->stream, "$%d",
161	DECODE_INSN_RC (insn));
162	break;
163	case A_S:
164	(*info->fprintf_func) (info->stream, "$sp%d",
165	DECODE_INSN_RA (insn));
166	break;
167	case A_H:
168	(*info->fprintf_func) (info->stream, "$ch%d",
169	DECODE_INSN_RA (insn));
170	break;
171	case A_P:
172	paren++;
173	(*info->fprintf_func) (info->stream, "(");
174	break;
175	case A_U7A:
176	(*info->fprintf_func) (info->stream, "%d",
177	173 - DECODE_INSN_U8 (insn));
178	break;
179	case A_U7B:
180	(*info->fprintf_func) (info->stream, "%d",
181	155 - DECODE_INSN_U8 (insn));
182	break;
183	case A_S3:
184	case A_S6:
185	case A_S7:
186	case A_S7N:
187	case A_U3:
188	case A_U5:
189	case A_U6:
190	case A_U7:
191	hex_value = DECODE_INSN_I7 (insn);
192	(*info->fprintf_func) (info->stream, "%d", hex_value);
193	break;
194	case A_S11:
195	(info->print_address_func) (memaddr + DECODE_INSN_I9a (insn) 4,
196	info);
197	break;
198	case A_S11I:
199	(info->print_address_func) (memaddr + DECODE_INSN_I9b (insn) 4,
200	info);
201	break;
202	case A_S10:
203	case A_S10B:
204	hex_value = DECODE_INSN_I10 (insn);
205	(*info->fprintf_func) (info->stream, "%d", hex_value);
206	break;
207	case A_S14:
208	hex_value = DECODE_INSN_I10 (insn) * 16;
209	(*info->fprintf_func) (info->stream, "%d", hex_value);
210	break;
211	case A_S16:
212	hex_value = DECODE_INSN_I16 (insn);
213	(*info->fprintf_func) (info->stream, "%d", hex_value);
214	break;
215	case A_X16:
216	hex_value = DECODE_INSN_U16 (insn);
217	(*info->fprintf_func) (info->stream, "%u", hex_value);
218	break;
219	case A_R18:
220	value = DECODE_INSN_I16 (insn) * 4;
221	if (value == 0)
222	(*info->fprintf_func) (info->stream, "%d", value);
223	else
224	{
225	hex_value = memaddr + value;
226	(*info->print_address_func) (hex_value & 0x3ffff, info);
227	}
228	break;
229	case A_S18:
230	value = DECODE_INSN_U16 (insn) * 4;
231	if (value == 0)
232	(*info->fprintf_func) (info->stream, "%d", value);
233	else
234	(*info->print_address_func) (value, info);
235	break;
236	case A_U18:
237	value = DECODE_INSN_U18 (insn);
238	if (value == 0 \|\| !(*info->symbol_at_address_func)(0, info))
239	{
240	hex_value = value;
241	(*info->fprintf_func) (info->stream, "%u", value);
242	}
243	else
244	(*info->print_address_func) (value, info);
245	break;
246	case A_U14:
247	hex_value = DECODE_INSN_U14 (insn);
248	(*info->fprintf_func) (info->stream, "%u", hex_value);
249	break;
250	}
251	if (arg != A_P && paren)
252	{
253	(*info->fprintf_func) (info->stream, ")");
254	paren--;
255	}
256	}
257	if (hex_value > 16)
258	(*info->fprintf_func) (info->stream, "\t# %x", hex_value);
259	}
260	return 4;
261	}