[binutils.git] / bfd / cpu-h8300.c

/* BFD library support routines for the Hitachi H8/300 architecture.
   Copyright (C) 1990-1991 Free Software Foundation, Inc.
   Hacked by Steve Chamberlain of Cygnus Support.

This file is part of BFD, the Binary File Descriptor 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 2 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., 675 Mass Ave, Cambridge, MA 02139, USA.  */

#include <sysdep.h>
#include "bfd.h"
#include "libbfd.h"

#define DEFINE_TABLE 
#include "h8300-opcode.h"

#define MAXSAME 14

static struct h8_opcode * h8_opcodes_sorted[256][MAXSAME];

/* Run through the opcodes and sort them into order to make them easy
   to disassemble
 */
static void
DEFUN_VOID(bfd_h8_disassemble_init)
{
  unsigned int i;	
  struct h8_opcode *p; 
    
  for (p = h8_opcodes; p->name; p++) {	
    int where = 0;
    int n1 = 0;
    int n2 = 0;
    int n3 = 0;
    int n4= 0;
    if ((int)p->data.nib[0] < 16) {
      n1 =(int) p->data.nib[0] ;
    } else n1 = 0;
    if ((int)p->data.nib[1] < 16) {
      n2 = (int) p->data.nib[1];
    }else n2 = 0;

    for (i = 0; i < MAXSAME; i++) {
      int j = n1 * 16 + n2;
      if (h8_opcodes_sorted[j][i] == (struct h8_opcode *)NULL) {
	h8_opcodes_sorted[j][i] = p;
	break;
      }
    }
    
    if (i==MAXSAME)abort();

    /* Just make sure there are an even number of nibbles in it, and
       that the count is the same s the length */
    for (i = 0; p->data.nib[i] != E; i++) ;
    if (i & 1) abort();
    if (i/2 != p->length) abort();
  }
  for (i = 0; i < 256; i++) 
      {
	if (h8_opcodes_sorted[i][0]) 
	  p = h8_opcodes_sorted[i][0];
	else h8_opcodes_sorted[i][0] = p;
      }
}


