opcodes/d30v-dis.c

   1 /* Disassemble D30V instructions.
   2    Copyright (C) 1997-2019 Free Software Foundation, Inc.
   3
   4    This file is part of the GNU opcodes library.
   5
   6    This library 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, or (at your option)
   9    any later version.
  10
  11    It is distributed in the hope that it will be useful, but WITHOUT
  12    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  13    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
  14    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 <stdio.h>
  23 #include "opcode/d30v.h"
  24 #include "disassemble.h"
  25 #include "opintl.h"
  26 #include "libiberty.h"
  27
  28 #define PC_MASK 0xFFFFFFFF
  29
  30 /* Return 0 if lookup fails,
  31    1 if found and only one form,
  32    2 if found and there are short and long forms.  */
  33
  34 static int
  35 lookup_opcode (struct d30v_insn *insn, long num, int is_long)
  36 {
  37   int i = 0, op_index;
  38   struct d30v_format *f;
  39   struct d30v_opcode *op = (struct d30v_opcode *) d30v_opcode_table;
  40   int op1 = (num >> 25) & 0x7;
  41   int op2 = (num >> 20) & 0x1f;
  42   int mod = (num >> 18) & 0x3;
  43
  44   /* Find the opcode.  */
  45   do
  46     {
  47       if ((op->op1 == op1) && (op->op2 == op2))
  48         break;
  49       op++;
  50     }
  51   while (op->name);
  52
  53   if (!op || !op->name)
  54     return 0;
  55
  56   while (op->op1 == op1 && op->op2 == op2)
  57     {
  58       /* Scan through all the formats for the opcode.  */
  59       op_index = op->format[i++];
  60       do
  61         {
  62           f = (struct d30v_format *) &d30v_format_table[op_index];
  63           while (f->form == op_index)
  64             {
  65               if ((!is_long || f->form >= LONG) && (f->modifier == mod))
  66                 {
  67                   insn->form = f;
  68                   break;
  69                 }
  70               f++;
  71             }
  72           if (insn->form)
  73             break;
  74         }
  75       while ((op_index = op->format[i++]) != 0);
  76       if (insn->form)
  77         break;
  78       op++;
  79       i = 0;
  80     }
  81   if (insn->form == NULL)
  82     return 0;
  83
  84   insn->op = op;
  85   insn->ecc = (num >> 28) & 0x7;
  86   if (op->format[1])
  87     return 2;
  88   else
  89     return 1;
  90 }
  91
  92 static int
  93 extract_value (long long num, struct d30v_operand *oper, int is_long)
  94 {
  95   int val;
  96   int shift = 12 - oper->position;
  97   int mask = (0xFFFFFFFF >> (32 - oper->bits));
  98
  99   if (is_long)
 100     {
 101       if (oper->bits == 32)
 102         /* Piece together 32-bit constant.  */
 103         val = ((num & 0x3FFFF)
 104                | ((num & 0xFF00000) >> 2)
 105                | ((num & 0x3F00000000LL) >> 6));
 106       else
 107         val = (num >> (32 + shift)) & mask;
 108     }
 109   else
 110     val = (num >> shift) & mask;
 111
 112   if (oper->flags & OPERAND_SHIFT)
 113     val <<= 3;
 114
 115   return val;
 116 }
 117
 118 static void
 119 print_insn (struct disassemble_info *info,
 120             bfd_vma memaddr,
 121             long long num,
 122             struct d30v_insn *insn,
 123             int is_long,
 124             int show_ext)
 125 {
 126   int val, opnum, need_comma = 0;
 127   struct d30v_operand *oper;
 128   int i, match, need_paren = 0, found_control = 0;
 129   unsigned int opind = 0;
 130
 131   (*info->fprintf_func) (info->stream, "%s", insn->op->name);
 132
 133   /* Check for CMP or CMPU.  */
 134   if (d30v_operand_table[insn->form->operands[0]].flags & OPERAND_NAME)
 135     {
 136       opind++;
 137       val =
 138         extract_value (num,
 139                        (struct d30v_operand *) &d30v_operand_table[insn->form->operands[0]],
 140                        is_long);
 141       (*info->fprintf_func) (info->stream, "%s", d30v_cc_names[val]);
 142     }
 143
 144   /* Add in ".s" or ".l".  */
 145   if (show_ext == 2)
 146     {
 147       if (is_long)
 148         (*info->fprintf_func) (info->stream, ".l");
 149       else
 150         (*info->fprintf_func) (info->stream, ".s");
 151     }
 152
 153   if (insn->ecc)
 154     (*info->fprintf_func) (info->stream, "/%s", d30v_ecc_names[insn->ecc]);
 155
 156   (*info->fprintf_func) (info->stream, "\t");
 157
 158   while (opind < ARRAY_SIZE (insn->form->operands)
 159          && (opnum = insn->form->operands[opind++]) != 0)
 160     {
 161       int bits;
 162
 163       oper = (struct d30v_operand *) &d30v_operand_table[opnum];
 164       bits = oper->bits;
 165       if (oper->flags & OPERAND_SHIFT)
 166         bits += 3;
 167
 168       if (need_comma
 169           && oper->flags != OPERAND_PLUS
 170           && oper->flags != OPERAND_MINUS)
 171         {
 172           need_comma = 0;
 173           (*info->fprintf_func) (info->stream, ", ");
 174         }
 175
 176       if (oper->flags == OPERAND_ATMINUS)
 177         {
 178           (*info->fprintf_func) (info->stream, "@-");
 179           continue;
 180         }
 181       if (oper->flags == OPERAND_MINUS)
 182         {
 183           (*info->fprintf_func) (info->stream, "-");
 184           continue;
 185         }
 186       if (oper->flags == OPERAND_PLUS)
 187         {
 188           (*info->fprintf_func) (info->stream, "+");
 189           continue;
 190         }
 191       if (oper->flags == OPERAND_ATSIGN)
 192         {
 193           (*info->fprintf_func) (info->stream, "@");
 194           continue;
 195         }
 196       if (oper->flags == OPERAND_ATPAR)
 197         {
 198           (*info->fprintf_func) (info->stream, "@(");
 199           need_paren = 1;
 200           continue;
 201         }
 202
 203       if (oper->flags == OPERAND_SPECIAL)
 204         continue;
 205
 206       val = extract_value (num, oper, is_long);
 207
 208       if (oper->flags & OPERAND_REG)
 209         {
 210           match = 0;
 211           if (oper->flags & OPERAND_CONTROL)
 212             {
 213               struct d30v_operand *oper3 =
 214                 (struct d30v_operand *) &d30v_operand_table[insn->form->operands[2]];
 215               int id = extract_value (num, oper3, is_long);
 216
 217               found_control = 1;
 218               switch (id)
 219                 {
 220                 case 0:
 221                   val |= OPERAND_CONTROL;
 222                   break;
 223                 case 1:
 224                 case 2:
 225                   val = OPERAND_CONTROL + MAX_CONTROL_REG + id;
 226                   break;
 227                 case 3:
 228                   val |= OPERAND_FLAG;
 229                   break;
 230                 default:
 231                   /* xgettext: c-format */
 232                   opcodes_error_handler (_("illegal id (%d)"), id);
 233                   abort ();
 234                 }
 235             }
 236           else if (oper->flags & OPERAND_ACC)
 237             val |= OPERAND_ACC;
 238           else if (oper->flags & OPERAND_FLAG)
 239             val |= OPERAND_FLAG;
 240           for (i = 0; i < reg_name_cnt (); i++)
 241             {
 242               if (val == pre_defined_registers[i].value)
 243                 {
 244                   if (pre_defined_registers[i].pname)
 245                     (*info->fprintf_func)
 246                       (info->stream, "%s", pre_defined_registers[i].pname);
 247                   else
 248                     (*info->fprintf_func)
 249                       (info->stream, "%s", pre_defined_registers[i].name);
 250                   match = 1;
 251                   break;
 252                 }
 253             }
 254           if (match == 0)
 255             {
 256               /* This would only get executed if a register was not in
 257                  the register table.  */
 258               (*info->fprintf_func)
 259                 (info->stream, _("<unknown register %d>"), val & 0x3F);
 260             }
 261         }
 262       /* repeati has a relocation, but its first argument is a plain
 263          immediate.  OTOH instructions like djsri have a pc-relative
 264          delay target, but an absolute jump target.  Therefore, a test
 265          of insn->op->reloc_flag is not specific enough; we must test
 266          if the actual operand we are handling now is pc-relative.  */
 267       else if (oper->flags & OPERAND_PCREL)
 268         {
 269           int neg = 0;
 270
 271           /* IMM6S3 is unsigned.  */
 272           if (oper->flags & OPERAND_SIGNED || bits == 32)
 273             {
 274               long max;
 275               max = (1 << (bits - 1));
 276               if (val & max)
 277                 {
 278                   if (bits == 32)
 279                     val = -val;
 280                   else
 281                     val = -val & ((1 << bits) - 1);
 282                   neg = 1;
 283                 }
 284             }
 285           if (neg)
 286             {
 287               (*info->fprintf_func) (info->stream, "-%x\t(", val);
 288               (*info->print_address_func) ((memaddr - val) & PC_MASK, info);
 289               (*info->fprintf_func) (info->stream, ")");
 290             }
 291           else
 292             {
 293               (*info->fprintf_func) (info->stream, "%x\t(", val);
 294               (*info->print_address_func) ((memaddr + val) & PC_MASK, info);
 295               (*info->fprintf_func) (info->stream, ")");
 296             }
 297         }
 298       else if (insn->op->reloc_flag == RELOC_ABS)
 299         {
 300           (*info->print_address_func) (val, info);
 301         }
 302       else
 303         {
 304           if (oper->flags & OPERAND_SIGNED)
 305             {
 306               int max = (1 << (bits - 1));
 307
 308               if (val & max)
 309                 {
 310                   val = -val;
 311                   if (bits < 32)
 312                     val &= ((1 << bits) - 1);
 313                   (*info->fprintf_func) (info->stream, "-");
 314                 }
 315             }
 316           (*info->fprintf_func) (info->stream, "0x%x", val);
 317         }
 318       /* If there is another operand, then write a comma and space.  */
 319       if (opind < ARRAY_SIZE (insn->form->operands)
 320           && insn->form->operands[opind]
 321           && !(found_control && opind == 2))
 322         need_comma = 1;
 323     }
 324   if (need_paren)
 325     (*info->fprintf_func) (info->stream, ")");
 326 }
 327
 328 int
 329 print_insn_d30v (bfd_vma memaddr, struct disassemble_info *info)
 330 {
 331   int status, result;
 332   bfd_byte buffer[12];
 333   unsigned long in1, in2;
 334   struct d30v_insn insn;
 335   long long num;
 336
 337   insn.form = NULL;
 338
 339   info->bytes_per_line = 8;
 340   info->bytes_per_chunk = 4;
 341   info->display_endian = BFD_ENDIAN_BIG;
 342
 343   status = (*info->read_memory_func) (memaddr, buffer, 4, info);
 344   if (status != 0)
 345     {
 346       (*info->memory_error_func) (status, memaddr, info);
 347       return -1;
 348     }
 349   in1 = bfd_getb32 (buffer);
 350
 351   status = (*info->read_memory_func) (memaddr + 4, buffer, 4, info);
 352   if (status != 0)
 353     {
 354       info->bytes_per_line = 8;
 355       if (!(result = lookup_opcode (&insn, in1, 0)))
 356         (*info->fprintf_func) (info->stream, ".long\t0x%lx", in1);
 357       else
 358         print_insn (info, memaddr, (long long) in1, &insn, 0, result);
 359       return 4;
 360     }
 361   in2 = bfd_getb32 (buffer);
 362
 363   if (in1 & in2 & FM01)
 364     {
 365       /* LONG instruction.  */
 366       if (!(result = lookup_opcode (&insn, in1, 1)))
 367         {
 368           (*info->fprintf_func) (info->stream, ".long\t0x%lx,0x%lx", in1, in2);
 369           return 8;
 370         }
 371       num = (long long) in1 << 32 | in2;
 372       print_insn (info, memaddr, num, &insn, 1, result);
 373     }
 374   else
 375     {
 376       num = in1;
 377       if (!(result = lookup_opcode (&insn, in1, 0)))
 378         (*info->fprintf_func) (info->stream, ".long\t0x%lx", in1);
 379       else
 380         print_insn (info, memaddr, num, &insn, 0, result);
 381
 382       switch (((in1 >> 31) << 1) | (in2 >> 31))
 383         {
 384         case 0:
 385           (*info->fprintf_func) (info->stream, "\t||\t");
 386           break;
 387         case 1:
 388           (*info->fprintf_func) (info->stream, "\t->\t");
 389           break;
 390         case 2:
 391           (*info->fprintf_func) (info->stream, "\t<-\t");
 392         default:
 393           break;
 394         }
 395
 396       insn.form = NULL;
 397       num = in2;
 398       if (!(result = lookup_opcode (&insn, in2, 0)))
 399         (*info->fprintf_func) (info->stream, ".long\t0x%lx", in2);
 400       else
 401         print_insn (info, memaddr, num, &insn, 0, result);
 402     }
 403   return 8;
 404 }