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

/* Disassemble SPU instructions

   Copyright 2006 Free Software Foundation, Inc.

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