unsigned int
DEFUN(bfd_h8_disassemble,(addr, data, stream),
bfd_vma addr AND
CONST bfd_byte *data AND
FILE *stream)
{
  /* Find the first entry in the table for this opcode */
  CONST static char *regnames[] = {
    "r0h","r1h","r2h","r3h","r4h","r5h","r6h","r7h",
    "r0l","r1l","r2l","r3l","r4l","r5l","r6l","r7l" };

  int rs = 0;
  int rd = 0;
  int rdisp = 0;
  int abs = 0;
  struct h8_opcode **p = h8_opcodes_sorted[(unsigned)(data[0])];
  struct h8_opcode *q;

  /* Find the exact opcode/arg combo */
  while (*p) {
    op_enum_type *nib;
    unsigned int len = 0;
    q = *p++;
    nib  =q->data.nib;
    while (*nib != E) {
      op_enum_type looking_for = *nib;
      int thisnib = data[len>>1] ;
      thisnib = (len & 1) ? (thisnib & 0xf) : ((thisnib >> 4) & 0xf);
      if ((int)looking_for & (int)B31) {
	if (((int)thisnib & 0x8) ==0) goto fail;
	looking_for = (op_enum_type)((int)looking_for &  ~(int)B31);
      }
      if ((int)looking_for & (int)B30) {
	if (((int)thisnib & 0x8) !=0) goto fail;
	looking_for = (op_enum_type)((int)looking_for &  ~(int)B30);
      }
      switch (looking_for) {
      case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7: 
      case 8: case 9: case 10: case 11: case 12: case 13: case 14: case 15:
	if ((int)looking_for != thisnib) goto fail;
	break;
      case ABS16SRC:
      case ABS16DST:
      case DISPSRC:
      case DISPDST:
      case IMM16:
	abs = (data[len>>1]) * 256 + data[(len+2)>>1];
	len+=3;
	nib+=3;
	break;
      case DISPREG:
	rdisp = thisnib; 
	break;
      case KBIT:
	abs = thisnib == 0x80 ? 2:1;
	break;
      case IMM8:
      case ABS8SRC:
      case ABS8DST:
      case DISP8:
	abs= data[len>>1];
	len++;
	nib++;
	break;
      case IMM3:
	abs = thisnib ;
	break;
      case RS8:
      case RS16:
      case RSINC:
      case RSIND:
	rs = thisnib;
	break;
      case RD16:
      case RDDEC:
      case RD8:
      case RDIND:
	rd = thisnib;
	break;
      default:
	fprintf(stream, "Dont understand \n");
	goto found;
      }
      len++;
      nib++;
    }
    goto found;
  fail: 
    ;

  }
  fprintf(stream, "%02x %02x        .word\tH'%x,H'%x\n",
	  data[0], data[1],
	  data[0], data[1]);
  return 2;
 found:;
    { int i;

      for (i = 0; i < q->length; i++) {
	fprintf(stream, "%02x ", data[i]);
      }
      for (; i < 6; i++) {
	fprintf(stream, "   ");
      }
    }
  fprintf(stream, "%s\t",q->name);
  /* Now print out the args */
    {
      op_enum_type *args = q->args.nib;
      int hadone = 0;
      while (*args != E) {
	if (hadone)
	  fprintf(stream, ",");
	switch ((int)(*args) & ~((int)B30|(int)B31)) {
	case IMM16:
	case IMM8:
	case IMM3:
	  fprintf(stream, "#H'%x", (unsigned)abs); break;
	case RD8:
	  fprintf(stream, "%s", regnames[rd]); break;
	case RS8:
	  fprintf(stream, "%s",regnames[rs]); break;
	case RD16:
	  fprintf(stream, "r%d", rd& 0x7); break;
	case RS16:
	  fprintf(stream, "r%d", rs & 0x7); break;
	case RSINC:
	  fprintf(stream, "@r%d+", rs & 0x7); break;
	case RDDEC:
	  fprintf(stream, "@-r%d", rd & 0x7); break;
	case RDIND: 
	  fprintf(stream, "@r%d", rd & 0x7); break;
	case RSIND:
	  fprintf(stream, "@r%d",rs & 0x7); break;
	case ABS8SRC:
	case ABS16SRC:
	case ABS16DST:
	case ABS8DST:
	  fprintf(stream, "@H'%x", (unsigned)abs); break;
	case DISP8:
	  fprintf(stream, ".%s%d (%x)",(char)abs>0 ? "+" :"", (char)abs,
		  addr + (char)abs);
	  break;
	case DISPSRC:
	case DISPDST:
	  fprintf(stream, "@(%d,r%d)", abs, rdisp & 0x7); break;
	case CCR:
	  fprintf(stream, "ccr"); break;
	case KBIT:
	  fprintf(stream, "#%d",abs); break;
	default:
	  abort();
	}
	hadone = 1;
	args++;
      }
    }
  return q->length;
}


unsigned int DEFUN( print_insn_h8300,(addr, data, file),
bfd_vma addr AND
CONST bfd_byte *data AND
PTR file)
{
  static boolean init;
  if (!init) {
    bfd_h8_disassemble_init();
    init= 1;

  }
  return   bfd_h8_disassemble(addr, data, file);
}

/* 
Relocations for the H8

*/
static bfd_reloc_status_enum_type 
DEFUN(howto16_callback,(abfd, reloc_entry, symbol_in, data, ignore_input_section),
bfd *abfd AND
arelent *reloc_entry AND
asymbol *symbol_in AND
unsigned char *data AND
asection *ignore_input_section)
{
  long relocation = 0;
  bfd_vma addr = reloc_entry->address;
  long x = bfd_get_16(abfd, (bfd_byte *)data + addr);

  HOWTO_PREPARE(relocation, symbol_in);

  x = (x + relocation + reloc_entry->addend);

  bfd_put_16(abfd, x, (bfd_byte *)data + addr);
  return bfd_reloc_ok;
}


