mirrors/binutils-gdb
1
0
Fork 0
mirror of https://sourceware.org/git/binutils-gdb.git synced 2024-11-25 11:04:18 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity
e2e9097bd2
binutils-gdb/opcodes/csky-dis.c

1069 lines
26 KiB
C
Raw Blame History

/* C-SKY disassembler.
Copyright (C) 1988-2019 Free Software Foundation, Inc.
Contributed by C-SKY Microsystems and Mentor Graphics.
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 "config.h"
#include <stdio.h>
#include "bfd_stdint.h"
#include "disassemble.h"
#include "elf-bfd.h"
#include "opcode/csky.h"
#include "libiberty.h"
#include "csky-opc.h"
#include "floatformat.h"
#define CSKY_INST_TYPE unsigned long
#define HAS_SUB_OPERAND (unsigned int)0xffffffff
enum sym_type
{
CUR_TEXT,
CUR_DATA
};
struct csky_dis_info
{
/* Mem to disassemble. */
bfd_vma mem;
/* Disassemble info. */
disassemble_info *info;
/* Opcode information. */
struct csky_opcode_info const *opinfo;
/* The value of operand to show. */
int value;
/* Whether to look up/print a symbol name. */
int need_output_symbol;
} dis_info;
enum sym_type last_type;
int last_map_sym = 1;
bfd_vma last_map_addr = 0;
/* Only for objdump tool. */
#define INIT_MACH_FLAG 0xffffffff
#define BINARY_MACH_FLAG 0x0
static unsigned int mach_flag = INIT_MACH_FLAG;
static void
print_insn_data (bfd_vma pc ATTRIBUTE_UNUSED,
struct disassemble_info *info,
long given)
{
switch (info->bytes_per_chunk)
{
case 1:
info->fprintf_func (info->stream, ".byte\t0x%02lx", given);
break;
case 2:
info->fprintf_func (info->stream, ".short\t0x%04lx", given);
break;
case 4:
info->fprintf_func (info->stream, ".long\t0x%08lx", given);
break;
default:
abort ();
}
}
static int
get_sym_code_type (struct disassemble_info *info,
int n,
enum sym_type *sym_type)
{
const char *name;
name = bfd_asymbol_name (info->symtab[n]);
if (name[0] == '$' && (name[1] == 't' || name[1] == 'd')
&& (name[2] == 0 || name[2] == '.'))
{
*sym_type = ((name[1] == 't') ? CUR_TEXT : CUR_DATA);
return TRUE;
}
return FALSE;
}
static int
csky_get_operand_mask (struct operand const *oprnd)
{
int mask = 0;
if (oprnd->mask == HAS_SUB_OPERAND)
{
struct soperand *sop = (struct soperand *)oprnd;
mask |= csky_get_operand_mask (&sop->subs[0]);
mask |= csky_get_operand_mask (&sop->subs[1]);
return mask;
}
return oprnd->mask;
}
static int
csky_get_mask (struct csky_opcode_info const *pinfo)
{
int i = 0;
int mask = 0;
/* List type. */
if (pinfo->operand_num == -1)
mask |= csky_get_operand_mask (&pinfo->oprnd.oprnds[i]);
else
for (; i < pinfo->operand_num; i++)
mask |= csky_get_operand_mask (&pinfo->oprnd.oprnds[i]);
mask = ~mask;
return mask;
}
static unsigned int
csky_chars_to_number (unsigned char * buf, int n)
{
if (n == 0)
abort ();
int i;
int val = 0;
if (dis_info.info->endian == BFD_ENDIAN_BIG)
while (n--)
val |= buf[n] << (n*8);
else
for (i = 0; i < n; i++)
val |= buf[i] << (i*8);
return val;
}
static struct csky_opcode const *g_opcodeP;
static struct csky_opcode const *
csky_find_inst_info (struct csky_opcode_info const **pinfo,
CSKY_INST_TYPE inst, int length)
{
int i;
unsigned int mask;
struct csky_opcode const *p;
p = g_opcodeP;
while (p->mnemonic)
{
/* Get the opcode mask. */
for (i = 0; i < OP_TABLE_NUM; i++)
if (length == 2)
{
mask = csky_get_mask (&p->op16[i]);
if (mask != 0 && (inst & mask) == p->op16[i].opcode)
{
*pinfo = &p->op16[i];
g_opcodeP = p;
return p;
}
}
else if (length == 4)
{
mask = csky_get_mask (&p->op32[i]);
if (mask != 0
&& ((unsigned long)(inst & mask)
== (unsigned long)p->op32[i].opcode))
{
*pinfo = &p->op32[i];
g_opcodeP = p;
return p;
}
}
p++;
}
return NULL;
}
static bfd_boolean
is_extern_symbol (struct disassemble_info *info, int addr)
{
unsigned int rel_count = 0;
if (info->section == NULL)
return 0;
if ((info->section->flags & SEC_RELOC) != 0) /* Fit .o file. */
{
struct reloc_cache_entry *pt = info->section->relocation;
for (; rel_count < info->section->reloc_count; rel_count++, pt++)
if ((long unsigned int)addr == pt->address)
return TRUE;
return FALSE;
}
return FALSE;
}
/* Suppress printing of mapping symbols emitted by the assembler to mark
the beginning of code and data sequences. */
bfd_boolean
csky_symbol_is_valid (asymbol *sym,
struct disassemble_info *info ATTRIBUTE_UNUSED)
{
const char *name;
if (sym == NULL)
return FALSE;
name = bfd_asymbol_name (sym);
return name && *name != '$';
}
disassembler_ftype
csky_get_disassembler (bfd *abfd)
{
if (abfd != NULL)
mach_flag = elf_elfheader (abfd)->e_flags;
return print_insn_csky;
}
static int
csky_output_operand (char *str, struct operand const *oprnd,
CSKY_INST_TYPE inst, int reloc ATTRIBUTE_UNUSED)
{
int ret = 0;;
int bit = 0;
int result = 0;
bfd_vma value;
int mask = oprnd->mask;
int max = 0;
char buf[128];
/* Get operand value with mask. */
value = inst & mask;
for (; mask; mask >>= 1, value >>=1)
if (mask & 0x1)
{
result |= ((value & 0x1) << bit);
max |= (1 << bit);
bit++;
}
value = result;
/* Here is general instructions that have no reloc. */
switch (oprnd->type)
{
case OPRND_TYPE_CTRLREG:
if (IS_CSKY_V1 (mach_flag))
{
/* In V1 only cr0-cr12 have alias names. */
if (value <= 12)
strcat (str, csky_ctrl_regs[value].name);
/* Others using crn(n > 12). */
else if (value <= 30)
{
sprintf (buf, "cr%d", (int)value);
strcat (str, buf);
}
else
return -1;
}
else
{
int sel;
int crx;
sel = value >> 5;
crx = value & 0x1f;
sprintf (buf, "cr<%d, %d>", crx, sel);
strcat (str, buf);
}
break;
case OPRND_TYPE_DUMMY_REG:
mask = dis_info.opinfo->oprnd.oprnds[0].mask;
value = inst & mask;
for (; mask; mask >>= 1, value >>=1)
if (mask & 0x1)
{
result |= ((value & 0x1) << bit);
bit++;
}
value = result;
strcat (str, csky_general_reg[value]);
break;
case OPRND_TYPE_GREG0_7:
case OPRND_TYPE_GREG0_15:
case OPRND_TYPE_GREG16_31:
case OPRND_TYPE_REGnsplr:
case OPRND_TYPE_AREG:
if (IS_CSKY_V2 (mach_flag) && value == 14)
strcat (str, "sp");
else
strcat (str, csky_general_reg[value]);
dis_info.value = value;
break;
case OPRND_TYPE_CPREG:
strcat (str, csky_cp_reg[value]);
break;
case OPRND_TYPE_FREG:
sprintf (buf, "fr%d", (int)value);
strcat (str, buf);
break;
case OPRND_TYPE_VREG:
sprintf (buf, "vr%d", (int)value);
strcat (str, buf);
break;
case OPRND_TYPE_CPCREG:
strcat (str, csky_cp_creg[value]);
break;
case OPRND_TYPE_CPIDX:
strcat (str, csky_cp_idx[value]);
break;
case OPRND_TYPE_IMM2b_JMPIX:
value = (value + 2) << 3;
sprintf (buf, "%d", (int)value);
strcat (str, buf);
break;
case OPRND_TYPE_IMM_LDST:
case OPRND_TYPE_IMM_FLDST:
value <<= oprnd->shift;
sprintf (buf, "0x%x", (unsigned int)value);
strcat (str, buf);
break;
case OPRND_TYPE_IMM7b_LS2:
case OPRND_TYPE_IMM8b_LS2:
sprintf (buf, "%d", (int)(value << 2));
strcat (str, buf);
ret = 0;
break;
case OPRND_TYPE_IMM5b_BMASKI:
if ((value != 0) && (value > 31 || value < 8))
{
ret = -1;
break;
}
sprintf (buf, "%d", (int)value);
strcat (str, buf);
ret = 0;
break;
case OPRND_TYPE_IMM5b_1_31:
if (value > 31 || value < 1)
{
ret = -1;
break;
}
sprintf (buf, "%d", (int)value);
strcat (str, buf);
ret = 0;
break;
case OPRND_TYPE_IMM5b_7_31:
if (value > 31 || value < 7)
{
ret = -1;
break;
}
sprintf (buf, "%d", (int)value);
strcat (str, buf);
ret = 0;
break;
case OPRND_TYPE_MSB2SIZE:
case OPRND_TYPE_LSB2SIZE:
{
static int size;
if (oprnd->type == OPRND_TYPE_MSB2SIZE)
size = value;
else
{
str[strlen (str) - 2] = '\0';
sprintf (buf, "%d, %d", (int)(size + value), (int)value);
strcat (str, buf);
}
break;
}
case OPRND_TYPE_IMM1b:
case OPRND_TYPE_IMM2b:
case OPRND_TYPE_IMM4b:
case OPRND_TYPE_IMM5b:
case OPRND_TYPE_IMM7b:
case OPRND_TYPE_IMM8b:
case OPRND_TYPE_IMM12b:
case OPRND_TYPE_IMM15b:
case OPRND_TYPE_IMM16b:
case OPRND_TYPE_IMM16b_MOVIH:
case OPRND_TYPE_IMM16b_ORI:
sprintf (buf, "%d", (int)value);
strcat (str, buf);
ret = 0;
break;
case OPRND_TYPE_OFF8b:
case OPRND_TYPE_OFF16b:
{
unsigned char ibytes[4];
int shift = oprnd->shift;
int status;
unsigned int mem_val;
dis_info.info->stop_vma = 0;
value = ((dis_info.mem + (value << shift)
+ ((IS_CSKY_V1 (mach_flag)) ? 2 : 0))
& 0xfffffffc);
status = dis_info.info->read_memory_func (value, ibytes, 4,
dis_info.info);
if (status != 0)
{
dis_info.info->memory_error_func (status, dis_info.mem,
dis_info.info);
return -1;
}
mem_val = csky_chars_to_number (ibytes, 4);
/* Remove [] around literal value to match ABI syntax. */
sprintf (buf, "0x%X", mem_val);
strcat (str, buf);
/* For jmpi/jsri, we'll try to get a symbol for the target. */
if (dis_info.info->print_address_func && mem_val != 0)
{
dis_info.value = mem_val;
dis_info.need_output_symbol = 1;
}
else
{
sprintf (buf, "\t// from address pool at 0x%x",
(unsigned int)value);
strcat (str, buf);
}
break;
}
case OPRND_TYPE_BLOOP_OFF4b:
case OPRND_TYPE_BLOOP_OFF12b:
case OPRND_TYPE_OFF11b:
case OPRND_TYPE_OFF16b_LSL1:
case OPRND_TYPE_IMM_OFF18b:
case OPRND_TYPE_OFF26b:
{
int shift = oprnd->shift;
if (value & ((max >> 1) + 1))
value |= ~max;
if (is_extern_symbol (dis_info.info, dis_info.mem))
value = 0;
else if (IS_CSKY_V1 (mach_flag))
value = dis_info.mem + 2 + (value << shift);
else
value = dis_info.mem + (value << shift);
dis_info.need_output_symbol = 1;
dis_info.value= value;
sprintf (buf, "0x%x", (unsigned int)value);
strcat (str, buf);
break;
}
case OPRND_TYPE_CONSTANT:
case OPRND_TYPE_FCONSTANT:
{
int shift = oprnd->shift;
char ibytes[8];
int status;
bfd_vma addr;
int nbytes;
dis_info.info->stop_vma = 0;
value <<= shift;
if (IS_CSKY_V1 (mach_flag))
addr = (dis_info.mem + 2 + value) & 0xfffffffc;
else
addr = (dis_info.mem + value) & 0xfffffffc;
if (oprnd->type == OPRND_TYPE_FCONSTANT
&& dis_info.opinfo->opcode != CSKYV2_INST_FLRW)
nbytes = 8;
else
nbytes = 4;
status = dis_info.info->read_memory_func (addr, (bfd_byte *)ibytes,
nbytes, dis_info.info);
if (status != 0)
/* Address out of bounds. -> lrw rx, [pc, 0ffset]. */
sprintf (buf, "[pc, %d]\t// from address pool at %x", (int)value,
(unsigned int)addr);
else
{
dis_info.value = addr;
value = csky_chars_to_number ((unsigned char *)ibytes, 4);
}
if (oprnd->type == OPRND_TYPE_FCONSTANT)
{
double f;
if (dis_info.opinfo->opcode == CSKYV2_INST_FLRW)
/* flrws. */
floatformat_to_double ((dis_info.info->endian == BFD_ENDIAN_BIG
? &floatformat_ieee_single_big
: &floatformat_ieee_single_little),
ibytes, &f);
else
floatformat_to_double ((dis_info.info->endian == BFD_ENDIAN_BIG
? &floatformat_ieee_double_big
: &floatformat_ieee_double_little),
ibytes, &f);
sprintf (buf, "%f", f);
}
else
{
dis_info.need_output_symbol = 1;
sprintf (buf, "0x%x", (unsigned int)value);
}
strcat (str, buf);
break;
}
case OPRND_TYPE_ELRW_CONSTANT:
{
int shift = oprnd->shift;
char ibytes[4];
int status;
bfd_vma addr;
dis_info.info->stop_vma = 0;
value = 0x80 + ((~value) & 0x7f);
value = value << shift;
addr = (dis_info.mem + value) & 0xfffffffc;
status = dis_info.info->read_memory_func (addr, (bfd_byte *)ibytes,
4, dis_info.info);
if (status != 0)
/* Address out of bounds. -> lrw rx, [pc, 0ffset]. */
sprintf (buf, "[pc, %d]\t// from address pool at %x", (int) value,
(unsigned int)addr);
else
{
dis_info.value = addr;
value = csky_chars_to_number ((unsigned char *)ibytes, 4);
dis_info.need_output_symbol = 1;
sprintf (buf, "0x%x", (unsigned int)value);
}
strcat (str, buf);
break;
}
case OPRND_TYPE_SFLOAT:
case OPRND_TYPE_DFLOAT:
{
/* This is for fmovis/fmovid, which have an internal 13-bit
encoding that they convert to single/double precision
(respectively). We'll convert the 13-bit encoding to an IEEE
double and then to host double format to print it.
Sign bit: bit 20.
4-bit exponent: bits 19:16, biased by 11.
8-bit mantissa: split between 24:21 and 7:4. */
uint64_t imm4;
uint64_t imm8;
uint64_t dbnum;
unsigned char valbytes[8];
double fvalue;
imm4 = ((inst >> 16) & 0xf);
imm4 = (uint64_t)(1023 - (imm4 - 11)) << 52;
imm8 = (uint64_t)((inst >> 4) & 0xf) << 44;
imm8 |= (uint64_t)((inst >> 21) & 0xf) << 48;
dbnum = (uint64_t)((inst >> 20) & 1) << 63;
dbnum |= imm4 | imm8;
/* Do this a byte at a time so we don't have to
worry about the host's endianness. */
valbytes[0] = dbnum & 0xff;
valbytes[1] = (dbnum >> 8) & 0xff;
valbytes[2] = (dbnum >> 16) & 0xff;
valbytes[3] = (dbnum >> 24) & 0xff;
valbytes[4] = (dbnum >> 32) & 0xff;
valbytes[5] = (dbnum >> 40) & 0xff;
valbytes[6] = (dbnum >> 48) & 0xff;
valbytes[7] = (dbnum >> 56) & 0xff;
floatformat_to_double (&floatformat_ieee_double_little, valbytes,
&fvalue);
sprintf (buf, "%f", fvalue);
strcat (str, buf);
break;
}
case OPRND_TYPE_LABEL_WITH_BRACKET:
sprintf (buf, "[0x%x]", (unsigned int)value);
strcat (str, buf);
strcat (str, "\t// the offset is based on .data");
break;
case OPRND_TYPE_OIMM3b:
case OPRND_TYPE_OIMM4b:
case OPRND_TYPE_OIMM5b:
case OPRND_TYPE_OIMM5b_IDLY:
case OPRND_TYPE_OIMM8b:
case OPRND_TYPE_OIMM12b:
case OPRND_TYPE_OIMM16b:
case OPRND_TYPE_OIMM18b:
value += 1;
sprintf (buf, "%d", (int)value);
strcat (str, buf);
break;
case OPRND_TYPE_OIMM5b_BMASKI:
if (value > 32 || value < 16)
{
ret = -1;
break;
}
sprintf (buf, "%d", (int)(value + 1));
strcat (str, buf);
ret = 0;
break;
case OPRND_TYPE_FREGLIST_DASH:
if (IS_CSKY_V2 (mach_flag))
{
int vrx = value & 0xf;
int vry = vrx + (value >> 4);
sprintf (buf, "fr%d-fr%d", vrx, vry);
strcat (str, buf);
}
break;
case OPRND_TYPE_REGLIST_DASH:
if (IS_CSKY_V1 (mach_flag))
{
strcat (str, csky_general_reg[value]);
strcat (str, "-r15");
}
else
{
strcat (str, csky_general_reg[value >> 5]);
strcat (str, "-");
strcat (str, csky_general_reg[(value & 0x1f) + (value >> 5)]);
}
break;
case OPRND_TYPE_PSR_BITS_LIST:
{
struct psrbit const *bits;
int first_oprnd = TRUE;
int i = 0;
if (IS_CSKY_V1 (mach_flag))
{
if (value == 0)
{
strcat (str, "af");
break;
}
bits = cskyv1_psr_bits;
}
else
bits = cskyv2_psr_bits;
while (value != 0 && bits[i].name != NULL)
{
if (value & bits[i].value)
{
if (!first_oprnd)
strcat (str, ", ");
strcat (str, bits[i].name);
value &= ~bits[i].value;
first_oprnd = FALSE;
}
i++;
}
break;
}
case OPRND_TYPE_REGbsp:
if (IS_CSKY_V1 (mach_flag))
strcat (str, "(sp)");
else
strcat (str, "(sp)");
break;
case OPRND_TYPE_REGsp:
if (IS_CSKY_V1 (mach_flag))
strcat (str, "sp");
else
strcat (str, "sp");
break;
case OPRND_TYPE_REGnr4_r7:
case OPRND_TYPE_AREG_WITH_BRACKET:
if (IS_CSKY_V1 (mach_flag) && (value < 4 || value > 7))
{
strcat (str, "(");
strcat (str, csky_general_reg[value]);
strcat (str, ")");
}
else
{
strcat (str, "(");
strcat (str, csky_general_reg[value]);
strcat (str, ")");
}
break;
case OPRND_TYPE_AREG_WITH_LSHIFT:
strcat (str, csky_general_reg[value >> 5]);
strcat (str, " << ");
if ((value & 0x1f) == 0x1)
strcat (str, "0");
else if ((value & 0x1f) == 0x2)
strcat (str, "1");
else if ((value & 0x1f) == 0x4)
strcat (str, "2");
else if ((value & 0x1f) == 0x8)
strcat (str, "3");
break;
case OPRND_TYPE_AREG_WITH_LSHIFT_FPU:
strcat (str, csky_general_reg[value >> 2]);
strcat (str, " << ");
if ((value & 0x3) == 0x0)
strcat (str, "0");
else if ((value & 0x3) == 0x1)
strcat (str, "1");
else if ((value & 0x3) == 0x2)
strcat (str, "2");
else if ((value & 0x3) == 0x3)
strcat (str, "3");
break;
case OPRND_TYPE_FREG_WITH_INDEX:
{
unsigned freg_val = value & 0xf;
unsigned index_val = (value >> 4) & 0xf;
sprintf (buf, "vr%d[%d]", freg_val, index_val);
strcat(str, buf);
break;
}
case OPRND_TYPE_REGr4_r7:
if (IS_CSKY_V1 (mach_flag))
strcat (str, "r4-r7");
break;
case OPRND_TYPE_CONST1:
strcat (str, "1");
break;
case OPRND_TYPE_REG_r1a:
case OPRND_TYPE_REG_r1b:
strcat (str, "r1");
break;
case OPRND_TYPE_REG_r28:
strcat (str, "r28");
break;
case OPRND_TYPE_REGLIST_DASH_COMMA:
/* 16-bit reglist. */
if (value & 0xf)
{
strcat (str, "r4");
if ((value & 0xf) > 1)
{
strcat (str, "-");
strcat (str, csky_general_reg[(value & 0xf) + 3]);
}
if (value & ~0xf)
strcat (str, ", ");
}
if (value & 0x10)
{
/* r15. */
strcat (str, "r15");
if (value & ~0x1f)
strcat (str, ", ");
}
if (dis_info.opinfo->oprnd.oprnds[0].mask != OPRND_MASK_0_4)
{
/* 32bits reglist. */
value >>= 5;
if (value & 0x3)
{
strcat (str, "r16");
if ((value & 0x7) > 1)
{
strcat (str, "-");
strcat (str, csky_general_reg[(value & 0xf) + 15]);
}
if (value & ~0x7)
strcat (str, ", ");
}
if (value & 0x8)
/* r15. */
strcat (str, "r28");
}
break;
case OPRND_TYPE_UNCOND10b:
case OPRND_TYPE_UNCOND16b:
case OPRND_TYPE_COND10b:
case OPRND_TYPE_COND16b:
{
int shift = oprnd->shift;
if (value & ((max >> 1) + 1))
value |= ~max;
if (is_extern_symbol (dis_info.info, dis_info.mem))
value = 0;
else
value = dis_info.mem + (value << shift);
sprintf (buf, "0x%x", (unsigned int)value);
strcat (str, buf);
dis_info.need_output_symbol = 1;
dis_info.value = value;
}
break;
default:
ret = -1;
break;
}
return ret;
}
static int
csky_print_operand (char *str, struct operand const *oprnd,
CSKY_INST_TYPE inst, int reloc)
{
int ret = -1;
char *lc = "";
char *rc = "";
if (oprnd->mask == HAS_SUB_OPERAND)
{
struct soperand *sop = (struct soperand *)oprnd;
if (oprnd->type == OPRND_TYPE_BRACKET)
{
lc = "(";
rc = ")";
}
else if (oprnd->type == OPRND_TYPE_ABRACKET)
{
lc = "<";
rc = ">";
}
strcat (str, lc);
ret = csky_print_operand (str, &sop->subs[0], inst, reloc);
if (ret)
return ret;
strcat (str, ", ");
ret = csky_print_operand (str, &sop->subs[1], inst, reloc);
strcat (str, rc);
return ret;
}
return csky_output_operand (str, oprnd, inst, reloc);
}
static int
csky_print_operands (char *str, struct csky_opcode_info const *pinfo,
struct disassemble_info *info, CSKY_INST_TYPE inst,
int reloc)
{
int i = 0;
int ret = 0;
if (pinfo->operand_num)
strcat (str, " \t");
if (pinfo->operand_num == -1)
{
ret = csky_print_operand (str, &pinfo->oprnd.oprnds[i], inst, reloc);
if (ret)
return ret;
}
else
for (; i < pinfo->operand_num; i++)
{
if (i != 0)
strcat (str, ", ");
ret = csky_print_operand (str, &pinfo->oprnd.oprnds[i], inst, reloc);
if (ret)
return ret;
}
info->fprintf_func (info->stream, "%s", str);
if (dis_info.need_output_symbol)
{
info->fprintf_func (info->stream, "\t// ");
info->print_address_func (dis_info.value, dis_info.info);
}
return 0;
}
static void
number_to_chars_littleendian (char *buf, CSKY_INST_TYPE val, int n)
{
if (n <= 0)
abort ();
while (n--)
{
*buf++ = val & 0xff;
val >>= 8;
}
}
#define CSKY_READ_DATA() \
{ \
status = info->read_memory_func (memaddr, buf, 2, info); \
if (status) \
{ \
info->memory_error_func (status, memaddr, info); \
return -1; \
} \
if (info->endian == BFD_ENDIAN_BIG) \
inst |= (buf[0] << 8) | buf[1]; \
else if (info->endian == BFD_ENDIAN_LITTLE) \
inst |= (buf[1] << 8) | buf[0]; \
else \
abort(); \
info->bytes_per_chunk += 2; \
memaddr += 2; \
}
int
print_insn_csky (bfd_vma memaddr, struct disassemble_info *info)
{
unsigned char buf[4];
CSKY_INST_TYPE inst = 0;
int status;
char str[256];
long given;
int is_data = FALSE;
void (*printer) (bfd_vma, struct disassemble_info *, long);
unsigned int size = 4;
memset (str, 0, sizeof (str));
info->bytes_per_chunk = 0;
info->bytes_per_chunk = 0;
dis_info.mem = memaddr;
dis_info.info = info;
dis_info.need_output_symbol = 0;
if (mach_flag != INIT_MACH_FLAG && mach_flag != BINARY_MACH_FLAG)
info->mach = mach_flag;
else if (mach_flag == INIT_MACH_FLAG)
mach_flag = info->mach;
if (mach_flag == BINARY_MACH_FLAG && info->endian == BFD_ENDIAN_UNKNOWN)
info->endian = BFD_ENDIAN_LITTLE;
/* First check the full symtab for a mapping symbol, even if there
are no usable non-mapping symbols for this address. */
if (info->symtab_size != 0
&& bfd_asymbol_flavour (*info->symtab) == bfd_target_elf_flavour)
{
bfd_vma addr;
int n;
int last_sym = -1;
enum sym_type type = CUR_TEXT;
if (memaddr <= last_map_addr)
last_map_sym = -1;
/* Start scanning at the start of the function, or wherever
we finished last time. */
n = 0;
if (n < last_map_sym)
n = last_map_sym;
/* Scan up to the location being disassembled. */
for (; n < info->symtab_size; n++)
{
addr = bfd_asymbol_value (info->symtab[n]);
if (addr > memaddr)
break;
if ((info->section == NULL
|| info->section == info->symtab[n]->section)
&& get_sym_code_type (info, n, &type))
last_sym = n;
}
last_map_sym = last_sym;
last_type = type;
is_data = (last_type == CUR_DATA);
if (is_data)
{
size = 4 - ( memaddr & 3);
for (n = last_sym + 1; n < info->symtab_size; n++)
{
addr = bfd_asymbol_value (info->symtab[n]);
if (addr > memaddr)
{
if (addr - memaddr < size)
size = addr - memaddr;
break;
}
}
/* If the next symbol is after three bytes, we need to
print only part of the data, so that we can use either
.byte or .short. */
if (size == 3)
size = (memaddr & 1) ? 1 : 2;
}
}
info->bytes_per_line = 4;
if (is_data)
{
int i;
/* Size was already set above. */
info->bytes_per_chunk = size;
printer = print_insn_data;
status = info->read_memory_func (memaddr, (bfd_byte *) buf, size, info);
given = 0;
if (info->endian == BFD_ENDIAN_LITTLE)
for (i = size - 1; i >= 0; i--)
given = buf[i] | (given << 8);
else
for (i = 0; i < (int) size; i++)
given = buf[i] | (given << 8);
printer (memaddr, info, given);
return info->bytes_per_chunk;
}
/* Handle instructions. */
CSKY_READ_DATA();
if ((inst & 0xc000) == 0xc000 && IS_CSKY_V2 (mach_flag))
{
/* It's a 32-bit instruction. */
inst <<= 16;
CSKY_READ_DATA();
if (info->buffer && (info->endian == BFD_ENDIAN_LITTLE))
{
char* src = (char *)(info->buffer
+ ((memaddr - 4 - info->buffer_vma)
* info->octets_per_byte));
if (info->endian == BFD_ENDIAN_LITTLE)
number_to_chars_littleendian (src, inst, 4);
}
}
if (IS_CSKY_V1 (mach_flag))
g_opcodeP = csky_v1_opcodes;
else
g_opcodeP = csky_v2_opcodes;
do
{
struct csky_opcode const *op;
struct csky_opcode_info const *pinfo = NULL;
int reloc;
memset (str, 0, sizeof (str));
op = csky_find_inst_info (&pinfo, inst, info->bytes_per_chunk);
if (!op)
{
if (IS_CSKY_V1 (mach_flag))
info->fprintf_func (info->stream, ".short: 0x%04x",
(unsigned short)inst);
else
info->fprintf_func (info->stream, ".long: 0x%08x",
(unsigned int)inst);
return info->bytes_per_chunk;
}
if (info->bytes_per_chunk == 2)
reloc = op->reloc16;
else
reloc = op->reloc32;
dis_info.opinfo = pinfo;
strcat (str, op->mnemonic);
if (csky_print_operands (str, pinfo, info, inst, reloc))
g_opcodeP++;
else
break;
} while (1);
return info->bytes_per_chunk;
}
Reference in New Issue View Git Blame Copy Permalink