gnu/dist/gdb6/opcodes/dlx-dis.c

   1 /* Instruction printing code for the DLX Microprocessor
   2    Copyright 2002, 2005 Free Software Foundation, Inc.
   3    Contributed by Kuang Hwa Lin.  Written by Kuang Hwa Lin, 03/2002.
   4
   5    This program is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 2 of the License, or
   8    (at your option) any later version.
   9
  10    This program is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program; if not, write to the Free Software
  17    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  18    MA 02110-1301, USA.  */
  19
  20 #include "sysdep.h"
  21 #include "dis-asm.h"
  22 #include "opcode/dlx.h"
  23
  24 #define R_ERROR     0x1
  25 #define R_TYPE      0x2
  26 #define ILD_TYPE    0x3
  27 #define IST_TYPE    0x4
  28 #define IAL_TYPE    0x5
  29 #define IBR_TYPE    0x6
  30 #define IJ_TYPE     0x7
  31 #define IJR_TYPE    0x8
  32 #define NIL         0x9
  33
  34 #define OPC(x)      ((x >> 26) & 0x3F)
  35 #define FUNC(x)     (x & 0x7FF)
  36
  37 unsigned char opc, rs1, rs2, rd;
  38 unsigned long imm26, imm16, func, current_insn_addr;
  39
  40 /* Print one instruction from MEMADDR on INFO->STREAM.
  41    Return the size of the instruction (always 4 on dlx).  */
  42
  43 static unsigned char
  44 dlx_get_opcode (unsigned long opcode)
  45 {
  46   return (unsigned char) ((opcode >> 26) & 0x3F);
  47 }
  48
  49 static unsigned char
  50 dlx_get_rs1 (unsigned long opcode)
  51 {
  52   return (unsigned char) ((opcode >> 21) & 0x1F);
  53 }
  54
  55 static unsigned char
  56 dlx_get_rs2 (unsigned long opcode)
  57 {
  58   return (unsigned char) ((opcode >> 16) & 0x1F);
  59 }
  60
  61 static unsigned char
  62 dlx_get_rdR (unsigned long opcode)
  63 {
  64   return (unsigned char) ((opcode >> 11) & 0x1F);
  65 }
  66
  67 static unsigned long
  68 dlx_get_func (unsigned long opcode)
  69 {
  70   return (unsigned char) (opcode & 0x7FF);
  71 }
  72
  73 static unsigned long
  74 dlx_get_imm16 (unsigned long opcode)
  75 {
  76   return (unsigned long) (opcode & 0xFFFF);
  77 }
  78
  79 static unsigned long
  80 dlx_get_imm26 (unsigned long opcode)
  81 {
  82   return (unsigned long) (opcode & 0x03FFFFFF);
  83 }
  84
  85 /* Fill the opcode to the max length.  */
  86
  87 static void
  88 operand_deliminator (struct disassemble_info *info, char *ptr)
  89 {
  90   int difft = 8 - (int) strlen (ptr);
  91
  92   while (difft > 0)
  93     {
  94       (*info->fprintf_func) (info->stream, "%c", ' ');
  95       difft -= 1;
  96     }
  97 }
  98
  99 /* Process the R-type opcode.  */
 100
 101 static unsigned char
 102 dlx_r_type (struct disassemble_info *info)
 103 {
 104   unsigned char r_opc[] = { OPC(ALUOP) }; /* Fix ME */
 105   int r_opc_num = (sizeof r_opc) / (sizeof (char));
 106   struct _r_opcode
 107   {
 108     unsigned long func;
 109     char *name;
 110   }
 111   dlx_r_opcode[] =
 112   {
 113     { NOPF,     "nop"    },  /* NOP                          */
 114     { ADDF,     "add"    },  /* Add                          */
 115     { ADDUF,    "addu"   },  /* Add Unsigned                 */
 116     { SUBF,     "sub"    },  /* SUB                          */
 117     { SUBUF,    "subu"   },  /* Sub Unsigned                 */
 118     { MULTF,    "mult"   },  /* MULTIPLY                     */
 119     { MULTUF,   "multu"  },  /* MULTIPLY Unsigned            */
 120     { DIVF,     "div"    },  /* DIVIDE                       */
 121     { DIVUF,    "divu"   },  /* DIVIDE Unsigned              */
 122     { ANDF,     "and"    },  /* AND                          */
 123     { ORF,      "or"     },  /* OR                           */
 124     { XORF,     "xor"    },  /* Exclusive OR                 */
 125     { SLLF,     "sll"    },  /* SHIFT LEFT LOGICAL           */
 126     { SRAF,     "sra"    },  /* SHIFT RIGHT ARITHMETIC       */
 127     { SRLF,     "srl"    },  /* SHIFT RIGHT LOGICAL          */
 128     { SEQF,     "seq"    },  /* Set if equal                 */
 129     { SNEF,     "sne"    },  /* Set if not equal             */
 130     { SLTF,     "slt"    },  /* Set if less                  */
 131     { SGTF,     "sgt"    },  /* Set if greater               */
 132     { SLEF,     "sle"    },  /* Set if less or equal         */
 133     { SGEF,     "sge"    },  /* Set if greater or equal      */
 134     { SEQUF,    "sequ"   },  /* Set if equal                 */
 135     { SNEUF,    "sneu"   },  /* Set if not equal             */
 136     { SLTUF,    "sltu"   },  /* Set if less                  */
 137     { SGTUF,    "sgtu"   },  /* Set if greater               */
 138     { SLEUF,    "sleu"   },  /* Set if less or equal         */
 139     { SGEUF,    "sgeu"   },  /* Set if greater or equal      */
 140     { MVTSF,    "mvts"   },  /* Move to special register     */
 141     { MVFSF,    "mvfs"   },  /* Move from special register   */
 142     { BSWAPF,   "bswap"  },  /* Byte swap ??                 */
 143     { LUTF,     "lut"    }   /* ????????? ??                 */
 144   };
 145   int dlx_r_opcode_num = (sizeof dlx_r_opcode) / (sizeof dlx_r_opcode[0]);
 146   int idx;
 147
 148   for (idx = 0; idx < r_opc_num; idx++)
 149     {
 150       if (r_opc[idx] != opc)
 151         continue;
 152       else
 153         break;
 154     }
 155
 156   if (idx == r_opc_num)
 157     return NIL;
 158
 159   for (idx = 0 ; idx < dlx_r_opcode_num; idx++)
 160     if (dlx_r_opcode[idx].func == func)
 161       {
 162         (*info->fprintf_func) (info->stream, "%s", dlx_r_opcode[idx].name);
 163
 164         if (func != NOPF)
 165           {
 166             /* This is not a nop.  */
 167             operand_deliminator (info, dlx_r_opcode[idx].name);
 168             (*info->fprintf_func) (info->stream, "r%d,", (int)rd);
 169             (*info->fprintf_func) (info->stream, "r%d", (int)rs1);
 170             if (func != MVTSF && func != MVFSF)
 171               (*info->fprintf_func) (info->stream, ",r%d", (int)rs2);
 172           }
 173         return (unsigned char) R_TYPE;
 174       }
 175
 176   return (unsigned char) R_ERROR;
 177 }
 178
 179 /* Process the memory read opcode.  */
 180
 181 static unsigned char
 182 dlx_load_type (struct disassemble_info* info)
 183 {
 184   struct _load_opcode
 185   {
 186     unsigned long opcode;
 187     char *name;
 188   }
 189   dlx_load_opcode[] =
 190   {
 191     { OPC(LHIOP),   "lhi" },  /* Load HI to register.           */
 192     { OPC(LBOP),     "lb" },  /* load byte sign extended.       */
 193     { OPC(LBUOP),   "lbu" },  /* load byte unsigned.            */
 194     { OPC(LSBUOP),"ldstbu"},  /* load store byte unsigned.      */
 195     { OPC(LHOP),     "lh" },  /* load halfword sign extended.   */
 196     { OPC(LHUOP),   "lhu" },  /* load halfword unsigned.        */
 197     { OPC(LSHUOP),"ldsthu"},  /* load store halfword unsigned.  */
 198     { OPC(LWOP),     "lw" },  /* load word.                     */
 199     { OPC(LSWOP), "ldstw" }   /* load store word.               */
 200   };
 201   int dlx_load_opcode_num =
 202     (sizeof dlx_load_opcode) / (sizeof dlx_load_opcode[0]);
 203   int idx;
 204
 205   for (idx = 0 ; idx < dlx_load_opcode_num; idx++)
 206     if (dlx_load_opcode[idx].opcode == opc)
 207       {
 208         if (opc == OPC (LHIOP))
 209           {
 210             (*info->fprintf_func) (info->stream, "%s", dlx_load_opcode[idx].name);
 211             operand_deliminator (info, dlx_load_opcode[idx].name);
 212             (*info->fprintf_func) (info->stream, "r%d,", (int)rs2);
 213             (*info->fprintf_func) (info->stream, "0x%04x", (int)imm16);
 214           }
 215         else
 216           {
 217             (*info->fprintf_func) (info->stream, "%s", dlx_load_opcode[idx].name);
 218             operand_deliminator (info, dlx_load_opcode[idx].name);
 219             (*info->fprintf_func) (info->stream, "r%d,", (int)rs2);
 220             (*info->fprintf_func) (info->stream, "0x%04x[r%d]", (int)imm16, (int)rs1);
 221           }
 222
 223         return (unsigned char) ILD_TYPE;
 224     }
 225
 226   return (unsigned char) NIL;
 227 }
 228
 229 /* Process the memory store opcode.  */
 230
 231 static unsigned char
 232 dlx_store_type (struct disassemble_info* info)
 233 {
 234   struct _store_opcode
 235   {
 236     unsigned long opcode;
 237     char *name;
 238   }
 239   dlx_store_opcode[] =
 240   {
 241     { OPC(SBOP),     "sb" },  /* Store byte.      */
 242     { OPC(SHOP),     "sh" },  /* Store halfword.  */
 243     { OPC(SWOP),     "sw" },  /* Store word.      */
 244   };
 245   int dlx_store_opcode_num =
 246     (sizeof dlx_store_opcode) / (sizeof dlx_store_opcode[0]);
 247   int idx;
 248
 249   for (idx = 0 ; idx < dlx_store_opcode_num; idx++)
 250     if (dlx_store_opcode[idx].opcode == opc)
 251       {
 252         (*info->fprintf_func) (info->stream, "%s", dlx_store_opcode[idx].name);
 253         operand_deliminator (info, dlx_store_opcode[idx].name);
 254         (*info->fprintf_func) (info->stream, "0x%04x[r%d],", (int)imm16, (int)rs1);
 255         (*info->fprintf_func) (info->stream, "r%d", (int)rs2);
 256         return (unsigned char) IST_TYPE;
 257       }
 258
 259   return (unsigned char) NIL;
 260 }
 261
 262 /* Process the Arithmetic and Logical I-TYPE opcode.  */
 263
 264 static unsigned char
 265 dlx_aluI_type (struct disassemble_info* info)
 266 {
 267   struct _aluI_opcode
 268   {
 269     unsigned long opcode;
 270     char *name;
 271   }
 272   dlx_aluI_opcode[] =
 273   {
 274     { OPC(ADDIOP),   "addi"  },  /* Store byte.      */
 275     { OPC(ADDUIOP),  "addui" },  /* Store halfword.  */
 276     { OPC(SUBIOP),   "subi"  },  /* Store word.      */
 277     { OPC(SUBUIOP),  "subui" },  /* Store word.      */
 278     { OPC(ANDIOP),   "andi"  },  /* Store word.      */
 279     { OPC(ORIOP),    "ori"   },  /* Store word.      */
 280     { OPC(XORIOP),   "xori"  },  /* Store word.      */
 281     { OPC(SLLIOP),   "slli"  },  /* Store word.      */
 282     { OPC(SRAIOP),   "srai"  },  /* Store word.      */
 283     { OPC(SRLIOP),   "srli"  },  /* Store word.      */
 284     { OPC(SEQIOP),   "seqi"  },  /* Store word.      */
 285     { OPC(SNEIOP),   "snei"  },  /* Store word.      */
 286     { OPC(SLTIOP),   "slti"  },  /* Store word.      */
 287     { OPC(SGTIOP),   "sgti"  },  /* Store word.      */
 288     { OPC(SLEIOP),   "slei"  },  /* Store word.      */
 289     { OPC(SGEIOP),   "sgei"  },  /* Store word.      */
 290     { OPC(SEQUIOP),  "sequi" },  /* Store word.      */
 291     { OPC(SNEUIOP),  "sneui" },  /* Store word.      */
 292     { OPC(SLTUIOP),  "sltui" },  /* Store word.      */
 293     { OPC(SGTUIOP),  "sgtui" },  /* Store word.      */
 294     { OPC(SLEUIOP),  "sleui" },  /* Store word.      */
 295     { OPC(SGEUIOP),  "sgeui" },  /* Store word.      */
 296 #if 0
 297     { OPC(MVTSOP),   "mvts"  },  /* Store word.      */
 298     { OPC(MVFSOP),   "mvfs"  },  /* Store word.      */
 299 #endif
 300   };
 301   int dlx_aluI_opcode_num =
 302     (sizeof dlx_aluI_opcode) / (sizeof dlx_aluI_opcode[0]);
 303   int idx;
 304
 305   for (idx = 0 ; idx < dlx_aluI_opcode_num; idx++)
 306     if (dlx_aluI_opcode[idx].opcode == opc)
 307       {
 308         (*info->fprintf_func) (info->stream, "%s", dlx_aluI_opcode[idx].name);
 309         operand_deliminator (info, dlx_aluI_opcode[idx].name);
 310         (*info->fprintf_func) (info->stream, "r%d,", (int)rs2);
 311         (*info->fprintf_func) (info->stream, "r%d,", (int)rs1);
 312         (*info->fprintf_func) (info->stream, "0x%04x", (int)imm16);
 313
 314         return (unsigned char) IAL_TYPE;
 315       }
 316
 317   return (unsigned char) NIL;
 318 }
 319
 320 /* Process the branch instruction.  */
 321
 322 static unsigned char
 323 dlx_br_type (struct disassemble_info* info)
 324 {
 325   struct _br_opcode
 326   {
 327     unsigned long opcode;
 328     char *name;
 329   }
 330   dlx_br_opcode[] =
 331   {
 332     { OPC(BEQOP), "beqz" }, /* Store byte.  */
 333     { OPC(BNEOP), "bnez" }  /* Store halfword.  */
 334   };
 335   int dlx_br_opcode_num =
 336     (sizeof dlx_br_opcode) / (sizeof dlx_br_opcode[0]);
 337   int idx;
 338
 339   for (idx = 0 ; idx < dlx_br_opcode_num; idx++)
 340     if (dlx_br_opcode[idx].opcode == opc)
 341       {
 342         if (imm16 & 0x00008000)
 343           imm16 |= 0xFFFF0000;
 344
 345         imm16 += (current_insn_addr + 4);
 346         (*info->fprintf_func) (info->stream, "%s", dlx_br_opcode[idx].name);
 347         operand_deliminator (info, dlx_br_opcode[idx].name);
 348         (*info->fprintf_func) (info->stream, "r%d,", (int) rs1);
 349         (*info->fprintf_func) (info->stream, "0x%08x", (int) imm16);
 350
 351         return (unsigned char) IBR_TYPE;
 352       }
 353
 354   return (unsigned char) NIL;
 355 }
 356
 357 /* Process the jump instruction.  */
 358
 359 static unsigned char
 360 dlx_jmp_type (struct disassemble_info* info)
 361 {
 362   struct _jmp_opcode
 363   {
 364     unsigned long opcode;
 365     char *name;
 366   }
 367   dlx_jmp_opcode[] =
 368   {
 369     { OPC(JOP),         "j" },  /* Store byte.      */
 370     { OPC(JALOP),     "jal" },  /* Store halfword.  */
 371     { OPC(BREAKOP), "break" },  /* Store halfword.  */
 372     { OPC(TRAPOP),   "trap" },  /* Store halfword.  */
 373     { OPC(RFEOP),     "rfe" }   /* Store halfword.  */
 374   };
 375   int dlx_jmp_opcode_num =
 376     (sizeof dlx_jmp_opcode) / (sizeof dlx_jmp_opcode[0]);
 377   int idx;
 378
 379   for (idx = 0 ; idx < dlx_jmp_opcode_num; idx++)
 380     if (dlx_jmp_opcode[idx].opcode == opc)
 381       {
 382         if (imm26 & 0x02000000)
 383           imm26 |= 0xFC000000;
 384
 385         imm26 += (current_insn_addr + 4);
 386
 387         (*info->fprintf_func) (info->stream, "%s", dlx_jmp_opcode[idx].name);
 388         operand_deliminator (info, dlx_jmp_opcode[idx].name);
 389         (*info->fprintf_func) (info->stream, "0x%08x", (int)imm26);
 390
 391         return (unsigned char) IJ_TYPE;
 392       }
 393
 394   return (unsigned char) NIL;
 395 }
 396
 397 /* Process the jump register instruction.  */
 398
 399 static unsigned char
 400 dlx_jr_type (struct disassemble_info* info)
 401 {
 402   struct _jr_opcode
 403   {
 404     unsigned long opcode;
 405     char *name;
 406   }
 407   dlx_jr_opcode[] =
 408   {
 409     { OPC(JROP),   "jr"    },  /* Store byte.  */
 410     { OPC(JALROP), "jalr"  }   /* Store halfword.  */
 411   };
 412   int dlx_jr_opcode_num =
 413     (sizeof dlx_jr_opcode) / (sizeof dlx_jr_opcode[0]);
 414   int idx;
 415
 416   for (idx = 0 ; idx < dlx_jr_opcode_num; idx++)
 417     if (dlx_jr_opcode[idx].opcode == opc)
 418       {
 419         (*info->fprintf_func) (info->stream, "%s", dlx_jr_opcode[idx].name);
 420         operand_deliminator (info, dlx_jr_opcode[idx].name);
 421         (*info->fprintf_func) (info->stream, "r%d", (int)rs1);
 422         return (unsigned char) IJR_TYPE;
 423       }
 424
 425   return (unsigned char) NIL;
 426 }
 427
 428 typedef unsigned char (* dlx_insn) (struct disassemble_info *);
 429
 430 /* This is the main DLX insn handling routine.  */
 431
 432 int
 433 print_insn_dlx (bfd_vma memaddr, struct disassemble_info* info)
 434 {
 435   bfd_byte buffer[4];
 436   int insn_idx;
 437   unsigned long insn_word;
 438   unsigned char rtn_code;
 439   unsigned long dlx_insn_type[] =
 440   {
 441     (unsigned long) dlx_r_type,
 442     (unsigned long) dlx_load_type,
 443     (unsigned long) dlx_store_type,
 444     (unsigned long) dlx_aluI_type,
 445     (unsigned long) dlx_br_type,
 446     (unsigned long) dlx_jmp_type,
 447     (unsigned long) dlx_jr_type,
 448     (unsigned long) NULL
 449   };
 450   int dlx_insn_type_num = ((sizeof dlx_insn_type) / (sizeof (unsigned long))) - 1;
 451   int status =
 452     (*info->read_memory_func) (memaddr, (bfd_byte *) &buffer[0], 4, info);
 453
 454   if (status != 0)
 455     {
 456       (*info->memory_error_func) (status, memaddr, info);
 457       return -1;
 458     }
 459
 460   /* Now decode the insn    */
 461   insn_word = bfd_getb32 (buffer);
 462   opc  = dlx_get_opcode (insn_word);
 463   rs1  = dlx_get_rs1 (insn_word);
 464   rs2  = dlx_get_rs2 (insn_word);
 465   rd   = dlx_get_rdR (insn_word);
 466   func = dlx_get_func (insn_word);
 467   imm16= dlx_get_imm16 (insn_word);
 468   imm26= dlx_get_imm26 (insn_word);
 469
 470 #if 0
 471   printf ("print_insn_big_dlx: opc = 0x%02x\n"
 472           "                    rs1 = 0x%02x\n"
 473           "                    rs2 = 0x%02x\n"
 474           "                    rd  = 0x%02x\n"
 475           "                  func  = 0x%08x\n"
 476           "                 imm16  = 0x%08x\n"
 477           "                 imm26  = 0x%08x\n",
 478           opc, rs1, rs2, rd, func, imm16, imm26);
 479 #endif
 480
 481   /* Scan through all the insn type and print the insn out.  */
 482   rtn_code = 0;
 483   current_insn_addr = (unsigned long) memaddr;
 484
 485   for (insn_idx = 0; dlx_insn_type[insn_idx] != 0x0; insn_idx++)
 486     switch (((dlx_insn) (dlx_insn_type[insn_idx])) (info))
 487       {
 488         /* Found the correct opcode   */
 489       case R_TYPE:
 490       case ILD_TYPE:
 491       case IST_TYPE:
 492       case IAL_TYPE:
 493       case IBR_TYPE:
 494       case IJ_TYPE:
 495       case IJR_TYPE:
 496         return 4;
 497
 498         /* Wrong insn type check next one. */
 499       default:
 500       case NIL:
 501         continue;
 502
 503         /* All rest of the return code are not recongnized, treat it as error */
 504         /* we should never get here,  I hope! */
 505       case R_ERROR:
 506         return -1;
 507       }
 508
 509   if (insn_idx ==  dlx_insn_type_num)
 510     /* Well, does not recoganize this opcode.  */
 511     (*info->fprintf_func) (info->stream, "<%s>", "Unrecognized Opcode");
 512
 513   return 4;
 514 }