opcodes/tilepro-dis.c

   1 /* tilepro-dis.c.  Disassembly routines for the TILEPro architecture.
   2    Copyright (C) 2011-2024 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 "disassemble.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 }