OpenCores
URL https://opencores.org/ocsvn/open8_urisc/open8_urisc/trunk

Subversion Repositories open8_urisc

[/] [open8_urisc/] [trunk/] [gnu/] [binutils/] [opcodes/] [tilepro-dis.c] - Blame information for rev 299

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 148 khays
/* tilepro-dis.c.  Disassembly routines for the TILEPro architecture.
2
   Copyright 2011 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 <stddef.h>
22
#include <assert.h>
23
#include "bfd.h"
24
#include "elf/tilepro.h"
25
#include "elf-bfd.h"
26
#include "sysdep.h"
27
#include "dis-asm.h"
28
#include "opcode/tilepro.h"
29
 
30
 
31
#define TREG_ZERO 63
32
 
33
static int
34
contains_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
 
79
int
80
print_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
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.