mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-11-25 02:53:48 +08:00
d87bef3a7b
The newer update-copyright.py fixes file encoding too, removing cr/lf on binutils/bfdtest2.c and ld/testsuite/ld-cygwin/exe-export.exp, and embedded cr in binutils/testsuite/binutils-all/ar.exp string match.
371 lines
12 KiB
C
371 lines
12 KiB
C
/* xgate-dis.c -- Freescale XGATE disassembly
|
|
Copyright (C) 2009-2023 Free Software Foundation, Inc.
|
|
Written by Sean Keys (skeys@ipdatasys.com)
|
|
|
|
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 <assert.h>
|
|
#include "disassemble.h"
|
|
#include "opintl.h"
|
|
#include "libiberty.h"
|
|
#include "ansidecl.h"
|
|
#include "opcode/xgate.h"
|
|
|
|
#define XGATE_TWO_BYTES 0x02
|
|
#define XGATE_NINE_BITS 0x1FF
|
|
#define XGATE_TEN_BITS 0x3FF
|
|
#define XGATE_NINE_SIGNBIT 0x100
|
|
#define XGATE_TEN_SIGNBIT 0x200
|
|
|
|
/* Structures. */
|
|
struct decodeInfo
|
|
{
|
|
unsigned int operMask;
|
|
unsigned int operMasksRegisterBits;
|
|
struct xgate_opcode *opcodePTR;
|
|
};
|
|
|
|
/* Prototypes for local functions. */
|
|
static int print_insn (bfd_vma, struct disassemble_info *);
|
|
static int read_memory (bfd_vma, bfd_byte*, int, struct disassemble_info *);
|
|
static int ripBits (unsigned int *, int,
|
|
struct xgate_opcode *, unsigned int);
|
|
static int macro_search (char *, char *);
|
|
static struct decodeInfo * find_match (unsigned int);
|
|
|
|
/* Statics. */
|
|
static struct decodeInfo *decodeTable;
|
|
static int initialized;
|
|
static char previousOpName[10];
|
|
static unsigned int perviousBin;
|
|
|
|
/* Disassemble one instruction at address 'memaddr'. Returns the number
|
|
of bytes used by that instruction. */
|
|
|
|
static int
|
|
print_insn (bfd_vma memaddr, struct disassemble_info* info)
|
|
{
|
|
int status;
|
|
unsigned int raw_code;
|
|
char *s = 0;
|
|
long bytesRead = 0;
|
|
int i = 0;
|
|
struct xgate_opcode *opcodePTR = (struct xgate_opcode*) xgate_opcodes;
|
|
struct decodeInfo *decodeTablePTR = 0;
|
|
struct decodeInfo *decodePTR = 0;
|
|
unsigned int operandRegisterBits = 0;
|
|
signed int relAddr = 0;
|
|
signed int operandOne = 0;
|
|
signed int operandTwo = 0;
|
|
bfd_byte buffer[4];
|
|
bfd_vma absAddress;
|
|
|
|
unsigned int operMaskReg = 0;
|
|
/* Initialize our array of opcode masks and check them against our constant
|
|
table. */
|
|
if (!initialized)
|
|
{
|
|
decodeTable = xmalloc (sizeof (struct decodeInfo) * xgate_num_opcodes);
|
|
for (i = 0, decodeTablePTR = decodeTable; i < xgate_num_opcodes;
|
|
i++, decodeTablePTR++, opcodePTR++)
|
|
{
|
|
unsigned int bin = 0;
|
|
unsigned int mask = 0;
|
|
for (s = opcodePTR->format; *s; s++)
|
|
{
|
|
bin <<= 1;
|
|
mask <<= 1;
|
|
operandRegisterBits <<= 1;
|
|
bin |= (*s == '1');
|
|
mask |= (*s == '0' || *s == '1');
|
|
operandRegisterBits |= (*s == 'r');
|
|
}
|
|
/* Asserting will uncover inconsistencies in our table. */
|
|
assert ((s - opcodePTR->format) == 16 || (s - opcodePTR->format) == 32);
|
|
assert (opcodePTR->bin_opcode == bin);
|
|
|
|
decodeTablePTR->operMask = mask;
|
|
decodeTablePTR->operMasksRegisterBits = operandRegisterBits;
|
|
decodeTablePTR->opcodePTR = opcodePTR;
|
|
}
|
|
initialized = 1;
|
|
}
|
|
|
|
/* Read 16 bits. */
|
|
bytesRead += XGATE_TWO_BYTES;
|
|
status = read_memory (memaddr, buffer, XGATE_TWO_BYTES, info);
|
|
if (status == 0)
|
|
{
|
|
raw_code = buffer[0];
|
|
raw_code <<= 8;
|
|
raw_code += buffer[1];
|
|
|
|
decodePTR = find_match (raw_code);
|
|
if (decodePTR)
|
|
{
|
|
operMaskReg = decodePTR->operMasksRegisterBits;
|
|
(*info->fprintf_func)(info->stream, "%s", decodePTR->opcodePTR->name);
|
|
|
|
/* First we compare the shorthand format of the constraints. If we
|
|
still are unable to pinpoint the operands
|
|
we analyze the opcodes constraint string. */
|
|
if (!strcmp (decodePTR->opcodePTR->constraints, XGATE_OP_MON_R_C))
|
|
{
|
|
(*info->fprintf_func)(info->stream, " R%x, CCR",
|
|
(raw_code >> 8) & 0x7);
|
|
}
|
|
else if (!strcmp (decodePTR->opcodePTR->constraints, XGATE_OP_MON_C_R))
|
|
{
|
|
(*info->fprintf_func)(info->stream, " CCR, R%x",
|
|
(raw_code >> 8) & 0x7);
|
|
}
|
|
else if (!strcmp (decodePTR->opcodePTR->constraints, XGATE_OP_MON_R_P))
|
|
{
|
|
(*info->fprintf_func)(info->stream, " R%x, PC",
|
|
(raw_code >> 8) & 0x7);
|
|
}
|
|
else if (!strcmp (decodePTR->opcodePTR->constraints, XGATE_OP_TRI))
|
|
{
|
|
(*info->fprintf_func)(info->stream, " R%x, R%x, R%x",
|
|
(raw_code >> 8) & 0x7, (raw_code >> 5) & 0x7,
|
|
(raw_code >> 2) & 0x7);
|
|
}
|
|
else if (!strcmp (decodePTR->opcodePTR->constraints, XGATE_OP_IDR))
|
|
{
|
|
if (raw_code & 0x01)
|
|
{
|
|
(*info->fprintf_func)(info->stream, " R%x, (R%x, R%x+)",
|
|
(raw_code >> 8) & 0x7, (raw_code >> 5) & 0x7,
|
|
(raw_code >> 2) & 0x7);
|
|
}
|
|
else if (raw_code & 0x02)
|
|
{
|
|
(*info->fprintf_func)(info->stream, " R%x, (R%x, -R%x)",
|
|
(raw_code >> 8) & 0x7, (raw_code >> 5) & 0x7,
|
|
(raw_code >> 2) & 0x7);
|
|
}
|
|
else
|
|
{
|
|
(*info->fprintf_func)(info->stream, " R%x, (R%x, R%x)",
|
|
(raw_code >> 8) & 0x7, (raw_code >> 5) & 0x7,
|
|
(raw_code >> 2) & 0x7);
|
|
}
|
|
}
|
|
else if (!strcmp (decodePTR->opcodePTR->constraints, XGATE_OP_DYA))
|
|
{
|
|
operandOne = ripBits (&operMaskReg, 3, decodePTR->opcodePTR, raw_code);
|
|
operandTwo = ripBits (&operMaskReg, 3, decodePTR->opcodePTR, raw_code);
|
|
( *info->fprintf_func)(info->stream, " R%x, R%x", operandOne,
|
|
operandTwo);
|
|
}
|
|
else if (!strcmp (decodePTR->opcodePTR->constraints, XGATE_OP_IDO5))
|
|
{
|
|
(*info->fprintf_func)(info->stream, " R%x, (R%x, #0x%x)",
|
|
(raw_code >> 8) & 0x7, (raw_code >> 5) & 0x7, raw_code & 0x1f);
|
|
}
|
|
else if (!strcmp (decodePTR->opcodePTR->constraints, XGATE_OP_MON))
|
|
{
|
|
operandOne = ripBits (&operMaskReg, 3, decodePTR->opcodePTR,
|
|
raw_code);
|
|
(*info->fprintf_func)(info->stream, " R%x", operandOne);
|
|
}
|
|
else if (!strcmp (decodePTR->opcodePTR->constraints, XGATE_OP_REL9))
|
|
{
|
|
/* If address is negative handle it accordingly. */
|
|
if (raw_code & XGATE_NINE_SIGNBIT)
|
|
{
|
|
relAddr = XGATE_NINE_BITS >> 1; /* Clip sign bit. */
|
|
relAddr = ~relAddr; /* Make signed. */
|
|
relAddr |= (raw_code & 0xFF) + 1; /* Apply our value. */
|
|
relAddr *= 2; /* Multiply by two as per processor docs. */
|
|
}
|
|
else
|
|
{
|
|
relAddr = raw_code & 0xff;
|
|
relAddr = relAddr * 2 + 2;
|
|
}
|
|
(*info->fprintf_func)(info->stream, " *%d", relAddr);
|
|
(*info->fprintf_func)(info->stream, " Abs* 0x");
|
|
(*info->print_address_func)(memaddr + relAddr, info);
|
|
}
|
|
else if (!strcmp (decodePTR->opcodePTR->constraints, XGATE_OP_REL10))
|
|
{
|
|
/* If address is negative handle it accordingly. */
|
|
if (raw_code & XGATE_TEN_SIGNBIT)
|
|
{
|
|
relAddr = XGATE_TEN_BITS >> 1; /* Clip sign bit. */
|
|
relAddr = ~relAddr; /* Make signed. */
|
|
relAddr |= (raw_code & 0x1FF) + 1; /* Apply our value. */
|
|
relAddr *= 2; /* Multiply by two as per processor docs. */
|
|
}
|
|
else
|
|
{
|
|
relAddr = raw_code & 0x1FF;
|
|
relAddr = relAddr * 2 + 2;
|
|
}
|
|
(*info->fprintf_func)(info->stream, " *%d", relAddr);
|
|
(*info->fprintf_func)(info->stream, " Abs* 0x");
|
|
(*info->print_address_func)(memaddr + relAddr, info);
|
|
}
|
|
else if (!strcmp (decodePTR->opcodePTR->constraints, XGATE_OP_IMM4))
|
|
{
|
|
(*info->fprintf_func)(info->stream, " R%x, #0x%02x",
|
|
(raw_code >> 8) & 0x7, (raw_code >> 4) & 0xF);
|
|
}
|
|
else if (!strcmp (decodePTR->opcodePTR->constraints, XGATE_OP_IMM8))
|
|
{
|
|
if (macro_search (decodePTR->opcodePTR->name, previousOpName) &&
|
|
previousOpName[0])
|
|
{
|
|
absAddress = (0xFF & raw_code) << 8;
|
|
absAddress |= perviousBin & 0xFF;
|
|
(*info->fprintf_func)(info->stream, " R%x, #0x%02x Abs* 0x",
|
|
(raw_code >> 8) & 0x7, raw_code & 0xff);
|
|
(*info->print_address_func)(absAddress, info);
|
|
previousOpName[0] = 0;
|
|
}
|
|
else
|
|
{
|
|
strcpy (previousOpName, decodePTR->opcodePTR->name);
|
|
(*info->fprintf_func)(info->stream, " R%x, #0x%02x",
|
|
(raw_code >> 8) & 0x7, raw_code & 0xff);
|
|
}
|
|
}
|
|
else if (!strcmp (decodePTR->opcodePTR->constraints, XGATE_OP_IMM3))
|
|
{
|
|
(*info->fprintf_func)(info->stream, " #0x%x",
|
|
(raw_code >> 8) & 0x7);
|
|
}
|
|
else if (!strcmp (decodePTR->opcodePTR->constraints, XGATE_OP_INH))
|
|
{
|
|
}
|
|
else
|
|
{
|
|
(*info->fprintf_func)(info->stream, " unhandled mode %s",
|
|
decodePTR->opcodePTR->constraints);
|
|
}
|
|
perviousBin = raw_code;
|
|
}
|
|
else
|
|
{
|
|
(*info->fprintf_func)(info->stream,
|
|
" unable to find opcode match #0%x", raw_code);
|
|
}
|
|
}
|
|
return bytesRead;
|
|
}
|
|
|
|
int
|
|
print_insn_xgate (bfd_vma memaddr, struct disassemble_info* info)
|
|
{
|
|
return print_insn (memaddr, info);
|
|
}
|
|
|
|
static int
|
|
read_memory (bfd_vma memaddr, bfd_byte* buffer, int size,
|
|
struct disassemble_info* info)
|
|
{
|
|
int status;
|
|
status = (*info->read_memory_func) (memaddr, buffer, size, info);
|
|
if (status != 0)
|
|
{
|
|
(*info->memory_error_func) (status, memaddr, info);
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
ripBits (unsigned int *operandBitsRemaining,
|
|
int numBitsRequested,
|
|
struct xgate_opcode *opcodePTR,
|
|
unsigned int memory)
|
|
{
|
|
unsigned int currentBit;
|
|
unsigned int operand = 0;
|
|
int numBitsFound;
|
|
|
|
for (numBitsFound = 0, currentBit = 1u << ((opcodePTR->size * 8) - 1);
|
|
numBitsFound < numBitsRequested && currentBit != 0;
|
|
currentBit >>= 1)
|
|
{
|
|
if (currentBit & *operandBitsRemaining)
|
|
{
|
|
*operandBitsRemaining &= ~(currentBit); /* Consume the current bit. */
|
|
operand <<= 1; /* Make room for our next bit. */
|
|
numBitsFound++;
|
|
operand |= (currentBit & memory) > 0;
|
|
}
|
|
}
|
|
return operand;
|
|
}
|
|
|
|
static int
|
|
macro_search (char *currentName, char *lastName)
|
|
{
|
|
int i;
|
|
int length = 0;
|
|
char *where;
|
|
|
|
for (i = 0; i < xgate_num_opcodes; i++)
|
|
{
|
|
where = strstr (xgate_opcodes[i].constraints, lastName);
|
|
|
|
if (where)
|
|
{
|
|
length = strlen (where);
|
|
}
|
|
if (length)
|
|
{
|
|
where = strstr (xgate_opcodes[i].constraints, currentName);
|
|
if (where)
|
|
{
|
|
length = strlen (where);
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static struct decodeInfo *
|
|
find_match (unsigned int raw_code)
|
|
{
|
|
struct decodeInfo *decodeTablePTR = 0;
|
|
int i;
|
|
|
|
for (i = 0, decodeTablePTR = decodeTable; i < xgate_num_opcodes;
|
|
i++, decodeTablePTR++)
|
|
{
|
|
if ((raw_code & decodeTablePTR->operMask)
|
|
== decodeTablePTR->opcodePTR->bin_opcode)
|
|
{
|
|
/* Make sure we didn't run into a macro or alias. */
|
|
if (decodeTablePTR->opcodePTR->cycles_min != 0)
|
|
{
|
|
return decodeTablePTR;
|
|
break;
|
|
}
|
|
else
|
|
continue;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|