static bfd_reloc_status_enum_type 
DEFUN(howto8_callback,(abfd, reloc_entry, symbol_in, data, ignore_input_section),
bfd *abfd AND
arelent *reloc_entry AND
asymbol *symbol_in AND
unsigned char *data AND
asection *ignore_input_section)
{
  long relocation = 0;
  bfd_vma addr = reloc_entry->address;
  long x = bfd_get_8(abfd, (bfd_byte *)data + addr);

  HOWTO_PREPARE(relocation, symbol_in);

  x = (x + relocation + reloc_entry->addend);

  bfd_put_8(abfd, x, (bfd_byte *)data + addr);
  return bfd_reloc_ok;
}


static bfd_reloc_status_enum_type 
DEFUN(howto8_FFnn_callback,(abfd, reloc_entry, symbol_in, data, ignore_input_section),
bfd *abfd AND
arelent *reloc_entry AND
asymbol *symbol_in AND
unsigned char *data AND
asection *ignore_input_section)
{
  long relocation = 0;
  bfd_vma addr = reloc_entry->address;

  long x = bfd_get_8(abfd, (bfd_byte *)data + addr);
  abort();
  HOWTO_PREPARE(relocation, symbol_in);

  x = (x + relocation + reloc_entry->addend);

  bfd_put_8(abfd, x, (bfd_byte *)data + addr);
  return bfd_reloc_ok;
}

static bfd_reloc_status_enum_type 
DEFUN(howto8_pcrel_callback,(abfd, reloc_entry, symbol_in, data, ignore_input_section),
bfd *abfd AND
arelent *reloc_entry AND
asymbol *symbol_in AND
unsigned char *data AND
asection *ignore_input_section)
{
  long relocation = 0;
  bfd_vma addr = reloc_entry->address;
  long x = bfd_get_8(abfd, (bfd_byte *)data + addr);
  abort();
  HOWTO_PREPARE(relocation, symbol_in);

  x = (x + relocation + reloc_entry->addend);

  bfd_put_8(abfd, x, (bfd_byte *)data + addr);
  return bfd_reloc_ok;
}


static reloc_howto_type howto_16
  = NEWHOWTO(howto16_callback,"abs16",1,0,0);
static reloc_howto_type howto_8
  = NEWHOWTO(howto8_callback,"abs8",0,0,0);

static reloc_howto_type howto_8_FFnn
  = NEWHOWTO(howto8_FFnn_callback,"ff00+abs8",0,0,0);

static reloc_howto_type howto_8_pcrel
  = NEWHOWTO(howto8_pcrel_callback,"pcrel8",0,1,1);


static CONST struct reloc_howto_struct *
DEFUN(local_bfd_reloc_type_lookup,(arch, code),
 bfd_arch_info_struct_type *arch AND
 bfd_reloc_code_enum_type code)
{
  switch (code) {
  case BFD_RELOC_16:
    return &howto_16;
  case BFD_RELOC_8_FFnn:
    return &howto_8_FFnn;
  case BFD_RELOC_8:
    return &howto_8;
  case BFD_RELOC_8_PCREL:
    return &howto_8_pcrel;
  }
  return (reloc_howto_type *)NULL;
}

int bfd_default_scan_num_mach();

static boolean 
DEFUN(h8300_scan,(info, string),
CONST struct bfd_arch_info_struct *info AND
CONST char *string)
{
  if (strcmp(string,"h8300") == 0) return true;
  if (strcmp(string,"H8300") == 0) return true;
  if (strcmp(string,"h8/300") == 0) return true;
  if (strcmp(string,"H8/300") == 0) return true;
  return false;
}
static bfd_arch_info_struct_type arch_info_struct = 
  {
    16,	/* 16 bits in a word */
    16,	/* 16 bits in an address */
    8,	/* 8 bits in a byte */
    bfd_arch_h8300,
    0,	/* only 1 machine */
    "H8/300", /* arch_name  */
    "H8/300", /* printable name */
    true,	/* the default machine */
    bfd_default_compatible,
    h8300_scan,
    print_insn_h8300,
    local_bfd_reloc_type_lookup,
    0,
  };


