[deliverable/binutils-gdb.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 "bfd.h"
#include "sysdep.h"
#include "libbfd.h"

#define DEFINE_TABLE 
#include "opcode/h8300.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_type *nib;
    unsigned int len = 0;
    q = *p++;
    nib  =q->data.nib;
    while (*nib != E) {
      op_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_type)((int)looking_for &  ~(int)B31);
      }
      if ((int)looking_for & (int)B30) {
	if (((int)thisnib & 0x8) !=0) goto fail;
	looking_for = (op_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 == 0x8 ? 2:1;
	break;
      case IMM8:
      case ABS8SRC:
      case ABS8DST:
      case MEMIND:
      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",
	  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_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, "#0x%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, "@0x%x", (unsigned)abs);
	  break;
	case MEMIND:
	  fprintf(stream, "@@%d (%x)",abs, abs);
	  break;
	case DISP8:
	  fprintf(stream, ".%s%d (%x)",(char)abs>0 ? "+" :"", (char)abs,
		  addr + (char)abs);
	  break;
	case DISPSRC:
	case DISPDST:
	  fprintf(stream, "@(0x%x,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 char *data AND
PTR file)
{
  static boolean init;
  if (!init) {
    bfd_h8_disassemble_init();
    init= 1;
  }

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

/* 
Relocations for the H8

*/
static bfd_reloc_status_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_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_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_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),
 CONST struct bfd_arch_info *arch AND
 bfd_reloc_code_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 *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_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
e89f2fbe	21	#include "bfd.h"
3b4f1a5d	22	#include "sysdep.h"
e89f2fbe SC	23	#include "libbfd.h"
	24
	25	#define DEFINE_TABLE
c3eb25fc	26	#include "opcode/h8300.h"
e89f2fbe SC	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) {
3b4f1a5d	99	op_type *nib;
e89f2fbe SC	100	unsigned int len = 0;
	101	q = *p++;
	102	nib =q->data.nib;
	103	while (*nib != E) {
3b4f1a5d	104	op_type looking_for = *nib;
e89f2fbe SC	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;
3b4f1a5d	109	looking_for = (op_type)((int)looking_for & ~(int)B31);
e89f2fbe SC	110	}
	111	if ((int)looking_for & (int)B30) {
	112	if (((int)thisnib & 0x8) !=0) goto fail;
3b4f1a5d	113	looking_for = (op_type)((int)looking_for & ~(int)B30);
e89f2fbe SC	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:
3b4f1a5d	133	abs = thisnib == 0x8 ? 2:1;
e89f2fbe SC	134	break;
	135	case IMM8:
	136	case ABS8SRC:
	137	case ABS8DST:
0d4b8e3f	138	case MEMIND:
e89f2fbe SC	139	case DISP8:
	140	abs= data[len>>1];
	141	len++;
	142	nib++;
	143	break;
	144	case IMM3:
	145	abs = thisnib ;
	146	break;
	147	case RS8:
	148	case RS16:
	149	case RSINC:
	150	case RSIND:
	151	rs = thisnib;
	152	break;
	153	case RD16:
	154	case RDDEC:
	155	case RD8:
	156	case RDIND:
	157	rd = thisnib;
	158	break;
	159	default:
	160	fprintf(stream, "Dont understand \n");
	161	goto found;
	162	}
	163	len++;
	164	nib++;
	165	}
	166	goto found;
	167	fail:
	168	;
	169
	170	}
