1/* tilepro-dis.c.  Disassembly routines for the TILEPro architecture.
2   Copyright (C) 2011-2017 Free Software Foundation, Inc.
3
4   This file is part of the GNU opcodes library.
5
6   This program is free software; you can redistribute it and/or modify
7   it under the terms of the GNU General Public License as published by
8   the Free Software Foundation; either version 3 of the License, or
9   (at your option) any later version.
10
11   This program is distributed in the hope that it will be useful,
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
17   along with this program; if not, write to the Free Software
18   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19   MA 02110-1301, USA.  */
20
21#include "sysdep.h"
22#include <stddef.h>
23#include <assert.h>
24#include "bfd.h"
25#include "elf/tilepro.h"
26#include "elf-bfd.h"
27#include "dis-asm.h"
28#include "opcode/tilepro.h"
29
30
31#define TREG_ZERO 63
32
33static int
34contains_insn (tilepro_mnemonic expected_mnemonic,
35	       int expected_first_operand,
36	       int expected_second_operand,
37	       bfd_vma memaddr,
38	       int *last_operand_ret,
39	       disassemble_info *info)
40{
41  struct tilepro_decoded_instruction
42    decoded[TILEPRO_MAX_INSTRUCTIONS_PER_BUNDLE];
43  bfd_byte opbuf[TILEPRO_BUNDLE_SIZE_IN_BYTES];
44  int i, num_instructions;
45
46  if ((*info->read_memory_func) (memaddr, opbuf,
47				 TILEPRO_BUNDLE_SIZE_IN_BYTES, info) != 0)
48    /* If we cannot even read the memory, it obviously does not have the
49       instruction for which we are looking. */
50    return 0;
51
52  /* Parse the instructions in the bundle. */
53  num_instructions = parse_insn_tilepro (bfd_getl64 (opbuf), memaddr, decoded);
54
55  for (i = 0; i < num_instructions; i++)
56    {
57      const struct tilepro_opcode *opcode = decoded[i].opcode;
58
59      if (opcode->mnemonic != expected_mnemonic)
60	continue;
61
62      if (expected_first_operand != -1
63	  && decoded[i].operand_values[0] != expected_first_operand)
64	continue;
65
66      if (expected_second_operand != -1
67	  && decoded[i].operand_values[1] != expected_second_operand)
68	continue;
69
70      *last_operand_ret = decoded[i].operand_values[opcode->num_operands - 1];
71      return 1;
72    }
73
74  /* No match. */
75  return 0;
76}
77
78
79int
80print_insn_tilepro (bfd_vma memaddr, disassemble_info *info)
81{
82  struct tilepro_decoded_instruction
83    decoded[TILEPRO_MAX_INSTRUCTIONS_PER_BUNDLE];
84  bfd_byte opbuf[TILEPRO_BUNDLE_SIZE_IN_BYTES];
85  int status, i, num_instructions, num_printed;
86  tilepro_mnemonic padding_mnemonic;
87
88  status = (*info->read_memory_func) (memaddr, opbuf,
89                                      TILEPRO_BUNDLE_SIZE_IN_BYTES, info);
90  if (status != 0)
91    {
92      (*info->memory_error_func) (status, memaddr, info);
93      return -1;
94    }
95
96  info->bytes_per_line = TILEPRO_BUNDLE_SIZE_IN_BYTES;
97  info->bytes_per_chunk = TILEPRO_BUNDLE_SIZE_IN_BYTES;
98  info->octets_per_byte = 1;
99  info->display_endian = BFD_ENDIAN_LITTLE;
100
101  /* Parse the instructions in the bundle.  */
102  num_instructions = parse_insn_tilepro (bfd_getl64 (opbuf), memaddr, decoded);
103
104  /* Print the instructions in the bundle.  */
105  info->fprintf_func (info->stream, "{ ");
106  num_printed = 0;
107
108  /* Determine which nop opcode is used for padding and should be skipped.  */
109  padding_mnemonic = TILEPRO_OPC_FNOP;
110  for (i = 0; i < num_instructions; i++)
111    {
112      if (!decoded[i].opcode->can_bundle)
113	{
114	  /* Instructions that cannot be bundled are padded out with nops,
115	     rather than fnops. Displaying them is always clutter.  */
116	  padding_mnemonic = TILEPRO_OPC_NOP;
117	  break;
118	}
119    }
120
121  for (i = 0; i < num_instructions; i++)
122    {
123      const struct tilepro_opcode *opcode = decoded[i].opcode;
124      const char *name;
125      int j;
126
127      /* Do not print out fnops, unless everything is an fnop, in
128	 which case we will print out just the last one.  */
129      if (opcode->mnemonic == padding_mnemonic
130	  && (num_printed > 0 || i + 1 < num_instructions))
131	continue;
132
133      if (num_printed > 0)
134	info->fprintf_func (info->stream, " ; ");
135      ++num_printed;
136
137      name = opcode->name;
138      if (name == NULL)
139	name = "<invalid>";
140      info->fprintf_func (info->stream, "%s", name);
141
142      for (j = 0; j < opcode->num_operands; j++)
143	{
144	  int num;
145	  const struct tilepro_operand *op;
146	  const char *spr_name;
147
148	  if (j > 0)
149	    info->fprintf_func (info->stream, ",");
150	  info->fprintf_func (info->stream, " ");
151
152	  num = decoded[i].operand_values[j];
153
154	  op = decoded[i].operands[j];
155	  switch (op->type)
156	    {
157	    case TILEPRO_OP_TYPE_REGISTER:
158	      info->fprintf_func (info->stream, "%s",
159				  tilepro_register_names[num]);
160	      break;
161
162	    case TILEPRO_OP_TYPE_SPR:
163	      spr_name = get_tilepro_spr_name(num);
164	      if (spr_name != NULL)
165		info->fprintf_func (info->stream, "%s", spr_name);
166	      else
167		info->fprintf_func (info->stream, "%d", num);
168	      break;
169
170	    case TILEPRO_OP_TYPE_IMMEDIATE:
171	      {
172		bfd_vma addr = 0;
173		int found_addr = 0;
174		int addr_piece;
175
176		switch (opcode->mnemonic)
177		  {
178		  case TILEPRO_OPC_ADDLI:
179		    if (contains_insn (TILEPRO_OPC_AULI,
180				       decoded[i].operand_values[1],
181				       TREG_ZERO,
182				       memaddr - TILEPRO_BUNDLE_SIZE_IN_BYTES,
183				       &addr_piece,
184				       info))
185		      {
186			addr = num + (addr_piece << 16);
187			found_addr = 1;
188		      }
189		    break;
190
191		  case TILEPRO_OPC_AULI:
192		    if (contains_insn (TILEPRO_OPC_MOVELI,
193				       decoded[i].operand_values[1],
194				       -1,
195				       memaddr - TILEPRO_BUNDLE_SIZE_IN_BYTES,
196				       &addr_piece,
197				       info))
198		      {
199			addr = (num << 16) + addr_piece;
200			found_addr = 1;
201		      }
202		    break;
203
204		  default:
205		    /* Operand does not look like a constructed address.  */
206		    break;
207		  }
208
209		info->fprintf_func (info->stream, "%d", num);
210
211		if (found_addr)
212		  {
213		    info->fprintf_func (info->stream, " /* ");
214		    info->print_address_func (addr, info);
215		    info->fprintf_func (info->stream, " */");
216		  }
217	      }
218	      break;
219
220	    case TILEPRO_OP_TYPE_ADDRESS:
221	      info->print_address_func ((bfd_vma)(unsigned int) num, info);
222	      break;
223
224	    default:
225	      abort ();
226	    }
227	}
228    }
229  info->fprintf_func (info->stream, " }");
230
231  return TILEPRO_BUNDLE_SIZE_IN_BYTES;
232}
233