mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-12-21 16:23:28 +08:00
233 lines
6.2 KiB
C
233 lines
6.2 KiB
C
/* tilepro-dis.c. Disassembly routines for the TILEPro architecture.
|
|
Copyright (C) 2011-2016 Free Software Foundation, Inc.
|
|
|
|
This file is part of the GNU opcodes library.
|
|
|
|
This program 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 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program 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 <stddef.h>
|
|
#include <assert.h>
|
|
#include "bfd.h"
|
|
#include "elf/tilepro.h"
|
|
#include "elf-bfd.h"
|
|
#include "dis-asm.h"
|
|
#include "opcode/tilepro.h"
|
|
|
|
|
|
#define TREG_ZERO 63
|
|
|
|
static int
|
|
contains_insn (tilepro_mnemonic expected_mnemonic,
|
|
int expected_first_operand,
|
|
int expected_second_operand,
|
|
bfd_vma memaddr,
|
|
int *last_operand_ret,
|
|
disassemble_info *info)
|
|
{
|
|
struct tilepro_decoded_instruction
|
|
decoded[TILEPRO_MAX_INSTRUCTIONS_PER_BUNDLE];
|
|
bfd_byte opbuf[TILEPRO_BUNDLE_SIZE_IN_BYTES];
|
|
int i, num_instructions;
|
|
|
|
if ((*info->read_memory_func) (memaddr, opbuf,
|
|
TILEPRO_BUNDLE_SIZE_IN_BYTES, info) != 0)
|
|
/* If we cannot even read the memory, it obviously does not have the
|
|
instruction for which we are looking. */
|
|
return 0;
|
|
|
|
/* Parse the instructions in the bundle. */
|
|
num_instructions = parse_insn_tilepro (bfd_getl64 (opbuf), memaddr, decoded);
|
|
|
|
for (i = 0; i < num_instructions; i++)
|
|
{
|
|
const struct tilepro_opcode *opcode = decoded[i].opcode;
|
|
|
|
if (opcode->mnemonic != expected_mnemonic)
|
|
continue;
|
|
|
|
if (expected_first_operand != -1
|
|
&& decoded[i].operand_values[0] != expected_first_operand)
|
|
continue;
|
|
|
|
if (expected_second_operand != -1
|
|
&& decoded[i].operand_values[1] != expected_second_operand)
|
|
continue;
|
|
|
|
*last_operand_ret = decoded[i].operand_values[opcode->num_operands - 1];
|
|
return 1;
|
|
}
|
|
|
|
/* No match. */
|
|
return 0;
|
|
}
|
|
|
|
|
|
int
|
|
print_insn_tilepro (bfd_vma memaddr, disassemble_info *info)
|
|
{
|
|
struct tilepro_decoded_instruction
|
|
decoded[TILEPRO_MAX_INSTRUCTIONS_PER_BUNDLE];
|
|
bfd_byte opbuf[TILEPRO_BUNDLE_SIZE_IN_BYTES];
|
|
int status, i, num_instructions, num_printed;
|
|
tilepro_mnemonic padding_mnemonic;
|
|
|
|
status = (*info->read_memory_func) (memaddr, opbuf,
|
|
TILEPRO_BUNDLE_SIZE_IN_BYTES, info);
|
|
if (status != 0)
|
|
{
|
|
(*info->memory_error_func) (status, memaddr, info);
|
|
return -1;
|
|
}
|
|
|
|
info->bytes_per_line = TILEPRO_BUNDLE_SIZE_IN_BYTES;
|
|
info->bytes_per_chunk = TILEPRO_BUNDLE_SIZE_IN_BYTES;
|
|
info->octets_per_byte = 1;
|
|
info->display_endian = BFD_ENDIAN_LITTLE;
|
|
|
|
/* Parse the instructions in the bundle. */
|
|
num_instructions = parse_insn_tilepro (bfd_getl64 (opbuf), memaddr, decoded);
|
|
|
|
/* Print the instructions in the bundle. */
|
|
info->fprintf_func (info->stream, "{ ");
|
|
num_printed = 0;
|
|
|
|
/* Determine which nop opcode is used for padding and should be skipped. */
|
|
padding_mnemonic = TILEPRO_OPC_FNOP;
|
|
for (i = 0; i < num_instructions; i++)
|
|
{
|
|
if (!decoded[i].opcode->can_bundle)
|
|
{
|
|
/* Instructions that cannot be bundled are padded out with nops,
|
|
rather than fnops. Displaying them is always clutter. */
|
|
padding_mnemonic = TILEPRO_OPC_NOP;
|
|
break;
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < num_instructions; i++)
|
|
{
|
|
const struct tilepro_opcode *opcode = decoded[i].opcode;
|
|
const char *name;
|
|
int j;
|
|
|
|
/* Do not print out fnops, unless everything is an fnop, in
|
|
which case we will print out just the last one. */
|
|
if (opcode->mnemonic == padding_mnemonic
|
|
&& (num_printed > 0 || i + 1 < num_instructions))
|
|
continue;
|
|
|
|
if (num_printed > 0)
|
|
info->fprintf_func (info->stream, " ; ");
|
|
++num_printed;
|
|
|
|
name = opcode->name;
|
|
if (name == NULL)
|
|
name = "<invalid>";
|
|
info->fprintf_func (info->stream, "%s", name);
|
|
|
|
for (j = 0; j < opcode->num_operands; j++)
|
|
{
|
|
int num;
|
|
const struct tilepro_operand *op;
|
|
const char *spr_name;
|
|
|
|
if (j > 0)
|
|
info->fprintf_func (info->stream, ",");
|
|
info->fprintf_func (info->stream, " ");
|
|
|
|
num = decoded[i].operand_values[j];
|
|
|
|
op = decoded[i].operands[j];
|
|
switch (op->type)
|
|
{
|
|
case TILEPRO_OP_TYPE_REGISTER:
|
|
info->fprintf_func (info->stream, "%s",
|
|
tilepro_register_names[num]);
|
|
break;
|
|
|
|
case TILEPRO_OP_TYPE_SPR:
|
|
spr_name = get_tilepro_spr_name(num);
|
|
if (spr_name != NULL)
|
|
info->fprintf_func (info->stream, "%s", spr_name);
|
|
else
|
|
info->fprintf_func (info->stream, "%d", num);
|
|
break;
|
|
|
|
case TILEPRO_OP_TYPE_IMMEDIATE:
|
|
{
|
|
bfd_vma addr = 0;
|
|
int found_addr = 0;
|
|
int addr_piece;
|
|
|
|
switch (opcode->mnemonic)
|
|
{
|
|
case TILEPRO_OPC_ADDLI:
|
|
if (contains_insn (TILEPRO_OPC_AULI,
|
|
decoded[i].operand_values[1],
|
|
TREG_ZERO,
|
|
memaddr - TILEPRO_BUNDLE_SIZE_IN_BYTES,
|
|
&addr_piece,
|
|
info))
|
|
{
|
|
addr = num + (addr_piece << 16);
|
|
found_addr = 1;
|
|
}
|
|
break;
|
|
|
|
case TILEPRO_OPC_AULI:
|
|
if (contains_insn (TILEPRO_OPC_MOVELI,
|
|
decoded[i].operand_values[1],
|
|
-1,
|
|
memaddr - TILEPRO_BUNDLE_SIZE_IN_BYTES,
|
|
&addr_piece,
|
|
info))
|
|
{
|
|
addr = (num << 16) + addr_piece;
|
|
found_addr = 1;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
/* Operand does not look like a constructed address. */
|
|
break;
|
|
}
|
|
|
|
info->fprintf_func (info->stream, "%d", num);
|
|
|
|
if (found_addr)
|
|
{
|
|
info->fprintf_func (info->stream, " /* ");
|
|
info->print_address_func (addr, info);
|
|
info->fprintf_func (info->stream, " */");
|
|
}
|
|
}
|
|
break;
|
|
|
|
case TILEPRO_OP_TYPE_ADDRESS:
|
|
info->print_address_func ((bfd_vma)(unsigned int) num, info);
|
|
break;
|
|
|
|
default:
|
|
abort ();
|
|
}
|
|
}
|
|
}
|
|
info->fprintf_func (info->stream, " }");
|
|
|
|
return TILEPRO_BUNDLE_SIZE_IN_BYTES;
|
|
}
|