3b4f1a5d	171	fprintf(stream, "%02x %02x .word\tH'%x,H'%x",
b2c91bd9 SC	172	data[0], data[1],
b2c91bd9 SC	173	data[0], data[1]);
e89f2fbe SC	174	return 2;
	175	found:;
	176	{ int i;
	177
	178	for (i = 0; i < q->length; i++) {
	179	fprintf(stream, "%02x ", data[i]);
	180	}
	181	for (; i < 6; i++) {
	182	fprintf(stream, " ");
	183	}
	184	}
	185	fprintf(stream, "%s\t",q->name);
	186	/* Now print out the args */
	187	{
3b4f1a5d	188	op_type *args = q->args.nib;
e89f2fbe SC	189	int hadone = 0;
	190	while (*args != E) {
	191	if (hadone)
	192	fprintf(stream, ",");
	193	switch ((int)(*args) & ~((int)B30\|(int)B31)) {
	194	case IMM16:
	195	case IMM8:
	196	case IMM3:
0d4b8e3f SC	197	fprintf(stream, "#0x%x", (unsigned)abs);
0d4b8e3f SC	198	break;
e89f2fbe	199	case RD8:
0d4b8e3f SC	200	fprintf(stream, "%s", regnames[rd]);
0d4b8e3f SC	201	break;
e89f2fbe	202	case RS8:
0d4b8e3f SC	203	fprintf(stream, "%s",regnames[rs]);
0d4b8e3f SC	204	break;
e89f2fbe	205	case RD16:
0d4b8e3f SC	206	fprintf(stream, "r%d", rd& 0x7);
0d4b8e3f SC	207	break;
e89f2fbe	208	case RS16:
0d4b8e3f SC	209	fprintf(stream, "r%d", rs & 0x7);
0d4b8e3f SC	210	break;
e89f2fbe	211	case RSINC:
0d4b8e3f SC	212	fprintf(stream, "@r%d+", rs & 0x7);
0d4b8e3f SC	213	break;
e89f2fbe	214	case RDDEC:
0d4b8e3f SC	215	fprintf(stream, "@-r%d", rd & 0x7);
0d4b8e3f SC	216	break;
e89f2fbe	217	case RDIND:
0d4b8e3f SC	218	fprintf(stream, "@r%d", rd & 0x7);
0d4b8e3f SC	219	break;
e89f2fbe	220	case RSIND:
0d4b8e3f SC	221	fprintf(stream, "@r%d",rs & 0x7);
0d4b8e3f SC	222	break;
e89f2fbe SC	223	case ABS8SRC:
	224	case ABS16SRC:
	225	case ABS16DST:
	226	case ABS8DST:
0d4b8e3f SC	227	fprintf(stream, "@0x%x", (unsigned)abs);
	228	break;
	229	case MEMIND:
	230	fprintf(stream, "@@%d (%x)",abs, abs);
	231	break;
e89f2fbe	232	case DISP8:
b2c91bd9 SC	233	fprintf(stream, ".%s%d (%x)",(char)abs>0 ? "+" :"", (char)abs,
	234	addr + (char)abs);
	235	break;
e89f2fbe SC	236	case DISPSRC:
e89f2fbe SC	237	case DISPDST:
0d4b8e3f SC	238	fprintf(stream, "@(0x%x,r%d)", abs, rdisp & 0x7);
0d4b8e3f SC	239	break;
e89f2fbe	240	case CCR:
0d4b8e3f SC	241	fprintf(stream, "ccr");
0d4b8e3f SC	242	break;
e89f2fbe	243	case KBIT:
0d4b8e3f SC	244	fprintf(stream, "#%d",abs);
0d4b8e3f SC	245	break;
e89f2fbe SC	246	default:
	247	abort();
	248	}
	249	hadone = 1;
	250	args++;
	251	}
	252	}
	253	return q->length;
	254	}
	255
	256
	257
3b4f1a5d	258	unsigned int DEFUN(print_insn_h8300,(addr, data, file),
e89f2fbe	259	bfd_vma addr AND
3b4f1a5d	260	CONST char *data AND
e89f2fbe SC	261	PTR file)
	262	{
	263	static boolean init;
	264	if (!init) {
	265	bfd_h8_disassemble_init();
	266	init= 1;
e89f2fbe	267	}
3b4f1a5d SC	268
3b4f1a5d SC	269	return bfd_h8_disassemble(addr, (bfd_byte *)data, file);
e89f2fbe SC	270	}
	271
	272	/*
	273	Relocations for the H8
	274
	275	*/
3b4f1a5d	276	static bfd_reloc_status_type
e89f2fbe SC	277	DEFUN(howto16_callback,(abfd, reloc_entry, symbol_in, data, ignore_input_section),
	278	bfd *abfd AND
	279	arelent *reloc_entry AND
	280	asymbol *symbol_in AND
	281	unsigned char *data AND
	282	asection *ignore_input_section)
	283	{
	284	long relocation = 0;
	285	bfd_vma addr = reloc_entry->address;
	286	long x = bfd_get_16(abfd, (bfd_byte *)data + addr);
	287
	288	HOWTO_PREPARE(relocation, symbol_in);
	289
	290	x = (x + relocation + reloc_entry->addend);
	291
	292	bfd_put_16(abfd, x, (bfd_byte *)data + addr);
	293	return bfd_reloc_ok;
	294	}
	295
	296
3b4f1a5d	297	static bfd_reloc_status_type
e89f2fbe SC	298	DEFUN(howto8_callback,(abfd, reloc_entry, symbol_in, data, ignore_input_section),
	299	bfd *abfd AND
	300	arelent *reloc_entry AND
	301	asymbol *symbol_in AND
	302	unsigned char *data AND
	303	asection *ignore_input_section)
	304	{
	305	long relocation = 0;
	306	bfd_vma addr = reloc_entry->address;
	307	long x = bfd_get_8(abfd, (bfd_byte *)data + addr);
	308
	309	HOWTO_PREPARE(relocation, symbol_in);
	310
	311	x = (x + relocation + reloc_entry->addend);
	312
	313	bfd_put_8(abfd, x, (bfd_byte *)data + addr);
	314	return bfd_reloc_ok;
	315	}
	316
	317
