/* -*- c -*- */
+/* Copyright (C) 2012-2014 Free Software Foundation, Inc.
+ Contributed by Red Hat.
+ Written by DJ Delorie.
+
+ 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 <stdio.h>
#include <stdlib.h>
#include <string.h>
-
-#include "config.h"
#include "ansidecl.h"
#include "opcode/rx.h"
{
RX_Byte,
RX_Word,
- RX_Long
+ RX_Long,
+ 0 /* Bogus instructions can have a size field set to 3. */
};
static int sbwl[] =
{
RX_SByte,
RX_SWord,
- RX_Long
+ RX_Long,
+ 0 /* Bogus instructions can have a size field set to 3. */
};
static int ubwl[] =
{
RX_UByte,
RX_UWord,
- RX_Long
+ RX_Long,
+ 0 /* Bogus instructions can have a size field set to 3. */
};
static int memex[] =
rx->op[n].size = s )
/* This is for the BWL and BW bitfields. */
-static int SCALE[] = { 1, 2, 4 };
+static int SCALE[] = { 1, 2, 4, 0 };
/* This is for the prefix size enum. */
static int PSCALE[] = { 4, 1, 1, 1, 2, 2, 2, 3, 4 };
#define SC(i) OP (1, RX_Operand_Immediate, 0, i)
#define SR(r) OP (1, RX_Operand_Register, r, 0)
+#define SRR(r) OP (1, RX_Operand_TwoReg, r, 0)
#define SI(r,a) OP (1, RX_Operand_Indirect, r, a)
#define SIs(r,a,s) OP (1, RX_Operand_Indirect, r, (a) * SCALE[s])
#define SD(t,r,s) rx_disp (1, t, r, bwl[s], ld);
ID(mov); DR(rdst); SC(IMM (1)); F_____;
/** 1111 10sd rdst im sz mov%s #%1, %0 */
- ID(mov); sBWL (sz); DD(sd, rdst, sz); SC(IMMex(im)); F_____;
+ ID(mov); DD(sd, rdst, sz);
+ if ((im == 1 && sz == 0)
+ || (im == 2 && sz == 1)
+ || (im == 0 && sz == 2))
+ {
+ BWL (sz);
+ SC(IMM(im));
+ }
+ else
+ {
+ sBWL (sz);
+ SC(IMMex(im));
+ }
+ F_____;
/** 0110 0110 immm rdst mov%s #%1, %0 */
ID(mov); DR(rdst); SC(immm); F_____;
ID(mov); sBWL (sz); DIs(dst, d*16+sppp, sz); SC(IMM(1)); F_____;
/** 11sz sd ss rsrc rdst mov%s %1, %0 */
- ID(mov); sBWL(sz); F_____;
- if ((ss == 3) && (sd != 3))
+ if (sd == 3 && ss == 3 && sz == 2 && rsrc == 0 && rdst == 0)
{
- SD(ss, rdst, sz); DD(sd, rsrc, sz);
+ ID(nop2);
+ rx->syntax = "nop";
}
else
{
- SD(ss, rsrc, sz); DD(sd, rdst, sz);
+ ID(mov); sBWL(sz); F_____;
+ if ((ss == 3) && (sd != 3))
+ {
+ SD(ss, rdst, sz); DD(sd, rsrc, sz);
+ }
+ else
+ {
+ SD(ss, rsrc, sz); DD(sd, rdst, sz);
+ }
}
/** 10sz 1dsp a src b dst mov%s %1, %0 */
ID(mov); sBWL(sz); DIs(dst, dsp*4+a*2+b, sz); SR(src); F_____;
/** 1111 1110 01sz isrc bsrc rdst mov%s [%1, %2], %0 */
- ID(movbi); sBWL(sz); DR(rdst); SR(isrc); S2R(bsrc); F_____;
+ ID(movbi); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
/** 1111 1110 00sz isrc bsrc rdst mov%s %0, [%1, %2] */
- ID(movbir); sBWL(sz); DR(rdst); SR(isrc); S2R(bsrc); F_____;
+ ID(movbir); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
/** 1111 1110 11sz isrc bsrc rdst movu%s [%1, %2], %0 */
- ID(movbi); uBWL(sz); DR(rdst); SR(isrc); S2R(bsrc); F_____;
+ ID(movbi); uBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____;
/** 1111 1101 0010 0p sz rdst rsrc mov%s %1, %0 */
ID(mov); sBWL (sz); SR(rsrc); F_____;
ID(max); DR(rdst); SC(IMMex(im));
/** 1111 1100 0001 00ss rsrc rdst max %1%S1, %0 */
- ID(max); SP(ss, rsrc); DR(rdst);
+ if (ss == 3 && rsrc == 0 && rdst == 0)
+ {
+ ID(nop3);
+ rx->syntax = "nop";
+ }
+ else
+ {
+ ID(max); SP(ss, rsrc); DR(rdst);
+ }
/** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max %1%S1, %0 */
ID(max); SPm(ss, rsrc, mx); DR(rdst);
/** 0000 1dsp bra.s %a0 */
- ID(branch); Scc(RXC_always); DC(pc + dsp3map[dsp]);
+ ID(branch); DC(pc + dsp3map[dsp]);
/** 0010 1110 bra.b %a0 */
- ID(branch); Scc(RXC_always); DC(pc + IMMex(1));
+ ID(branch); DC(pc + IMMex(1));
/** 0011 1000 bra.w %a0 */
- ID(branch); Scc(RXC_always); DC(pc + IMMex(2));
+ ID(branch); DC(pc + IMMex(2));
/** 0000 0100 bra.a %a0 */
- ID(branch); Scc(RXC_always); DC(pc + IMMex(3));
+ ID(branch); DC(pc + IMMex(3));
/** 0111 1111 0100 rsrc bra.l %0 */
- ID(branchrel); Scc(RXC_always); DR(rsrc);
+ ID(branchrel); DR(rsrc);
/** 0111 1111 0000 rsrc jmp %0 */
- ID(branch); Scc(RXC_always); DR(rsrc);
+ ID(branch); DR(rsrc);
/** 0111 1111 0001 rsrc jsr %0 */
ID(jsr); DR(rsrc);
/** 1111 1100 0110 00sd rdst rsrc bset %1, %0%S0 */
ID(bset); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____;
+ if (sd == 3) /* bset reg,reg */
+ BWL(LSIZE);
/** 0111 100b ittt rdst bset #%1, %0 */
ID(bset); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____;
/** 1111 1100 0110 01sd rdst rsrc bclr %1, %0%S0 */
ID(bclr); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____;
+ if (sd == 3) /* bset reg,reg */
+ BWL(LSIZE);
/** 0111 101b ittt rdst bclr #%1, %0 */
ID(bclr); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____;
/** 1111 1100 0110 10sd rdst rsrc btst %2, %1%S1 */
ID(btst); BWL(BSIZE); S2R(rsrc); SD(sd, rdst, BSIZE); F___ZC;
+ if (sd == 3) /* bset reg,reg */
+ BWL(LSIZE);
/** 0111 110b ittt rdst btst #%2, %1 */
ID(btst); BWL(LSIZE); S2C(b*16+ittt); SR(rdst); F___ZC;
/** 1111 1100 0110 11sd rdst rsrc bnot %1, %0%S0 */
ID(bnot); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE);
+ if (sd == 3) /* bset reg,reg */
+ BWL(LSIZE);
/** 1111 1101 111bittt 1111 rdst bnot #%1, %0 */
ID(bnot); BWL(LSIZE); SC(bittt); DR(rdst);
projects / platform / upstream / binutils.git / blobdiff