void DEFUN_VOID(bfd_h8300_arch)
{
  bfd_arch_linkin(&arch_info_struct);
}
Commit	Line	Data
e89f2fbe SC	1	/* BFD library support routines for the Hitachi H8/300 architecture.
	2	Copyright (C) 1990-1991 Free Software Foundation, Inc.
	3	Hacked by Steve Chamberlain of Cygnus Support.
	4
	5	This file is part of BFD, the Binary File Descriptor library.
	6
	7	This program is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
	9	the Free Software Foundation; either version 2 of the License, or
	10	(at your option) any later version.
	11
	12	This program is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with this program; if not, write to the Free Software
	19	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
	20
	21	#include <sysdep.h>
	22	#include "bfd.h"
	23	#include "libbfd.h"
	24
	25	#define DEFINE_TABLE
	26	#include "h8300-opcode.h"
	27
	28	#define MAXSAME 14
	29
	30	static struct h8_opcode * h8_opcodes_sorted[256][MAXSAME];
	31
	32	/* Run through the opcodes and sort them into order to make them easy
	33	to disassemble
	34	*/
	35	static void
	36	DEFUN_VOID(bfd_h8_disassemble_init)
	37	{
	38	unsigned int i;
	39	struct h8_opcode *p;
	40
	41	for (p = h8_opcodes; p->name; p++) {
	42	int where = 0;
	43	int n1 = 0;
	44	int n2 = 0;
	45	int n3 = 0;
	46	int n4= 0;
	47	if ((int)p->data.nib[0] < 16) {
	48	n1 =(int) p->data.nib[0] ;
	49	} else n1 = 0;
	50	if ((int)p->data.nib[1] < 16) {
	51	n2 = (int) p->data.nib[1];
	52	}else n2 = 0;
	53
	54	for (i = 0; i < MAXSAME; i++) {
	55	int j = n1 * 16 + n2;
	56	if (h8_opcodes_sorted[j][i] == (struct h8_opcode *)NULL) {
	57	h8_opcodes_sorted[j][i] = p;
	58	break;
	59	}
	60	}
	61
	62	if (i==MAXSAME)abort();
	63
	64	/* Just make sure there are an even number of nibbles in it, and
65	that the count is the same s the length */
66	for (i = 0; p->data.nib[i] != E; i++) ;
67	if (i & 1) abort();
68	if (i/2 != p->length) abort();
69	}
70	for (i = 0; i < 256; i++)
71	{
72	if (h8_opcodes_sorted[i][0])
73	p = h8_opcodes_sorted[i][0];
74	else h8_opcodes_sorted[i][0] = p;
75	}
76	}
77
b2c91bd9	78
e89f2fbe SC	79	unsigned int
	80	DEFUN(bfd_h8_disassemble,(addr, data, stream),
	81	bfd_vma addr AND
	82	CONST bfd_byte *data AND
	83	FILE *stream)
	84	{
	85	/* Find the first entry in the table for this opcode */
b2c91bd9 SC	86	CONST static char *regnames[] = {
	87	"r0h","r1h","r2h","r3h","r4h","r5h","r6h","r7h",
	88	"r0l","r1l","r2l","r3l","r4l","r5l","r6l","r7l" };
	89
e89f2fbe SC	90	int rs = 0;
	91	int rd = 0;
	92	int rdisp = 0;
	93	int abs = 0;
	94	struct h8_opcode **p = h8_opcodes_sorted[(unsigned)(data[0])];
	95	struct h8_opcode *q;
	96
	97	/* Find the exact opcode/arg combo */
	98	while (*p) {
	99	op_enum_type *nib;
	100	unsigned int len = 0;
	101	q = *p++;
	102	nib =q->data.nib;
	103	while (*nib != E) {
	104	op_enum_type looking_for = *nib;
	105	int thisnib = data[len>>1] ;
	106	thisnib = (len & 1) ? (thisnib & 0xf) : ((thisnib >> 4) & 0xf);
	107	if ((int)looking_for & (int)B31) {
	108	if (((int)thisnib & 0x8) ==0) goto fail;
	109	looking_for = (op_enum_type)((int)looking_for & ~(int)B31);
	110	}
	111	if ((int)looking_for & (int)B30) {
	112	if (((int)thisnib & 0x8) !=0) goto fail;
	113	looking_for = (op_enum_type)((int)looking_for & ~(int)B30);
	114	}
	115	switch (looking_for) {
	116	case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7:
	117	case 8: case 9: case 10: case 11: case 12: case 13: case 14: case 15:
	118	if ((int)looking_for != thisnib) goto fail;
	119	break;
	120	case ABS16SRC:
	121	case ABS16DST:
	122	case DISPSRC:
	123	case DISPDST:
	124	case IMM16:
	125	abs = (data[len>>1]) * 256 + data[(len+2)>>1];
	126	len+=3;
	127	nib+=3;
	128	break;
	129	case DISPREG:
	130	rdisp = thisnib;
	131	break;
	132	case KBIT:
	133	abs = thisnib == 0x80 ? 2:1;
	134	break;
	135	case IMM8:
	136	case ABS8SRC:
	137	case ABS8DST:
	138	case DISP8:
	139	abs= data[len>>1];
	140	len++;
	141	nib++;
	142	break;
	143	case IMM3:
	144	abs = thisnib ;
	145	break;
	146	case RS8:
	147	case RS16:
	148	case RSINC:
	149	case RSIND:
	150	rs = thisnib;
	151	break;
	152	case RD16:
	153	case RDDEC:
154	case RD8:
155	case RDIND:
156	rd = thisnib;
157	break;
158	default:
159	fprintf(stream, "Dont understand \n");
160	goto found;
161	}
162	len++;
163	nib++;
164	}
165	goto found;
166	fail:
167	;
168
169	}
170	fprintf(stream, "%02x %02x .word\tH'%x,H'%x\n",
b2c91bd9 SC	171	data[0], data[1],
b2c91bd9 SC	172	data[0], data[1]);
e89f2fbe SC	173	return 2;
	174	found:;
	175	{ int i;
	176
	177	for (i = 0; i < q->length; i++) {
	178	fprintf(stream, "%02x ", data[i]);
	179	}
	180	for (; i < 6; i++) {
	181	fprintf(stream, " ");
	182	}
	183	}
	184	fprintf(stream, "%s\t",q->name);
	185	/* Now print out the args */
	186	{
	187	op_enum_type *args = q->args.nib;
	188	int hadone = 0;
	189	while (*args != E) {
	190	if (hadone)
	191	fprintf(stream, ",");
	192	switch ((int)(*args) & ~((int)B30\|(int)B31)) {
	193	case IMM16:
	194	case IMM8:
	195	case IMM3:
	196	fprintf(stream, "#H'%x", (unsigned)abs); break;
	197	case RD8:
b2c91bd9	198	fprintf(stream, "%s", regnames[rd]); break;
e89f2fbe	199	case RS8:
b2c91bd9	200	fprintf(stream, "%s",regnames[rs]); break;
e89f2fbe SC	201	case RD16:
	202	fprintf(stream, "r%d", rd& 0x7); break;
	203	case RS16:
	204	fprintf(stream, "r%d", rs & 0x7); break;
	205	case RSINC:
	206	fprintf(stream, "@r%d+", rs & 0x7); break;
	207	case RDDEC:
	208	fprintf(stream, "@-r%d", rd & 0x7); break;
	209	case RDIND:
	210	fprintf(stream, "@r%d", rd & 0x7); break;
	211	case RSIND:
	212	fprintf(stream, "@r%d",rs & 0x7); break;
	213	case ABS8SRC:
	214	case ABS16SRC:
	215	case ABS16DST:
	216	case ABS8DST:
	217	fprintf(stream, "@H'%x", (unsigned)abs); break;
	218	case DISP8:
b2c91bd9 SC	219	fprintf(stream, ".%s%d (%x)",(char)abs>0 ? "+" :"", (char)abs,
	220	addr + (char)abs);
	221	break;
e89f2fbe SC	222	case DISPSRC:
	223	case DISPDST:
	224	fprintf(stream, "@(%d,r%d)", abs, rdisp & 0x7); break;
	225	case CCR:
	226	fprintf(stream, "ccr"); break;
	227	case KBIT:
	228	fprintf(stream, "#%d",abs); break;
	229	default:
	230	abort();
	231	}
	232	hadone = 1;
	233	args++;
	234	}
	235	}
	236	return q->length;
	237	}
	238
	239
	240
	241	unsigned int DEFUN( print_insn_h8300,(addr, data, file),
	242	bfd_vma addr AND
	243	CONST bfd_byte *data AND
	244	PTR file)
	245	{
	246	static boolean init;
	247	if (!init) {
	248	bfd_h8_disassemble_init();
	249	init= 1;
	250
	251	}
	252	return bfd_h8_disassemble(addr, data, file);
	253	}
	254
	255	/*
	256	Relocations for the H8
	257
	258	*/
	259	static bfd_reloc_status_enum_type
	260	DEFUN(howto16_callback,(abfd, reloc_entry, symbol_in, data, ignore_input_section),
	261	bfd *abfd AND
	262	arelent *reloc_entry AND
	263	asymbol *symbol_in AND
	264	unsigned char *data AND
	265	asection *ignore_input_section)
	266	{
	267	long relocation = 0;
	268	bfd_vma addr = reloc_entry->address;
	269	long x = bfd_get_16(abfd, (bfd_byte *)data + addr);
	270
	271	HOWTO_PREPARE(relocation, symbol_in);
	272
	273	x = (x + relocation + reloc_entry->addend);
	274
	275	bfd_put_16(abfd, x, (bfd_byte *)data + addr);
	276	return bfd_reloc_ok;
	277	}
	278
	279
	280	static bfd_reloc_status_enum_type
	281	DEFUN(howto8_callback,(abfd, reloc_entry, symbol_in, data, ignore_input_section),
	282	bfd *abfd AND
	283	arelent *reloc_entry AND
	284	asymbol *symbol_in AND
	285	unsigned char *data AND
286	asection *ignore_input_section)
287	{
288	long relocation = 0;
289	bfd_vma addr = reloc_entry->address;
290	long x = bfd_get_8(abfd, (bfd_byte *)data + addr);
291
292	HOWTO_PREPARE(relocation, symbol_in);
293
294	x = (x + relocation + reloc_entry->addend);
295
296	bfd_put_8(abfd, x, (bfd_byte *)data + addr);
297	return bfd_reloc_ok;
298	}
299
300
301	static bfd_reloc_status_enum_type
302	DEFUN(howto8_FFnn_callback,(abfd, reloc_entry, symbol_in, data, ignore_input_section),
303	bfd *abfd AND
304	arelent *reloc_entry AND
305	asymbol *symbol_in AND
306	unsigned char *data AND
307	asection *ignore_input_section)
308	{
309	long relocation = 0;
310	bfd_vma addr = reloc_entry->address;
311
312	long x = bfd_get_8(abfd, (bfd_byte *)data + addr);
313	abort();
314	HOWTO_PREPARE(relocation, symbol_in);
315
316	x = (x + relocation + reloc_entry->addend);
317
318	bfd_put_8(abfd, x, (bfd_byte *)data + addr);
319	return bfd_reloc_ok;
320	}
321
322	static bfd_reloc_status_enum_type
323	DEFUN(howto8_pcrel_callback,(abfd, reloc_entry, symbol_in, data, ignore_input_section),
324	bfd *abfd AND
325	arelent *reloc_entry AND
326	asymbol *symbol_in AND
327	unsigned char *data AND
328	asection *ignore_input_section)
329	{
330	long relocation = 0;
331	bfd_vma addr = reloc_entry->address;
332	long x = bfd_get_8(abfd, (bfd_byte *)data + addr);
333	abort();
334	HOWTO_PREPARE(relocation, symbol_in);
335
336	x = (x + relocation + reloc_entry->addend);
337
338	bfd_put_8(abfd, x, (bfd_byte *)data + addr);
339	return bfd_reloc_ok;
340	}
341
342
343	static reloc_howto_type howto_16
b2c91bd9	344	= NEWHOWTO(howto16_callback,"abs16",1,0,0);
e89f2fbe	345	static reloc_howto_type howto_8
b2c91bd9	346	= NEWHOWTO(howto8_callback,"abs8",0,0,0);
e89f2fbe SC	347
e89f2fbe SC	348	static reloc_howto_type howto_8_FFnn
b2c91bd9	349	= NEWHOWTO(howto8_FFnn_callback,"ff00+abs8",0,0,0);
e89f2fbe SC	350
e89f2fbe SC	351	static reloc_howto_type howto_8_pcrel
b2c91bd9	352	= NEWHOWTO(howto8_pcrel_callback,"pcrel8",0,1,1);
e89f2fbe SC	353
	354
	355