3b4f1a5d	318	static bfd_reloc_status_type
e89f2fbe SC	319	DEFUN(howto8_FFnn_callback,(abfd, reloc_entry, symbol_in, data, ignore_input_section),
	320	bfd *abfd AND
	321	arelent *reloc_entry AND
	322	asymbol *symbol_in AND
	323	unsigned char *data AND
	324	asection *ignore_input_section)
	325	{
	326	long relocation = 0;
	327	bfd_vma addr = reloc_entry->address;
	328
	329	long x = bfd_get_8(abfd, (bfd_byte *)data + addr);
	330	abort();
	331	HOWTO_PREPARE(relocation, symbol_in);
	332
	333	x = (x + relocation + reloc_entry->addend);
	334
	335	bfd_put_8(abfd, x, (bfd_byte *)data + addr);
	336	return bfd_reloc_ok;
	337	}
	338
3b4f1a5d	339	static bfd_reloc_status_type
e89f2fbe SC	340	DEFUN(howto8_pcrel_callback,(abfd, reloc_entry, symbol_in, data, ignore_input_section),
	341	bfd *abfd AND
	342	arelent *reloc_entry AND
	343	asymbol *symbol_in AND
	344	unsigned char *data AND
	345	asection *ignore_input_section)
	346	{
	347	long relocation = 0;
	348	bfd_vma addr = reloc_entry->address;
	349	long x = bfd_get_8(abfd, (bfd_byte *)data + addr);
	350	abort();
	351	HOWTO_PREPARE(relocation, symbol_in);
	352
	353	x = (x + relocation + reloc_entry->addend);
	354
	355	bfd_put_8(abfd, x, (bfd_byte *)data + addr);
	356	return bfd_reloc_ok;
	357	}
	358
	359
	360	static reloc_howto_type howto_16
b2c91bd9	361	= NEWHOWTO(howto16_callback,"abs16",1,0,0);
e89f2fbe	362	static reloc_howto_type howto_8
b2c91bd9	363	= NEWHOWTO(howto8_callback,"abs8",0,0,0);
e89f2fbe SC	364
e89f2fbe SC	365	static reloc_howto_type howto_8_FFnn
b2c91bd9	366	= NEWHOWTO(howto8_FFnn_callback,"ff00+abs8",0,0,0);
e89f2fbe SC	367
e89f2fbe SC	368	static reloc_howto_type howto_8_pcrel
b2c91bd9	369	= NEWHOWTO(howto8_pcrel_callback,"pcrel8",0,1,1);
e89f2fbe SC	370
	371
	372
b2c91bd9 SC	373	static CONST struct reloc_howto_struct *
b2c91bd9 SC	374	DEFUN(local_bfd_reloc_type_lookup,(arch, code),
3b4f1a5d SC	375	CONST struct bfd_arch_info *arch AND
3b4f1a5d SC	376	bfd_reloc_code_type code)
e89f2fbe SC	377	{
	378	switch (code) {
	379	case BFD_RELOC_16:
	380	return &howto_16;
	381	case BFD_RELOC_8_FFnn:
	382	return &howto_8_FFnn;
	383	case BFD_RELOC_8:
	384	return &howto_8;
	385	case BFD_RELOC_8_PCREL:
	386	return &howto_8_pcrel;
	387	}
	388	return (reloc_howto_type *)NULL;
	389	}
	390
	391	int bfd_default_scan_num_mach();
	392
b2c91bd9 SC	393	static boolean
b2c91bd9 SC	394	DEFUN(h8300_scan,(info, string),
3b4f1a5d	395	CONST struct bfd_arch_info *info AND
b2c91bd9 SC	396	CONST char *string)
	397	{
	398	if (strcmp(string,"h8300") == 0) return true;
	399	if (strcmp(string,"H8300") == 0) return true;
	400	if (strcmp(string,"h8/300") == 0) return true;
	401	if (strcmp(string,"H8/300") == 0) return true;
	402	return false;
	403	}
3b4f1a5d SC	404
3b4f1a5d SC	405	static bfd_arch_info_type arch_info_struct =
e89f2fbe SC	406	{
	407	16, /* 16 bits in a word */
	408	16, /* 16 bits in an address */
	409	8, /* 8 bits in a byte */
	410	bfd_arch_h8300,
	411	0, /* only 1 machine */
b2c91bd9	412	"H8/300", /* arch_name */
e89f2fbe SC	413	"H8/300", /* printable name */
	414	true, /* the default machine */
	415	bfd_default_compatible,
b2c91bd9	416	h8300_scan,
e89f2fbe SC	417	print_insn_h8300,
	418	local_bfd_reloc_type_lookup,
	419	0,
	420	};
	421
3b4f1a5d SC	422	void
3b4f1a5d SC	423	DEFUN_VOID(bfd_h8300_arch)
e89f2fbe SC	424	{
	425	bfd_arch_linkin(&arch_info_struct);
	426	}