Retro68/binutils/opcodes/dlx-dis.c
2015-08-28 17:32:19 +02:00

515 lines
15 KiB
C

/* Instruction printing code for the DLX Microprocessor
Copyright (C) 2002-2014 Free Software Foundation, Inc.
Contributed by Kuang Hwa Lin. Written by Kuang Hwa Lin, 03/2002.
This file is part of the GNU opcodes library.
This library is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.
It is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
MA 02110-1301, USA. */
#include "sysdep.h"
#include "dis-asm.h"
#include "opcode/dlx.h"
#define R_ERROR 0x1
#define R_TYPE 0x2
#define ILD_TYPE 0x3
#define IST_TYPE 0x4
#define IAL_TYPE 0x5
#define IBR_TYPE 0x6
#define IJ_TYPE 0x7
#define IJR_TYPE 0x8
#define NIL 0x9
#define OPC(x) ((x >> 26) & 0x3F)
#define FUNC(x) (x & 0x7FF)
unsigned char opc, rs1, rs2, rd;
unsigned long imm26, imm16, func, current_insn_addr;
/* Print one instruction from MEMADDR on INFO->STREAM.
Return the size of the instruction (always 4 on dlx). */
static unsigned char
dlx_get_opcode (unsigned long opcode)
{
return (unsigned char) ((opcode >> 26) & 0x3F);
}
static unsigned char
dlx_get_rs1 (unsigned long opcode)
{
return (unsigned char) ((opcode >> 21) & 0x1F);
}
static unsigned char
dlx_get_rs2 (unsigned long opcode)
{
return (unsigned char) ((opcode >> 16) & 0x1F);
}
static unsigned char
dlx_get_rdR (unsigned long opcode)
{
return (unsigned char) ((opcode >> 11) & 0x1F);
}
static unsigned long
dlx_get_func (unsigned long opcode)
{
return (unsigned char) (opcode & 0x7FF);
}
static unsigned long
dlx_get_imm16 (unsigned long opcode)
{
return (unsigned long) (opcode & 0xFFFF);
}
static unsigned long
dlx_get_imm26 (unsigned long opcode)
{
return (unsigned long) (opcode & 0x03FFFFFF);
}
/* Fill the opcode to the max length. */
static void
operand_deliminator (struct disassemble_info *info, char *ptr)
{
int difft = 8 - (int) strlen (ptr);
while (difft > 0)
{
(*info->fprintf_func) (info->stream, "%c", ' ');
difft -= 1;
}
}
/* Process the R-type opcode. */
static unsigned char
dlx_r_type (struct disassemble_info *info)
{
unsigned char r_opc[] = { OPC(ALUOP) }; /* Fix ME */
int r_opc_num = (sizeof r_opc) / (sizeof (char));
struct _r_opcode
{
unsigned long func;
char *name;
}
dlx_r_opcode[] =
{
{ NOPF, "nop" }, /* NOP */
{ ADDF, "add" }, /* Add */
{ ADDUF, "addu" }, /* Add Unsigned */
{ SUBF, "sub" }, /* SUB */
{ SUBUF, "subu" }, /* Sub Unsigned */
{ MULTF, "mult" }, /* MULTIPLY */
{ MULTUF, "multu" }, /* MULTIPLY Unsigned */
{ DIVF, "div" }, /* DIVIDE */
{ DIVUF, "divu" }, /* DIVIDE Unsigned */
{ ANDF, "and" }, /* AND */
{ ORF, "or" }, /* OR */
{ XORF, "xor" }, /* Exclusive OR */
{ SLLF, "sll" }, /* SHIFT LEFT LOGICAL */
{ SRAF, "sra" }, /* SHIFT RIGHT ARITHMETIC */
{ SRLF, "srl" }, /* SHIFT RIGHT LOGICAL */
{ SEQF, "seq" }, /* Set if equal */
{ SNEF, "sne" }, /* Set if not equal */
{ SLTF, "slt" }, /* Set if less */
{ SGTF, "sgt" }, /* Set if greater */
{ SLEF, "sle" }, /* Set if less or equal */
{ SGEF, "sge" }, /* Set if greater or equal */
{ SEQUF, "sequ" }, /* Set if equal */
{ SNEUF, "sneu" }, /* Set if not equal */
{ SLTUF, "sltu" }, /* Set if less */
{ SGTUF, "sgtu" }, /* Set if greater */
{ SLEUF, "sleu" }, /* Set if less or equal */
{ SGEUF, "sgeu" }, /* Set if greater or equal */
{ MVTSF, "mvts" }, /* Move to special register */
{ MVFSF, "mvfs" }, /* Move from special register */
{ BSWAPF, "bswap" }, /* Byte swap ?? */
{ LUTF, "lut" } /* ????????? ?? */
};
int dlx_r_opcode_num = (sizeof dlx_r_opcode) / (sizeof dlx_r_opcode[0]);
int idx;
for (idx = 0; idx < r_opc_num; idx++)
{
if (r_opc[idx] != opc)
continue;
else
break;
}
if (idx == r_opc_num)
return NIL;
for (idx = 0 ; idx < dlx_r_opcode_num; idx++)
if (dlx_r_opcode[idx].func == func)
{
(*info->fprintf_func) (info->stream, "%s", dlx_r_opcode[idx].name);
if (func != NOPF)
{
/* This is not a nop. */
operand_deliminator (info, dlx_r_opcode[idx].name);
(*info->fprintf_func) (info->stream, "r%d,", (int)rd);
(*info->fprintf_func) (info->stream, "r%d", (int)rs1);
if (func != MVTSF && func != MVFSF)
(*info->fprintf_func) (info->stream, ",r%d", (int)rs2);
}
return (unsigned char) R_TYPE;
}
return (unsigned char) R_ERROR;
}
/* Process the memory read opcode. */
static unsigned char
dlx_load_type (struct disassemble_info* info)
{
struct _load_opcode
{
unsigned long opcode;
char *name;
}
dlx_load_opcode[] =
{
{ OPC(LHIOP), "lhi" }, /* Load HI to register. */
{ OPC(LBOP), "lb" }, /* load byte sign extended. */
{ OPC(LBUOP), "lbu" }, /* load byte unsigned. */
{ OPC(LSBUOP),"ldstbu"}, /* load store byte unsigned. */
{ OPC(LHOP), "lh" }, /* load halfword sign extended. */
{ OPC(LHUOP), "lhu" }, /* load halfword unsigned. */
{ OPC(LSHUOP),"ldsthu"}, /* load store halfword unsigned. */
{ OPC(LWOP), "lw" }, /* load word. */
{ OPC(LSWOP), "ldstw" } /* load store word. */
};
int dlx_load_opcode_num =
(sizeof dlx_load_opcode) / (sizeof dlx_load_opcode[0]);
int idx;
for (idx = 0 ; idx < dlx_load_opcode_num; idx++)
if (dlx_load_opcode[idx].opcode == opc)
{
if (opc == OPC (LHIOP))
{
(*info->fprintf_func) (info->stream, "%s", dlx_load_opcode[idx].name);
operand_deliminator (info, dlx_load_opcode[idx].name);
(*info->fprintf_func) (info->stream, "r%d,", (int)rs2);
(*info->fprintf_func) (info->stream, "0x%04x", (int)imm16);
}
else
{
(*info->fprintf_func) (info->stream, "%s", dlx_load_opcode[idx].name);
operand_deliminator (info, dlx_load_opcode[idx].name);
(*info->fprintf_func) (info->stream, "r%d,", (int)rs2);
(*info->fprintf_func) (info->stream, "0x%04x[r%d]", (int)imm16, (int)rs1);
}
return (unsigned char) ILD_TYPE;
}
return (unsigned char) NIL;
}
/* Process the memory store opcode. */
static unsigned char
dlx_store_type (struct disassemble_info* info)
{
struct _store_opcode
{
unsigned long opcode;
char *name;
}
dlx_store_opcode[] =
{
{ OPC(SBOP), "sb" }, /* Store byte. */
{ OPC(SHOP), "sh" }, /* Store halfword. */
{ OPC(SWOP), "sw" }, /* Store word. */
};
int dlx_store_opcode_num =
(sizeof dlx_store_opcode) / (sizeof dlx_store_opcode[0]);
int idx;
for (idx = 0 ; idx < dlx_store_opcode_num; idx++)
if (dlx_store_opcode[idx].opcode == opc)
{
(*info->fprintf_func) (info->stream, "%s", dlx_store_opcode[idx].name);
operand_deliminator (info, dlx_store_opcode[idx].name);
(*info->fprintf_func) (info->stream, "0x%04x[r%d],", (int)imm16, (int)rs1);
(*info->fprintf_func) (info->stream, "r%d", (int)rs2);
return (unsigned char) IST_TYPE;
}
return (unsigned char) NIL;
}
/* Process the Arithmetic and Logical I-TYPE opcode. */
static unsigned char
dlx_aluI_type (struct disassemble_info* info)
{
struct _aluI_opcode
{
unsigned long opcode;
char *name;
}
dlx_aluI_opcode[] =
{
{ OPC(ADDIOP), "addi" }, /* Store byte. */
{ OPC(ADDUIOP), "addui" }, /* Store halfword. */
{ OPC(SUBIOP), "subi" }, /* Store word. */
{ OPC(SUBUIOP), "subui" }, /* Store word. */
{ OPC(ANDIOP), "andi" }, /* Store word. */
{ OPC(ORIOP), "ori" }, /* Store word. */
{ OPC(XORIOP), "xori" }, /* Store word. */
{ OPC(SLLIOP), "slli" }, /* Store word. */
{ OPC(SRAIOP), "srai" }, /* Store word. */
{ OPC(SRLIOP), "srli" }, /* Store word. */
{ OPC(SEQIOP), "seqi" }, /* Store word. */
{ OPC(SNEIOP), "snei" }, /* Store word. */
{ OPC(SLTIOP), "slti" }, /* Store word. */
{ OPC(SGTIOP), "sgti" }, /* Store word. */
{ OPC(SLEIOP), "slei" }, /* Store word. */
{ OPC(SGEIOP), "sgei" }, /* Store word. */
{ OPC(SEQUIOP), "sequi" }, /* Store word. */
{ OPC(SNEUIOP), "sneui" }, /* Store word. */
{ OPC(SLTUIOP), "sltui" }, /* Store word. */
{ OPC(SGTUIOP), "sgtui" }, /* Store word. */
{ OPC(SLEUIOP), "sleui" }, /* Store word. */
{ OPC(SGEUIOP), "sgeui" }, /* Store word. */
#if 0
{ OPC(MVTSOP), "mvts" }, /* Store word. */
{ OPC(MVFSOP), "mvfs" }, /* Store word. */
#endif
};
int dlx_aluI_opcode_num =
(sizeof dlx_aluI_opcode) / (sizeof dlx_aluI_opcode[0]);
int idx;
for (idx = 0 ; idx < dlx_aluI_opcode_num; idx++)
if (dlx_aluI_opcode[idx].opcode == opc)
{
(*info->fprintf_func) (info->stream, "%s", dlx_aluI_opcode[idx].name);
operand_deliminator (info, dlx_aluI_opcode[idx].name);
(*info->fprintf_func) (info->stream, "r%d,", (int)rs2);
(*info->fprintf_func) (info->stream, "r%d,", (int)rs1);
(*info->fprintf_func) (info->stream, "0x%04x", (int)imm16);
return (unsigned char) IAL_TYPE;
}
return (unsigned char) NIL;
}
/* Process the branch instruction. */
static unsigned char
dlx_br_type (struct disassemble_info* info)
{
struct _br_opcode
{
unsigned long opcode;
char *name;
}
dlx_br_opcode[] =
{
{ OPC(BEQOP), "beqz" }, /* Store byte. */
{ OPC(BNEOP), "bnez" } /* Store halfword. */
};
int dlx_br_opcode_num =
(sizeof dlx_br_opcode) / (sizeof dlx_br_opcode[0]);
int idx;
for (idx = 0 ; idx < dlx_br_opcode_num; idx++)
if (dlx_br_opcode[idx].opcode == opc)
{
if (imm16 & 0x00008000)
imm16 |= 0xFFFF0000;
imm16 += (current_insn_addr + 4);
(*info->fprintf_func) (info->stream, "%s", dlx_br_opcode[idx].name);
operand_deliminator (info, dlx_br_opcode[idx].name);
(*info->fprintf_func) (info->stream, "r%d,", (int) rs1);
(*info->fprintf_func) (info->stream, "0x%08x", (int) imm16);
return (unsigned char) IBR_TYPE;
}
return (unsigned char) NIL;
}
/* Process the jump instruction. */
static unsigned char
dlx_jmp_type (struct disassemble_info* info)
{
struct _jmp_opcode
{
unsigned long opcode;
char *name;
}
dlx_jmp_opcode[] =
{
{ OPC(JOP), "j" }, /* Store byte. */
{ OPC(JALOP), "jal" }, /* Store halfword. */
{ OPC(BREAKOP), "break" }, /* Store halfword. */
{ OPC(TRAPOP), "trap" }, /* Store halfword. */
{ OPC(RFEOP), "rfe" } /* Store halfword. */
};
int dlx_jmp_opcode_num =
(sizeof dlx_jmp_opcode) / (sizeof dlx_jmp_opcode[0]);
int idx;
for (idx = 0 ; idx < dlx_jmp_opcode_num; idx++)
if (dlx_jmp_opcode[idx].opcode == opc)
{
if (imm26 & 0x02000000)
imm26 |= 0xFC000000;
imm26 += (current_insn_addr + 4);
(*info->fprintf_func) (info->stream, "%s", dlx_jmp_opcode[idx].name);
operand_deliminator (info, dlx_jmp_opcode[idx].name);
(*info->fprintf_func) (info->stream, "0x%08x", (int)imm26);
return (unsigned char) IJ_TYPE;
}
return (unsigned char) NIL;
}
/* Process the jump register instruction. */
static unsigned char
dlx_jr_type (struct disassemble_info* info)
{
struct _jr_opcode
{
unsigned long opcode;
char *name;
}
dlx_jr_opcode[] =
{
{ OPC(JROP), "jr" }, /* Store byte. */
{ OPC(JALROP), "jalr" } /* Store halfword. */
};
int dlx_jr_opcode_num =
(sizeof dlx_jr_opcode) / (sizeof dlx_jr_opcode[0]);
int idx;
for (idx = 0 ; idx < dlx_jr_opcode_num; idx++)
if (dlx_jr_opcode[idx].opcode == opc)
{
(*info->fprintf_func) (info->stream, "%s", dlx_jr_opcode[idx].name);
operand_deliminator (info, dlx_jr_opcode[idx].name);
(*info->fprintf_func) (info->stream, "r%d", (int)rs1);
return (unsigned char) IJR_TYPE;
}
return (unsigned char) NIL;
}
typedef unsigned char (* dlx_insn) (struct disassemble_info *);
/* This is the main DLX insn handling routine. */
int
print_insn_dlx (bfd_vma memaddr, struct disassemble_info* info)
{
bfd_byte buffer[4];
int insn_idx;
unsigned long insn_word;
dlx_insn dlx_insn_type[] =
{
dlx_r_type,
dlx_load_type,
dlx_store_type,
dlx_aluI_type,
dlx_br_type,
dlx_jmp_type,
dlx_jr_type,
(dlx_insn) NULL
};
int dlx_insn_type_num = ((sizeof dlx_insn_type) / (sizeof (dlx_insn))) - 1;
int status =
(*info->read_memory_func) (memaddr, (bfd_byte *) &buffer[0], 4, info);
if (status != 0)
{
(*info->memory_error_func) (status, memaddr, info);
return -1;
}
/* Now decode the insn */
insn_word = bfd_getb32 (buffer);
opc = dlx_get_opcode (insn_word);
rs1 = dlx_get_rs1 (insn_word);
rs2 = dlx_get_rs2 (insn_word);
rd = dlx_get_rdR (insn_word);
func = dlx_get_func (insn_word);
imm16= dlx_get_imm16 (insn_word);
imm26= dlx_get_imm26 (insn_word);
#if 0
printf ("print_insn_big_dlx: opc = 0x%02x\n"
" rs1 = 0x%02x\n"
" rs2 = 0x%02x\n"
" rd = 0x%02x\n"
" func = 0x%08x\n"
" imm16 = 0x%08x\n"
" imm26 = 0x%08x\n",
opc, rs1, rs2, rd, func, imm16, imm26);
#endif
/* Scan through all the insn type and print the insn out. */
current_insn_addr = (unsigned long) memaddr;
for (insn_idx = 0; dlx_insn_type[insn_idx] != 0x0; insn_idx++)
switch ((dlx_insn_type[insn_idx]) (info))
{
/* Found the correct opcode */
case R_TYPE:
case ILD_TYPE:
case IST_TYPE:
case IAL_TYPE:
case IBR_TYPE:
case IJ_TYPE:
case IJR_TYPE:
return 4;
/* Wrong insn type check next one. */
default:
case NIL:
continue;
/* All rest of the return code are not recongnized, treat it as error */
/* we should never get here, I hope! */
case R_ERROR:
return -1;
}
if (insn_idx == dlx_insn_type_num)
/* Well, does not recoganize this opcode. */
(*info->fprintf_func) (info->stream, "<%s>", "Unrecognized Opcode");
return 4;
}