b2c91bd9 SC	356	static CONST struct reloc_howto_struct *
	357	DEFUN(local_bfd_reloc_type_lookup,(arch, code),
	358	bfd_arch_info_struct_type *arch AND
	359	bfd_reloc_code_enum_type code)
e89f2fbe SC	360	{
	361	switch (code) {
	362	case BFD_RELOC_16:
	363	return &howto_16;
	364	case BFD_RELOC_8_FFnn:
	365	return &howto_8_FFnn;
	366	case BFD_RELOC_8:
	367	return &howto_8;
	368	case BFD_RELOC_8_PCREL:
	369	return &howto_8_pcrel;
	370	}
	371	return (reloc_howto_type *)NULL;
	372	}
	373
	374	int bfd_default_scan_num_mach();
	375
b2c91bd9 SC	376	static boolean
	377	DEFUN(h8300_scan,(info, string),
	378	CONST struct bfd_arch_info_struct *info AND
	379	CONST char *string)
	380	{
	381	if (strcmp(string,"h8300") == 0) return true;
	382	if (strcmp(string,"H8300") == 0) return true;
	383	if (strcmp(string,"h8/300") == 0) return true;
	384	if (strcmp(string,"H8/300") == 0) return true;
	385	return false;
	386	}
e89f2fbe SC	387	static bfd_arch_info_struct_type arch_info_struct =
	388	{
	389	16, /* 16 bits in a word */
	390	16, /* 16 bits in an address */
	391	8, /* 8 bits in a byte */
	392	bfd_arch_h8300,
	393	0, /* only 1 machine */
b2c91bd9	394	"H8/300", /* arch_name */
e89f2fbe SC	395	"H8/300", /* printable name */
	396	true, /* the default machine */
	397	bfd_default_compatible,
b2c91bd9	398	h8300_scan,
e89f2fbe SC	399	print_insn_h8300,
	400	local_bfd_reloc_type_lookup,
	401	0,
	402	};
	403
	404
	405
	406
	407	void DEFUN_VOID(bfd_h8300_arch)
	408	{
	409	bfd_arch_linkin(&arch_info_struct);
	410	}
	411
	412
	413