opcodes/xtensa-dis.c

   1 /* xtensa-dis.c.  Disassembly functions for Xtensa.
   2    Copyright (C) 2003-2018 Free Software Foundation, Inc.
   3    Contributed by Bob Wilson at Tensilica, Inc. (bwilson@tensilica.com)
   4
   5    This file is part of the GNU opcodes library.
   6
   7    This library 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 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.  */
  21
  22 #include "sysdep.h"
  23 #include <stdlib.h>
  24 #include <stdio.h>
  25 #include <sys/types.h>
  26 #include <string.h>
  27 #include "xtensa-isa.h"
  28 #include "ansidecl.h"
  29 #include "libiberty.h"
  30 #include "bfd.h"
  31 #include "elf/xtensa.h"
  32 #include "disassemble.h"
  33
  34 #include <setjmp.h>
  35
  36 extern xtensa_isa xtensa_default_isa;
  37
  38 #ifndef MAX
  39 #define MAX(a,b) (a > b ? a : b)
  40 #endif
  41
  42 int show_raw_fields;
  43
  44 struct dis_private
  45 {
  46   bfd_byte *byte_buf;
  47   OPCODES_SIGJMP_BUF bailout;
  48   /* Persistent fields, valid for last_section only.  */
  49   asection *last_section;
  50   property_table_entry *insn_table_entries;
  51   int insn_table_entry_count;
  52   /* Cached property table search position.  */
  53   bfd_vma insn_table_cur_addr;
  54   int insn_table_cur_idx;
  55 };
  56
  57 static void
  58 xtensa_coalesce_insn_tables (struct dis_private *priv)
  59 {
  60   const int mask = ~(XTENSA_PROP_DATA | XTENSA_PROP_NO_TRANSFORM);
  61   int count = priv->insn_table_entry_count;
  62   int i, j;
  63
  64   /* Loop over all entries, combining adjacent ones that differ only in
  65      the flag bits XTENSA_PROP_DATA and XTENSA_PROP_NO_TRANSFORM.  */
  66
  67   for (i = j = 0; j < count; ++i)
  68     {
  69       property_table_entry *entry = priv->insn_table_entries + i;
  70
  71       *entry = priv->insn_table_entries[j];
  72
  73       for (++j; j < count; ++j)
  74         {
  75           property_table_entry *next = priv->insn_table_entries + j;
  76           int fill = xtensa_compute_fill_extra_space (entry);
  77           int size = entry->size + fill;
  78
  79           if (entry->address + size == next->address)
  80             {
  81               int entry_flags = entry->flags & mask;
  82               int next_flags = next->flags & mask;
  83
  84               if (next_flags == entry_flags)
  85                 entry->size = next->address - entry->address + next->size;
  86               else
  87                 break;
  88             }
  89           else
  90             {
  91               break;
  92             }
  93         }
  94     }
  95   priv->insn_table_entry_count = i;
  96 }
  97
  98 static property_table_entry *
  99 xtensa_find_table_entry (bfd_vma memaddr, struct disassemble_info *info)
 100 {
 101   struct dis_private *priv = (struct dis_private *) info->private_data;
 102   int i;
 103
 104   if (priv->insn_table_entries == NULL
 105       || priv->insn_table_entry_count < 0)
 106     return NULL;
 107
 108   if (memaddr < priv->insn_table_cur_addr)
 109     priv->insn_table_cur_idx = 0;
 110
 111   for (i = priv->insn_table_cur_idx; i < priv->insn_table_entry_count; ++i)
 112     {
 113       property_table_entry *block = priv->insn_table_entries + i;
 114
 115       if (block->size != 0)
 116         {
 117           if ((memaddr >= block->address
 118                && memaddr < block->address + block->size)
 119               || memaddr < block->address)
 120             {
 121               priv->insn_table_cur_addr = memaddr;
 122               priv->insn_table_cur_idx = i;
 123               return block;
 124             }
 125         }
 126     }
 127   return NULL;
 128 }
 129
 130 /* Check whether an instruction crosses an instruction block boundary
 131    (according to property tables).
 132    If it does, return 0 (doesn't fit), else return 1.  */
 133
 134 static int
 135 xtensa_instruction_fits (bfd_vma memaddr, int size,
 136                          property_table_entry *insn_block)
 137 {
 138   unsigned max_size;
 139
 140   /* If no property table info, assume it fits.  */
 141   if (insn_block == NULL || size <= 0)
 142     return 1;
 143
 144   /* If too high, limit nextstop by the next insn address.  */
 145   if (insn_block->address > memaddr)
 146     {
 147       /* memaddr is not in an instruction block, but is followed by one.  */
 148       max_size = insn_block->address - memaddr;
 149     }
 150   else
 151     {
 152       /* memaddr is in an instruction block, go no further than the end.  */
 153       max_size = insn_block->address + insn_block->size - memaddr;
 154     }
 155
 156   /* Crossing a boundary, doesn't "fit".  */
 157   if ((unsigned)size > max_size)
 158     return 0;
 159   return 1;
 160 }
 161
 162 static int
 163 fetch_data (struct disassemble_info *info, bfd_vma memaddr)
 164 {
 165   int length, status = 0;
 166   struct dis_private *priv = (struct dis_private *) info->private_data;
 167   int insn_size = xtensa_isa_maxlength (xtensa_default_isa);
 168
 169   insn_size = MAX (insn_size, 4);
 170
 171   /* Read the maximum instruction size, padding with zeros if we go past
 172      the end of the text section.  This code will automatically adjust
 173      length when we hit the end of the buffer.  */
 174
 175   memset (priv->byte_buf, 0, insn_size);
 176   for (length = insn_size; length > 0; length--)
 177     {
 178       status = (*info->read_memory_func) (memaddr, priv->byte_buf, length,
 179                                           info);
 180       if (status == 0)
 181         return length;
 182     }
 183   (*info->memory_error_func) (status, memaddr, info);
 184   OPCODES_SIGLONGJMP (priv->bailout, 1);
 185   /*NOTREACHED*/
 186 }
 187
 188
 189 static void
 190 print_xtensa_operand (bfd_vma memaddr,
 191                       struct disassemble_info *info,
 192                       xtensa_opcode opc,
 193                       int opnd,
 194                       unsigned operand_val)
 195 {
 196   xtensa_isa isa = xtensa_default_isa;
 197   int signed_operand_val;
 198
 199   if (show_raw_fields)
 200     {
 201       if (operand_val < 0xa)
 202         (*info->fprintf_func) (info->stream, "%u", operand_val);
 203       else
 204         (*info->fprintf_func) (info->stream, "0x%x", operand_val);
 205       return;
 206     }
 207
 208   (void) xtensa_operand_decode (isa, opc, opnd, &operand_val);
 209   signed_operand_val = (int) operand_val;
 210
 211   if (xtensa_operand_is_register (isa, opc, opnd) == 0)
 212     {
 213       if (xtensa_operand_is_PCrelative (isa, opc, opnd) == 1)
 214         {
 215           (void) xtensa_operand_undo_reloc (isa, opc, opnd,
 216                                             &operand_val, memaddr);
 217           info->target = operand_val;
 218           (*info->print_address_func) (info->target, info);
 219         }
 220       else
 221         {
 222           if ((signed_operand_val > -256) && (signed_operand_val < 256))
 223             (*info->fprintf_func) (info->stream, "%d", signed_operand_val);
 224           else
 225             (*info->fprintf_func) (info->stream, "0x%x", signed_operand_val);
 226         }
 227     }
 228   else
 229     {
 230       int i = 1;
 231       xtensa_regfile opnd_rf = xtensa_operand_regfile (isa, opc, opnd);
 232       (*info->fprintf_func) (info->stream, "%s%u",
 233                              xtensa_regfile_shortname (isa, opnd_rf),
 234                              operand_val);
 235       while (i < xtensa_operand_num_regs (isa, opc, opnd))
 236         {
 237           operand_val++;
 238           (*info->fprintf_func) (info->stream, ":%s%u",
 239                                  xtensa_regfile_shortname (isa, opnd_rf),
 240                                  operand_val);
 241           i++;
 242         }
 243     }
 244 }
 245
 246
 247 /* Print the Xtensa instruction at address MEMADDR on info->stream.
 248    Returns length of the instruction in bytes.  */
 249
 250 int
 251 print_insn_xtensa (bfd_vma memaddr, struct disassemble_info *info)
 252 {
 253   unsigned operand_val;
 254   int bytes_fetched, size, maxsize, i, n, noperands, nslots;
 255   xtensa_isa isa;
 256   xtensa_opcode opc;
 257   xtensa_format fmt;
 258   static struct dis_private priv;
 259   static bfd_byte *byte_buf = NULL;
 260   static xtensa_insnbuf insn_buffer = NULL;
 261   static xtensa_insnbuf slot_buffer = NULL;
 262   int first, first_slot, valid_insn = 0;
 263   property_table_entry *insn_block;
 264
 265   if (!xtensa_default_isa)
 266     xtensa_default_isa = xtensa_isa_init (0, 0);
 267
 268   info->target = 0;
 269   maxsize = xtensa_isa_maxlength (xtensa_default_isa);
 270
 271   /* Set bytes_per_line to control the amount of whitespace between the hex
 272      values and the opcode.  For Xtensa, we always print one "chunk" and we
 273      vary bytes_per_chunk to determine how many bytes to print.  (objdump
 274      would apparently prefer that we set bytes_per_chunk to 1 and vary
 275      bytes_per_line but that makes it hard to fit 64-bit instructions on
 276      an 80-column screen.)  The value of bytes_per_line here is not exactly
 277      right, because objdump adds an extra space for each chunk so that the
 278      amount of whitespace depends on the chunk size.  Oh well, it's good
 279      enough....  Note that we set the minimum size to 4 to accomodate
 280      literal pools.  */
 281   info->bytes_per_line = MAX (maxsize, 4);
 282
 283   /* Allocate buffers the first time through.  */
 284   if (!insn_buffer)
 285     {
 286       insn_buffer = xtensa_insnbuf_alloc (xtensa_default_isa);
 287       slot_buffer = xtensa_insnbuf_alloc (xtensa_default_isa);
 288       byte_buf = (bfd_byte *) xmalloc (MAX (maxsize, 4));
 289     }
 290
 291   priv.byte_buf = byte_buf;
 292
 293   info->private_data = (void *) &priv;
 294
 295   /* Prepare instruction tables.  */
 296
 297   if (info->section != NULL)
 298     {
 299       asection *section = info->section;
 300
 301       if (priv.last_section != section)
 302         {
 303           bfd *abfd = section->owner;
 304
 305           if (priv.last_section != NULL)
 306             {
 307               /* Reset insn_table_entries.  */
 308               priv.insn_table_entry_count = 0;
 309               if (priv.insn_table_entries)
 310                 free (priv.insn_table_entries);
 311               priv.insn_table_entries = NULL;
 312             }
 313           priv.last_section = section;
 314
 315           /* Read insn_table_entries.  */
 316           priv.insn_table_entry_count =
 317             xtensa_read_table_entries (abfd, section,
 318                                        &priv.insn_table_entries,
 319                                        XTENSA_PROP_SEC_NAME, FALSE);
 320           if (priv.insn_table_entry_count == 0)
 321             {
 322               if (priv.insn_table_entries)
 323                 free (priv.insn_table_entries);
 324               priv.insn_table_entries = NULL;
 325               /* Backwards compatibility support.  */
 326               priv.insn_table_entry_count =
 327                 xtensa_read_table_entries (abfd, section,
 328                                            &priv.insn_table_entries,
 329                                            XTENSA_INSN_SEC_NAME, FALSE);
 330             }
 331           priv.insn_table_cur_idx = 0;
 332           xtensa_coalesce_insn_tables (&priv);
 333         }
 334       /* Else nothing to do, same section as last time.  */
 335     }
 336
 337   if (OPCODES_SIGSETJMP (priv.bailout) != 0)
 338       /* Error return.  */
 339       return -1;
 340
 341   /* Don't set "isa" before the setjmp to keep the compiler from griping.  */
 342   isa = xtensa_default_isa;
 343   size = 0;
 344   nslots = 0;
 345
 346   /* Fetch the maximum size instruction.  */
 347   bytes_fetched = fetch_data (info, memaddr);
 348
 349   insn_block = xtensa_find_table_entry (memaddr, info);
 350
 351   if (!insn_block || (insn_block->flags & XTENSA_PROP_INSN))
 352     {
 353       /* Copy the bytes into the decode buffer.  */
 354       memset (insn_buffer, 0, (xtensa_insnbuf_size (isa) *
 355                                sizeof (xtensa_insnbuf_word)));
 356       xtensa_insnbuf_from_chars (isa, insn_buffer, priv.byte_buf,
 357                                  bytes_fetched);
 358
 359       fmt = xtensa_format_decode (isa, insn_buffer);
 360       if (fmt != XTENSA_UNDEFINED
 361           && ((size = xtensa_format_length (isa, fmt)) <= bytes_fetched)
 362           && xtensa_instruction_fits (memaddr, size, insn_block))
 363         {
 364           /* Make sure all the opcodes are valid.  */
 365           valid_insn = 1;
 366           nslots = xtensa_format_num_slots (isa, fmt);
 367           for (n = 0; n < nslots; n++)
 368             {
 369               xtensa_format_get_slot (isa, fmt, n, insn_buffer, slot_buffer);
 370               if (xtensa_opcode_decode (isa, fmt, n, slot_buffer)
 371                   == XTENSA_UNDEFINED)
 372                 {
 373                   valid_insn = 0;
 374                   break;
 375                 }
 376             }
 377         }
 378     }
 379
 380   if (!valid_insn)
 381     {
 382       if (insn_block && (insn_block->flags & XTENSA_PROP_LITERAL)
 383           && (memaddr & 3) == 0 && bytes_fetched >= 4)
 384         {
 385           return 4;
 386         }
 387       else
 388         {
 389           (*info->fprintf_func) (info->stream, ".byte %#02x", priv.byte_buf[0]);
 390           return 1;
 391         }
 392     }
 393
 394   if (nslots > 1)
 395     (*info->fprintf_func) (info->stream, "{ ");
 396
 397   first_slot = 1;
 398   for (n = 0; n < nslots; n++)
 399     {
 400       if (first_slot)
 401         first_slot = 0;
 402       else
 403         (*info->fprintf_func) (info->stream, "; ");
 404
 405       xtensa_format_get_slot (isa, fmt, n, insn_buffer, slot_buffer);
 406       opc = xtensa_opcode_decode (isa, fmt, n, slot_buffer);
 407       (*info->fprintf_func) (info->stream, "%s",
 408                              xtensa_opcode_name (isa, opc));
 409
 410       /* Print the operands (if any).  */
 411       noperands = xtensa_opcode_num_operands (isa, opc);
 412       first = 1;
 413       for (i = 0; i < noperands; i++)
 414         {
 415           if (xtensa_operand_is_visible (isa, opc, i) == 0)
 416             continue;
 417           if (first)
 418             {
 419               (*info->fprintf_func) (info->stream, "\t");
 420               first = 0;
 421             }
 422           else
 423             (*info->fprintf_func) (info->stream, ", ");
 424           (void) xtensa_operand_get_field (isa, opc, i, fmt, n,
 425                                            slot_buffer, &operand_val);
 426
 427           print_xtensa_operand (memaddr, info, opc, i, operand_val);
 428         }
 429     }
 430
 431   if (nslots > 1)
 432     (*info->fprintf_func) (info->stream, " }");
 433
 434   info->bytes_per_chunk = size;
 435   info->display_endian = info->endian;
 436
 437   return size;
 438 }
 439