-/* code generator for the Hitachi H8/300 architecture simulator.
- Copyright (C) 1990-1991 Free Software Foundation, Inc.
- Hacked by Steve Chamberlain of Cygnus Support.
+/* Code generator for the Hitachi H8/300 architecture simulator.
-This file is part of BFD, the Binary File Descriptor library.
+ Written by Steve Chamberlain of Cygnus Support.
+ sac@cygnus.com
-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 2 of the License, or
-(at your option) any later version.
+ This file is part of H8/300 sim
-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., 675 Mass Ave, Cambridge, MA 02139, USA. */
+ THIS SOFTWARE IS NOT COPYRIGHTED
+
+ Cygnus offers the following for use in the public domain. Cygnus
+ makes no warranty with regard to the software or it's performance
+ and the user accepts the software "AS IS" with all faults.
+
+ CYGNUS DISCLAIMS ANY WARRANTIES, EXPRESS OR IMPLIED, WITH REGARD TO
+ THIS SOFTWARE INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+
+*/
/* This program reads the H8/300 opcode table and writes out
a large switch statement to understand the opcodes (with ifs if
there is more than one opcode per case) and code to do the stuff */
-#include "bfd.h"
-#include "sysdep.h"
+#include <stdio.h>
#define DEFINE_TABLE
#define INSIM
#include"opcode/h8300.h"
-#define MAXSAME 14
+#define MAXSAME 140
#define PTWO 256
static struct h8_opcode *h8_opcodes_sorted[PTWO][MAXSAME];
{"foo",
"*(blow[b0])",
"*(bhigh[b1])",
- "*(blow[b1])"};
+ "*(blow[b1])",
+ 0, 0,
+ "*(bhigh[pc[1]>>8])"};
/* How to get at a word register from an index in the instruction at
nibble n */
int n1 = 0;
int n2 = 0;
int j;
-
+#if 0
for (j = 0; p->data.nib[j] != E; j++)
{
if ((int) p->data.nib[j] == ABS16ORREL8SRC)
if ((int) p->data.nib[j] == ABS16OR8DST)
p->data.nib[j] = ABS16DST;
}
+#endif
+
if ((int) p->data.nib[0] < 16)
{
n1 = (int) p->data.nib[0];
}
}
-/* either fetch srca&srcb or store dst */
+/* decode the lvalues, creating a pointer in real space to object -
+ remember if the thing has to be swapped out of where it is */
-void
-decode (p, fetch, size)
+
+int swap[2];
+
+lval (p)
struct h8_opcode *p;
- int fetch;
- int size;
{
int i;
- char *ss = size == 8 ? "BYTE" : "WORD";
for (i = 0; p->data.nib[i] != E; i++)
{
- switch (p->data.nib[i])
+ int x = p->data.nib[i];
+ int size;
+ int op;
+ op = (x & DST) ? 1 : 0;
+
+ switch (x & SIZE)
{
- case RS8:
- if (fetch)
- printf ("srca = %s;\n", breg[i]);
+ case L_32:
+ size = 32;
break;
- case RS16 | B30:
- case RS16 | B31:
- case RS16:
- if (fetch)
- printf ("srca = %s;\n", wreg[i]);
+ case L_16:
+ size = 16;
break;
- case RD8:
- if (fetch)
- printf ("srcb = %s;\n", breg[i]);
- else
- printf ("%s = dst;\n", breg[i]);
- break;
- case RD16 | B30:
- case RD16 | B31:
- case RD16:
- if (fetch)
- printf ("srcb = %s;\n", wreg[i]);
- else
- printf ("%s =dst;\n", wreg[i]);
+ case L_8:
+ size = 8;
break;
- case IMM8:
- if (fetch)
- printf ("srca = b1;\n");
- break;
- case RSINC:
- case RSINC | B30:
- case RSINC | B31:
+ default:
+ size = 1234;
+ }
- if (fetch)
- {
- printf ("srca = %s_MEM(%s);\n", ss, wreg[i]);
- printf ("%s+=%d;\n", wreg[i], size / 8);
- }
- break;
- case RSIND:
- case RSIND | B30:
- case RSIND | B31:
- if (fetch)
- {
- printf ("lval = %s;\n", wreg[i]);
- printf ("srca = %s_MEM(lval);\n", ss);
- }
- break;
+ if (x & REG)
+ {
+ printf ("ir%d = GET_LVAL_%d_REG(%d);\n", op, size, i);
+ }
+ else if (x & IMM)
+ {
+ printf ("/* Imm has no lvalue */\n");
+ }
- case RDIND:
- case RDIND | B30:
- case RDIND | B31:
- if (fetch)
- {
- printf ("lval = %s;\n", wreg[i]);
- printf ("srcb = %s_MEM(lval);\n", ss);
- }
- else
- {
- printf ("SET_%s_MEM(lval,dst);\n", ss);
- }
- break;
+ }
- case MEMIND:
- if (fetch)
- {
- printf ("lval = pc[1];\n");
- }
- break;
- case RDDEC:
- case RDDEC | B30:
- case RDDEC | B31:
- if (!fetch)
- {
- printf ("%s -=%d;\n", wreg[i], size / 8);
- printf ("SET_%s_MEM(%s, dst);\n", ss, wreg[i]);
- }
- break;
- case IMM3:
- case IMM3 | B31:
- case IMM3 | B30:
- if (fetch)
- printf ("srca = %s;\n", imm3[i]);
- break;
- case IMM16:
- if (fetch)
- printf ("srca =( pc[1]);\n");
- break;
- case ABS8SRC:
- if (fetch)
- {
- printf ("lval = (0xff00) + b1;\n");
- printf ("srca = BYTE_MEM(lval);\n");
- }
+}
- break;
- case ABS8DST:
- if (fetch)
- {
- printf ("lval = (0xff00) + b1;\n");
- printf ("srcb = BYTE_MEM(lval);\n");
- }
- else
- {
- printf ("SET_BYTE_MEM(lval,dst);\n");
- }
- break;
- case KBIT:
- if (fetch)
- printf ("srca = ((b1&0x80)?2:1);\n");
- break;
- case ABS16ORREL8SRC:
- case ABS16SRC:
- if (fetch)
- {
- printf ("lval = pc[1];\n");
- printf ("srca = %s_MEM(lval);\n", size == 8 ? "BYTE" : "WORD");
- }
- break;
- case DISPREG | B30:
- case DISPREG | B31:
- case DISPREG:
- printf ("rn = %s & 0x7;\n", nibs[i]);
- break;
- case DISPSRC:
- if (fetch)
- {
- printf ("lval = 0xffff&(pc[1] +reg[rn]);\n");
- printf ("srca = %s_MEM(lval);\n", size == 8 ? "BYTE" : "WORD");
- }
- break;
- case DISPDST:
- if (fetch)
- {
- printf ("lval = 0xffff&(pc[1] +reg[rn]);\n");
- printf ("srcb = %s_MEM(lval);\n", size == 8 ? "BYTE" : "WORD");
- }
- else
- {
- printf ("SET_%s_MEM(lval,dst);\n", ss);
- }
- break;
- case ABS16DST:
- if (fetch)
- {
- printf ("lval = (pc[1]);\n");
- printf ("srcb = %s_MEM(lval);\n", ss);
- }
- else
- {
- printf ("SET_%s_MEM(lval,dst);\n", ss);
- }
- break;
- case IGNORE:
- break;
- case DISP8:
- printf (" /* DISP8 handled in opcode */\n");
- break;
- default:
- if (p->data.nib[i] > HexF)
- {
- printf ("saved_state.exception = SIGILL;\n");
- }
- }
+void
+decode (p, fetch, size)
+ struct h8_opcode *p;
+ int fetch;
+ int size;
+{
+ if (fetch)
+ {
+ lval (p);
}
+
}
+
static void
esleep ()
{
printf ("reg[7]-=2;\n");
printf ("tmp = reg[7];\n");
printf ("SET_WORD_MEM(tmp, (npc-saved_state.mem)*2);\n");
- printf ("npc += (((char *)pc)[1])>>1;\n");
+ printf ("npc += ((char)b1)>>1;\n");
}
static void
printf ("tmp = reg[7];\n");
printf ("reg[7]+=2;\n");
printf ("SET_CCR(tmp);\n");
- printf("npc = saved_state.mem + (WORD_MEM(tmp)>>1);\n");
+ printf ("npc = saved_state.mem + (WORD_MEM(tmp)>>1);\n");
}
static void
}
-table [] =
-{
- { nx, 1, "bld", bit, "dst = srcb; c = (srcb>>srca)&1;", 8 } ,
- { nx, 1, "bild", bit, "dst = srcb; c = !((srcb>>srca)&1);", 8 } ,
- { nx, 1, "band", bit, "dst = srcb; c = C &&((srcb>>srca)&1);", 8 } ,
- { nx, 1, "biand", bit, "dst = srcb; c = C &&(!((srcb>>srca)&1));", 8 } ,
- { nx, 1, "bior", bit, "dst = srcb; c = C ||(!((srcb>>srca)&1));", 8 } ,
- { nx, 1, "bor", bit, "dst = srcb; c = C ||(((srcb>>srca)&1));", 8 } ,
- { nx, 1, "bixor", bit, "dst = srcb; c = C ^(!((srcb>>srca)&1));", 8 } ,
- { nx, 1, "bxor", bit, "dst = srcb; c = C ^(((srcb>>srca)&1));", 8 } ,
- { nx, 1, "bnot", bit, "dst = srcb ^ (1<<srca);", 8 } ,
- { nx, 1, "bclr", bit, "dst = srcb & ~(1<<srca);", 8 } ,
- { nx, 1, "bset", bit, "dst = srcb | (1<<srca);", 8 } ,
- { nx, 1, "bst", bit, "dst = (srcb & ~(1<<srca))| ((C)<<srca);", 8 } ,
- { nx, 1, "bist", bit, "dst = (srcb & ~(1<<srca))| ((!C)<<srca);", 8 } ,
- { nx, 1, "btst", bit, "dst = srcb; z = !((srcb>>srca)&1);", 8 } ,
- { icf, 0, "dec", dec, 0, 0 } ,
- { icf, 0, "inc", inc, 0, 0 } ,
- { saf, 1, "orc", setf, "|", 0 } ,
- { saf, 1, "xorc", setf, "^", 0 } ,
- { saf, 1, "andc", setf, "&", 0 } ,
- { nx, 1, "nop", nop, 0, 0 } ,
- { nx, 1, "bra", bra, "1", 0 } ,
- { nx, 1, "brn", bra, "0", 0 } ,
- { nx, 1, "bhi", bra, "(C||Z)==0", 0 } ,
- { nx, 1, "bls", bra, "(C||Z)==1", 0 } ,
- { nx, 1, "bcs", bra, "C==1", 0 } ,
- { nx, 1, "bcc", bra, "C==0", 0 } ,
- { nx, 1, "bpl", bra, "N==0", 0 } ,
- { nx, 1, "bmi", bra, "N==1", 0 } ,
- { nx, 1, "bvs", bra, "V==1", 0 } ,
- { nx, 1, "bvc", bra, "V==0", 0 } ,
- { nx, 1, "bge", bra, "(N^V)==0", 0 } ,
- { nx, 1, "bgt", bra, "(Z|(N^V))==0", 0 } ,
- { nx, 1, "blt", bra, "(N^V)==1", 0 } ,
- { nx, 1, "ble", bra, "(Z|(N^V))==1", 0 } ,
- { nx, 1, "beq", bra, "Z==1", 0 } ,
- { nx, 1, "bne", bra, "Z==0", 0 } ,
- { nx, 1, "bsr", bsr, "", 0 } ,
- { nx, 1, "jsr", jsr, 0, 0 } ,
- { nx, 1, "jmp", jmp, 0, 0 } ,
- { nx, 0, "rts", rts, 0, 0 } ,
- { nx, 0, "rte", rte, 0, 0 } ,
- { nx, 1, "andc", andc, 0, 0 } ,
- { sf, 1, "shal", shal, 0, 0 } ,
- { sf, 1, "shar", shar, 0, 0 } ,
- { sf, 1, "shll", shll, 0, 0 } ,
- { sf, 1, "shlr", shlr, 0, 0 } ,
- { sf, 1, "rotxl", rotxl, 0, 0 } ,
- { sf, 1, "rotxr", rotxr, 0, 0 } ,
- { sf, 1, "rotl", rotl, 0, 0 } ,
- { sf, 1, "rotr", rotr, 0, 0 } ,
- { lf, 1, "xor", log, "^", 0 } ,
- { lf, 1, "and", log, "&", 0 } ,
- { lf, 1, "or", log, "|", 0 } ,
- { lf, 1, "not", ulog, " ~", 0 } ,
- { lf, 1, "neg", ulog, " - ", 0 } ,
- { nx, 1, "adds", adds, "dst = srca + srcb", 0 } ,
- { nx, 1, "subs", adds, "srca = -srca; dst = srcb + srca", 0 } ,
- { af8, 1, "add.b", add, "dst = srca + srcb", 8 } ,
- { af16, 1, "add.w", add, "dst = srca + srcb", 16 } ,
- { af16, 1, "sub.w", add, "srca = -srca; dst = srcb + srca", 16 } ,
- { af8, 1, "sub.b", add, "srca = -srca; dst = srcb + srca", 8 } ,
- { af8, 1, "addx", addx, 0, 8 } ,
- { af8, 1, "subx", subx, 0, 8 } ,
- { af8, 0, "cmp.b", cmp, 0, 8 } ,
- { af16, 0, "cmp.w", cmp, 0, 16 } ,
- { nx, 1, "sleep", esleep, 0, 0 } ,
- { nx, 0, "bpt", bpt, 0, 8 } ,
- { nx, 0, "divxu", divxu, 0, 0 } ,
- { nx, 0, "mulxu", mulxu, 0, 0 } ,
- { mf8, 1, "mov.b", mov, 0, 8 } ,
- { mf8, 1, "movtpe", mov, 0, 8 } ,
- { mf8, 1, "movfpe", mov, 0, 8 } ,
- { mf16, 1, "mov.w", mov, 0, 16 } ,
- { 0 }
+table[] =
+{
+ {
+ nx, 1, "bld", bit, "dst = srcb; c = (srcb>>srca)&1;", 8
+ }
+ ,
+ {
+ nx, 1, "bild", bit, "dst = srcb; c = !((srcb>>srca)&1);", 8
+ }
+ ,
+ {
+ nx, 1, "band", bit, "dst = srcb; c = C &&((srcb>>srca)&1);", 8
+ }
+ ,
+ {
+ nx, 1, "biand", bit, "dst = srcb; c = C &&(!((srcb>>srca)&1));", 8
+ }
+ ,
+ {
+ nx, 1, "bior", bit, "dst = srcb; c = C ||(!((srcb>>srca)&1));", 8
+ }
+ ,
+ {
+ nx, 1, "bor", bit, "dst = srcb; c = C ||(((srcb>>srca)&1));", 8
+ }
+ ,
+ {
+ nx, 1, "bixor", bit, "dst = srcb; c = C ^(!((srcb>>srca)&1));", 8
+ }
+ ,
+ {
+ nx, 1, "bxor", bit, "dst = srcb; c = C ^(((srcb>>srca)&1));", 8
+ }
+ ,
+ {
+ nx, 1, "bnot", bit, "dst = srcb ^ (1<<srca);", 8
+ }
+ ,
+ {
+ nx, 1, "bclr", bit, "dst = srcb & ~(1<<srca);", 8
+ }
+ ,
+ {
+ nx, 1, "bset", bit, "dst = srcb | (1<<srca);", 8
+ }
+ ,
+ {
+ nx, 1, "bst", bit, "dst = (srcb & ~(1<<srca))| ((C)<<srca);", 8
+ }
+ ,
+ {
+ nx, 1, "bist", bit, "dst = (srcb & ~(1<<srca))| ((!C)<<srca);", 8
+ }
+ ,
+ {
+ nx, 1, "btst", bit, "dst = srcb; z = !((srcb>>srca)&1);", 8
+ }
+ ,
+ {
+ icf, 0, "dec", dec, 0, 0
+ }
+ ,
+ {
+ icf, 0, "inc", inc, 0, 0
+ }
+ ,
+ {
+ saf, 1, "orc", setf, "|", 0
+ }
+ ,
+ {
+ saf, 1, "xorc", setf, "^", 0
+ }
+ ,
+ {
+ saf, 1, "andc", setf, "&", 0
+ }
+ ,
+ {
+ nx, 1, "nop", nop, 0, 0
+ }
+ ,
+ {
+ nx, 1, "bra", bra, "1", 0
+ }
+ ,
+ {
+ nx, 1, "brn", bra, "0", 0
+ }
+ ,
+ {
+ nx, 1, "bhi", bra, "(C||Z)==0", 0
+ }
+ ,
+ {
+ nx, 1, "bls", bra, "(C||Z)==1", 0
+ }
+ ,
+ {
+ nx, 1, "bcs", bra, "C==1", 0
+ }
+ ,
+ {
+ nx, 1, "bcc", bra, "C==0", 0
+ }
+ ,
+ {
+ nx, 1, "bpl", bra, "N==0", 0
+ }
+ ,
+ {
+ nx, 1, "bmi", bra, "N==1", 0
+ }
+ ,
+ {
+ nx, 1, "bvs", bra, "V==1", 0
+ }
+ ,
+ {
+ nx, 1, "bvc", bra, "V==0", 0
+ }
+ ,
+ {
+ nx, 1, "bge", bra, "(N^V)==0", 0
+ }
+ ,
+ {
+ nx, 1, "bgt", bra, "(Z|(N^V))==0", 0
+ }
+ ,
+ {
+ nx, 1, "blt", bra, "(N^V)==1", 0
+ }
+ ,
+ {
+ nx, 1, "ble", bra, "(Z|(N^V))==1", 0
+ }
+ ,
+ {
+ nx, 1, "beq", bra, "Z==1", 0
+ }
+ ,
+ {
+ nx, 1, "bne", bra, "Z==0", 0
+ }
+ ,
+ {
+ nx, 1, "bsr", bsr, "", 0
+ }
+ ,
+ {
+ nx, 1, "jsr", jsr, 0, 0
+ }
+ ,
+ {
+ nx, 1, "jmp", jmp, 0, 0
+ }
+ ,
+ {
+ nx, 0, "rts", rts, 0, 0
+ }
+ ,
+ {
+ nx, 0, "rte", rte, 0, 0
+ }
+ ,
+ {
+ nx, 1, "andc", andc, 0, 0
+ }
+ ,
+ {
+ sf, 1, "shal", shal, 0, 0
+ }
+ ,
+ {
+ sf, 1, "shar", shar, 0, 0
+ }
+ ,
+ {
+ sf, 1, "shll", shll, 0, 0
+ }
+ ,
+ {
+ sf, 1, "shlr", shlr, 0, 0
+ }
+ ,
+ {
+ sf, 1, "rotxl", rotxl, 0, 0
+ }
+ ,
+ {
+ sf, 1, "rotxr", rotxr, 0, 0
+ }
+ ,
+ {
+ sf, 1, "rotl", rotl, 0, 0
+ }
+ ,
+ {
+ sf, 1, "rotr", rotr, 0, 0
+ }
+ ,
+ {
+ lf, 1, "xor", log, "^", 0
+ }
+ ,
+ {
+ lf, 1, "and", log, "&", 0
+ }
+ ,
+ {
+ lf, 1, "or", log, "|", 0
+ }
+ ,
+ {
+ lf, 1, "not", ulog, " ~", 0
+ }
+ ,
+ {
+ lf, 1, "neg", ulog, " - ", 0
+ }
+ ,
+ {
+ nx, 1, "adds", adds, "dst = srca + srcb", 0
+ }
+ ,
+ {
+ nx, 1, "subs", adds, "srca = -srca; dst = srcb + srca", 0
+ }
+ ,
+ {
+ af8, 1, "add.b", add, "dst = srca + srcb", 8
+ }
+ ,
+ {
+ af16, 1, "add.w", add, "dst = srca + srcb", 16
+ }
+ ,
+ {
+ af16, 1, "sub.w", add, "srca = -srca; dst = srcb + srca", 16
+ }
+ ,
+ {
+ af8, 1, "sub.b", add, "srca = -srca; dst = srcb + srca", 8
+ }
+ ,
+ {
+ af8, 1, "addx", addx, 0, 8
+ }
+ ,
+ {
+ af8, 1, "subx", subx, 0, 8
+ }
+ ,
+ {
+ af8, 0, "cmp.b", cmp, 0, 8
+ }
+ ,
+ {
+ af16, 0, "cmp.w", cmp, 0, 16
+ }
+ ,
+ {
+ nx, 1, "sleep", esleep, 0, 0
+ }
+ ,
+ {
+ nx, 0, "bpt", bpt, 0, 8
+ }
+ ,
+ {
+ nx, 0, "divxu", divxu, 0, 0
+ }
+ ,
+ {
+ nx, 0, "mulxu", mulxu, 0, 0
+ }
+ ,
+ {
+ mf8, 1, "mov.b", mov, 0, 8
+ }
+ ,
+ {
+ mf8, 1, "movtpe", mov, 0, 8
+ }
+ ,
+ {
+ mf8, 1, "movfpe", mov, 0, 8
+ }
+ ,
+ {
+ mf16, 1, "mov.w", mov, 0, 16
+ }
+ ,
+ {
+ 0
+ }
};
static
if (table[i].decode)
decode (p, 1, table[i].size);
printf ("cycles += %d;\n", p->time);
- printf ("npc = pc + %d;\n", p->length/2);
+ printf ("npc = pc + %d;\n", p->length / 2);
table[i].func (p, table[i].arg, table[i].size);
if (table[i].decode)
decode (p, 0, table[i].size);
printf ("case 0x%03x:\n", i);
}
- /* Dont need any if's this is the only one */
+ /* Don't need any if's this is the only one */
edo (*p);
}
else
if (mask0[c] | mask1[c])
{
int sh;
+
if (needand)
printf ("\n&&");
- if (c & 1) sh = 0;else sh = 8;
- if (c/2 == 0 && sh == 0)
- printf("((b1&0x%x)==0x%x)", mask0[c]| mask1[c],
- mask1[c]);
- else {
- printf ("((pc[%d]&(0x%02x<<%d))==(0x%x<<%d))",
- c/2, mask0[c] | mask1[c],sh,
- mask1[c],sh);
- }
+ if (c & 1)
+ sh = 0;
+ else
+ sh = 8;
+ if (c / 2 == 0 && sh == 0)
+ printf ("((b1&0x%x)==0x%x)", mask0[c] | mask1[c],
+ mask1[c]);
+ else
+ {
+ printf ("((pc[%d]&(0x%02x<<%d))==(0x%x<<%d))",
+ c / 2, mask0[c] | mask1[c], sh,
+ mask1[c], sh);
+ }
needand = 1;
}
projects / deliverable / binutils-gdb.git / blobdiff