Home | History | Annotate | Download | only in bfd
      1 /* BFD back-end for Renesas H8/300 ELF binaries.
      2    Copyright (C) 1993-2014 Free Software Foundation, Inc.
      3 
      4    This file is part of BFD, the Binary File Descriptor library.
      5 
      6    This program is free software; you can redistribute it and/or modify
      7    it under the terms of the GNU General Public License as published by
      8    the Free Software Foundation; either version 3 of the License, or
      9    (at your option) any later version.
     10 
     11    This program is distributed in the hope that it will be useful,
     12    but WITHOUT ANY WARRANTY; without even the implied warranty of
     13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     14    GNU General Public License for more details.
     15 
     16    You should have received a copy of the GNU General Public License
     17    along with this program; if not, write to the Free Software
     18    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
     19    MA 02110-1301, USA.  */
     20 
     21 #include "sysdep.h"
     22 #include "bfd.h"
     23 #include "libbfd.h"
     24 #include "elf-bfd.h"
     25 #include "elf/h8.h"
     26 
     27 static reloc_howto_type *elf32_h8_reloc_type_lookup
     28   (bfd *abfd, bfd_reloc_code_real_type code);
     29 static void elf32_h8_info_to_howto
     30   (bfd *, arelent *, Elf_Internal_Rela *);
     31 static void elf32_h8_info_to_howto_rel
     32   (bfd *, arelent *, Elf_Internal_Rela *);
     33 static unsigned long elf32_h8_mach (flagword);
     34 static void elf32_h8_final_write_processing (bfd *, bfd_boolean);
     35 static bfd_boolean elf32_h8_object_p (bfd *);
     36 static bfd_boolean elf32_h8_merge_private_bfd_data (bfd *, bfd *);
     37 static bfd_boolean elf32_h8_relax_section
     38   (bfd *, asection *, struct bfd_link_info *, bfd_boolean *);
     39 static bfd_boolean elf32_h8_relax_delete_bytes
     40   (bfd *, asection *, bfd_vma, int);
     41 static bfd_boolean elf32_h8_symbol_address_p (bfd *, asection *, bfd_vma);
     42 static bfd_byte *elf32_h8_get_relocated_section_contents
     43   (bfd *, struct bfd_link_info *, struct bfd_link_order *,
     44    bfd_byte *, bfd_boolean, asymbol **);
     45 static bfd_reloc_status_type elf32_h8_final_link_relocate
     46   (unsigned long, bfd *, bfd *, asection *,
     47    bfd_byte *, bfd_vma, bfd_vma, bfd_vma,
     48    struct bfd_link_info *, asection *, int);
     49 static bfd_boolean elf32_h8_relocate_section
     50   (bfd *, struct bfd_link_info *, bfd *, asection *,
     51    bfd_byte *, Elf_Internal_Rela *,
     52    Elf_Internal_Sym *, asection **);
     53 static bfd_reloc_status_type special
     54   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
     55 
     56 /* This does not include any relocation information, but should be
     57    good enough for GDB or objdump to read the file.  */
     58 
     59 static reloc_howto_type h8_elf_howto_table[] =
     60 {
     61 #define R_H8_NONE_X 0
     62   HOWTO (R_H8_NONE,		/* type */
     63 	 0,			/* rightshift */
     64 	 0,			/* size (0 = byte, 1 = short, 2 = long) */
     65 	 0,			/* bitsize */
     66 	 FALSE,			/* pc_relative */
     67 	 0,			/* bitpos */
     68 	 complain_overflow_dont,/* complain_on_overflow */
     69 	 special,		/* special_function */
     70 	 "R_H8_NONE",		/* name */
     71 	 FALSE,			/* partial_inplace */
     72 	 0,			/* src_mask */
     73 	 0,			/* dst_mask */
     74 	 FALSE),		/* pcrel_offset */
     75 #define R_H8_DIR32_X (R_H8_NONE_X + 1)
     76   HOWTO (R_H8_DIR32,		/* type */
     77 	 0,			/* rightshift */
     78 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
     79 	 32,			/* bitsize */
     80 	 FALSE,			/* pc_relative */
     81 	 0,			/* bitpos */
     82 	 complain_overflow_dont,/* complain_on_overflow */
     83 	 special,		/* special_function */
     84 	 "R_H8_DIR32",		/* name */
     85 	 FALSE,			/* partial_inplace */
     86 	 0,			/* src_mask */
     87 	 0xffffffff,		/* dst_mask */
     88 	 FALSE),		/* pcrel_offset */
     89 #define R_H8_DIR16_X (R_H8_DIR32_X + 1)
     90   HOWTO (R_H8_DIR16,		/* type */
     91 	 0,			/* rightshift */
     92 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
     93 	 16,			/* bitsize */
     94 	 FALSE,			/* pc_relative */
     95 	 0,			/* bitpos */
     96 	 complain_overflow_dont,/* complain_on_overflow */
     97 	 special,		/* special_function */
     98 	 "R_H8_DIR16",		/* name */
     99 	 FALSE,			/* partial_inplace */
    100 	 0,			/* src_mask */
    101 	 0x0000ffff,		/* dst_mask */
    102 	 FALSE),		/* pcrel_offset */
    103 #define R_H8_DIR8_X (R_H8_DIR16_X + 1)
    104   HOWTO (R_H8_DIR8,		/* type */
    105 	 0,			/* rightshift */
    106 	 0,			/* size (0 = byte, 1 = short, 2 = long) */
    107 	 8,			/* bitsize */
    108 	 FALSE,			/* pc_relative */
    109 	 0,			/* bitpos */
    110 	 complain_overflow_dont,/* complain_on_overflow */
    111 	 special,		/* special_function */
    112 	 "R_H8_DIR8",		/* name */
    113 	 FALSE,			/* partial_inplace */
    114 	 0,			/* src_mask */
    115 	 0x000000ff,		/* dst_mask */
    116 	 FALSE),		/* pcrel_offset */
    117 #define R_H8_DIR16A8_X (R_H8_DIR8_X + 1)
    118   HOWTO (R_H8_DIR16A8,		/* type */
    119 	 0,			/* rightshift */
    120 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
    121 	 16,			/* bitsize */
    122 	 FALSE,			/* pc_relative */
    123 	 0,			/* bitpos */
    124 	 complain_overflow_bitfield, /* complain_on_overflow */
    125 	 special,		/* special_function */
    126 	 "R_H8_DIR16A8",	/* name */
    127 	 FALSE,			/* partial_inplace */
    128 	 0,			/* src_mask */
    129 	 0x0000ffff,		/* dst_mask */
    130 	 FALSE),		/* pcrel_offset */
    131 #define R_H8_DIR16R8_X (R_H8_DIR16A8_X + 1)
    132   HOWTO (R_H8_DIR16R8,		/* type */
    133 	 0,			/* rightshift */
    134 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
    135 	 16,			/* bitsize */
    136 	 FALSE,			/* pc_relative */
    137 	 0,			/* bitpos */
    138 	 complain_overflow_bitfield, /* complain_on_overflow */
    139 	 special,		/* special_function */
    140 	 "R_H8_DIR16R8",	/* name */
    141 	 FALSE,			/* partial_inplace */
    142 	 0,			/* src_mask */
    143 	 0x0000ffff,		/* dst_mask */
    144 	 FALSE),		/* pcrel_offset */
    145 #define R_H8_DIR24A8_X (R_H8_DIR16R8_X + 1)
    146   HOWTO (R_H8_DIR24A8,		/* type */
    147 	 0,			/* rightshift */
    148 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
    149 	 24,			/* bitsize */
    150 	 FALSE,			/* pc_relative */
    151 	 0,			/* bitpos */
    152 	 complain_overflow_bitfield, /* complain_on_overflow */
    153 	 special,		/* special_function */
    154 	 "R_H8_DIR24A8",	/* name */
    155 	 TRUE,			/* partial_inplace */
    156 	 0xff000000,		/* src_mask */
    157 	 0x00ffffff,		/* dst_mask */
    158 	 FALSE),		/* pcrel_offset */
    159 #define R_H8_DIR24R8_X (R_H8_DIR24A8_X + 1)
    160   HOWTO (R_H8_DIR24R8,		/* type */
    161 	 0,			/* rightshift */
    162 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
    163 	 24,			/* bitsize */
    164 	 FALSE,			/* pc_relative */
    165 	 0,			/* bitpos */
    166 	 complain_overflow_bitfield, /* complain_on_overflow */
    167 	 special,		/* special_function */
    168 	 "R_H8_DIR24R8",	/* name */
    169 	 TRUE,			/* partial_inplace */
    170 	 0xff000000,		/* src_mask */
    171 	 0x00ffffff,		/* dst_mask */
    172 	 FALSE),		/* pcrel_offset */
    173 #define R_H8_DIR32A16_X (R_H8_DIR24R8_X + 1)
    174   HOWTO (R_H8_DIR32A16,		/* type */
    175 	 0,			/* rightshift */
    176 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
    177 	 32,			/* bitsize */
    178 	 FALSE,			/* pc_relative */
    179 	 0,			/* bitpos */
    180 	 complain_overflow_dont,/* complain_on_overflow */
    181 	 special,		/* special_function */
    182 	 "R_H8_DIR32A16",	/* name */
    183 	 FALSE,			/* partial_inplace */
    184 	 0,			/* src_mask */
    185 	 0xffffffff,		/* dst_mask */
    186 	 FALSE),		/* pcrel_offset */
    187 #define R_H8_DISP32A16_X (R_H8_DIR32A16_X + 1)
    188   HOWTO (R_H8_DISP32A16,	/* type */
    189 	 0,			/* rightshift */
    190 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
    191 	 32,			/* bitsize */
    192 	 FALSE,			/* pc_relative */
    193 	 0,			/* bitpos */
    194 	 complain_overflow_dont,/* complain_on_overflow */
    195 	 special,		/* special_function */
    196 	 "R_H8_DISP32A16",	/* name */
    197 	 FALSE,			/* partial_inplace */
    198 	 0,			/* src_mask */
    199 	 0xffffffff,		/* dst_mask */
    200 	 FALSE),		/* pcrel_offset */
    201 #define R_H8_PCREL16_X (R_H8_DISP32A16_X + 1)
    202   HOWTO (R_H8_PCREL16,		/* type */
    203 	 0,			/* rightshift */
    204 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
    205 	 16,			/* bitsize */
    206 	 TRUE,			/* pc_relative */
    207 	 0,			/* bitpos */
    208 	 complain_overflow_signed,/* complain_on_overflow */
    209 	 special,		/* special_function */
    210 	 "R_H8_PCREL16",	/* name */
    211 	 FALSE,			/* partial_inplace */
    212 	 0xffff,		/* src_mask */
    213 	 0xffff,		/* dst_mask */
    214 	 TRUE),			/* pcrel_offset */
    215 #define R_H8_PCREL8_X (R_H8_PCREL16_X + 1)
    216   HOWTO (R_H8_PCREL8,		/* type */
    217 	 0,			/* rightshift */
    218 	 0,			/* size (0 = byte, 1 = short, 2 = long) */
    219 	 8,			/* bitsize */
    220 	 TRUE,			/* pc_relative */
    221 	 0,			/* bitpos */
    222 	 complain_overflow_signed,/* complain_on_overflow */
    223 	 special,		/* special_function */
    224 	 "R_H8_PCREL8",		/* name */
    225 	 FALSE,			/* partial_inplace */
    226 	 0xff,			/* src_mask */
    227 	 0xff,			/* dst_mask */
    228 	 TRUE),			/* pcrel_offset */
    229 };
    230 
    231 /* This structure is used to map BFD reloc codes to H8 ELF relocs.  */
    232 
    233 struct elf_reloc_map {
    234   bfd_reloc_code_real_type bfd_reloc_val;
    235   unsigned char howto_index;
    236 };
    237 
    238 /* An array mapping BFD reloc codes to H8 ELF relocs.  */
    239 
    240 static const struct elf_reloc_map h8_reloc_map[] = {
    241   { BFD_RELOC_NONE, R_H8_NONE_X },
    242   { BFD_RELOC_32, R_H8_DIR32_X },
    243   { BFD_RELOC_16, R_H8_DIR16_X },
    244   { BFD_RELOC_8, R_H8_DIR8_X },
    245   { BFD_RELOC_H8_DIR16A8, R_H8_DIR16A8_X },
    246   { BFD_RELOC_H8_DIR16R8, R_H8_DIR16R8_X },
    247   { BFD_RELOC_H8_DIR24A8, R_H8_DIR24A8_X },
    248   { BFD_RELOC_H8_DIR24R8, R_H8_DIR24R8_X },
    249   { BFD_RELOC_H8_DIR32A16, R_H8_DIR32A16_X },
    250   { BFD_RELOC_H8_DISP32A16, R_H8_DISP32A16_X },
    251   { BFD_RELOC_16_PCREL, R_H8_PCREL16_X },
    252   { BFD_RELOC_8_PCREL, R_H8_PCREL8_X },
    253 };
    254 
    255 
    256 static reloc_howto_type *
    257 elf32_h8_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
    258 			    bfd_reloc_code_real_type code)
    259 {
    260   unsigned int i;
    261 
    262   for (i = 0; i < sizeof (h8_reloc_map) / sizeof (struct elf_reloc_map); i++)
    263     {
    264       if (h8_reloc_map[i].bfd_reloc_val == code)
    265 	return &h8_elf_howto_table[(int) h8_reloc_map[i].howto_index];
    266     }
    267   return NULL;
    268 }
    269 
    270 static reloc_howto_type *
    271 elf32_h8_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
    272 			    const char *r_name)
    273 {
    274   unsigned int i;
    275 
    276   for (i = 0;
    277        i < sizeof (h8_elf_howto_table) / sizeof (h8_elf_howto_table[0]);
    278        i++)
    279     if (h8_elf_howto_table[i].name != NULL
    280 	&& strcasecmp (h8_elf_howto_table[i].name, r_name) == 0)
    281       return &h8_elf_howto_table[i];
    282 
    283   return NULL;
    284 }
    285 
    286 static void
    287 elf32_h8_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *bfd_reloc,
    288 			Elf_Internal_Rela *elf_reloc)
    289 {
    290   unsigned int r;
    291   unsigned int i;
    292 
    293   r = ELF32_R_TYPE (elf_reloc->r_info);
    294   for (i = 0; i < sizeof (h8_elf_howto_table) / sizeof (reloc_howto_type); i++)
    295     if (h8_elf_howto_table[i].type == r)
    296       {
    297 	bfd_reloc->howto = &h8_elf_howto_table[i];
    298 	return;
    299       }
    300   abort ();
    301 }
    302 
    303 static void
    304 elf32_h8_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED, arelent *bfd_reloc,
    305 			    Elf_Internal_Rela *elf_reloc ATTRIBUTE_UNUSED)
    306 {
    307   unsigned int r;
    308 
    309   abort ();
    310   r = ELF32_R_TYPE (elf_reloc->r_info);
    311   bfd_reloc->howto = &h8_elf_howto_table[r];
    312 }
    313 
    314 /* Special handling for H8/300 relocs.
    315    We only come here for pcrel stuff and return normally if not an -r link.
    316    When doing -r, we can't do any arithmetic for the pcrel stuff, because
    317    we support relaxing on the H8/300 series chips.  */
    318 static bfd_reloc_status_type
    319 special (bfd *abfd ATTRIBUTE_UNUSED,
    320 	 arelent *reloc_entry ATTRIBUTE_UNUSED,
    321 	 asymbol *symbol ATTRIBUTE_UNUSED,
    322 	 void * data ATTRIBUTE_UNUSED,
    323 	 asection *input_section ATTRIBUTE_UNUSED,
    324 	 bfd *output_bfd,
    325 	 char **error_message ATTRIBUTE_UNUSED)
    326 {
    327   if (output_bfd == (bfd *) NULL)
    328     return bfd_reloc_continue;
    329 
    330   /* Adjust the reloc address to that in the output section.  */
    331   reloc_entry->address += input_section->output_offset;
    332   return bfd_reloc_ok;
    333 }
    334 
    335 /* Perform a relocation as part of a final link.  */
    336 static bfd_reloc_status_type
    337 elf32_h8_final_link_relocate (unsigned long r_type, bfd *input_bfd,
    338 			      bfd *output_bfd ATTRIBUTE_UNUSED,
    339 			      asection *input_section ATTRIBUTE_UNUSED,
    340 			      bfd_byte *contents, bfd_vma offset,
    341 			      bfd_vma value, bfd_vma addend,
    342 			      struct bfd_link_info *info ATTRIBUTE_UNUSED,
    343 			      asection *sym_sec ATTRIBUTE_UNUSED,
    344 			      int is_local ATTRIBUTE_UNUSED)
    345 {
    346   bfd_byte *hit_data = contents + offset;
    347 
    348   switch (r_type)
    349     {
    350     case R_H8_NONE:
    351       return bfd_reloc_ok;
    352 
    353     case R_H8_DIR32:
    354     case R_H8_DIR32A16:
    355     case R_H8_DISP32A16:
    356     case R_H8_DIR24A8:
    357       value += addend;
    358       bfd_put_32 (input_bfd, value, hit_data);
    359       return bfd_reloc_ok;
    360 
    361     case R_H8_DIR16:
    362     case R_H8_DIR16A8:
    363     case R_H8_DIR16R8:
    364       value += addend;
    365       bfd_put_16 (input_bfd, value, hit_data);
    366       return bfd_reloc_ok;
    367 
    368     /* AKA R_RELBYTE */
    369     case R_H8_DIR8:
    370       value += addend;
    371 
    372       bfd_put_8 (input_bfd, value, hit_data);
    373       return bfd_reloc_ok;
    374 
    375     case R_H8_DIR24R8:
    376       value += addend;
    377 
    378       /* HIT_DATA is the address for the first byte for the relocated
    379 	 value.  Subtract 1 so that we can manipulate the data in 32-bit
    380 	 hunks.  */
    381       hit_data--;
    382 
    383       /* Clear out the top byte in value.  */
    384       value &= 0xffffff;
    385 
    386       /* Retrieve the type byte for value from the section contents.  */
    387       value |= (bfd_get_32 (input_bfd, hit_data) & 0xff000000);
    388 
    389       /* Now scribble it out in one 32-bit hunk.  */
    390       bfd_put_32 (input_bfd, value, hit_data);
    391       return bfd_reloc_ok;
    392 
    393     case R_H8_PCREL16:
    394       value -= (input_section->output_section->vma
    395 		+ input_section->output_offset);
    396       value -= offset;
    397       value += addend;
    398 
    399       /* The value is relative to the start of the instruction,
    400 	 not the relocation offset.  Subtract 2 to account for
    401 	 this minor issue.  */
    402       value -= 2;
    403 
    404       bfd_put_16 (input_bfd, value, hit_data);
    405       return bfd_reloc_ok;
    406 
    407     case R_H8_PCREL8:
    408       value -= (input_section->output_section->vma
    409 		+ input_section->output_offset);
    410       value -= offset;
    411       value += addend;
    412 
    413       /* The value is relative to the start of the instruction,
    414 	 not the relocation offset.  Subtract 1 to account for
    415 	 this minor issue.  */
    416       value -= 1;
    417 
    418       bfd_put_8 (input_bfd, value, hit_data);
    419       return bfd_reloc_ok;
    420 
    421     default:
    422       return bfd_reloc_notsupported;
    423     }
    424 }
    425 
    426 /* Relocate an H8 ELF section.  */
    428 static bfd_boolean
    429 elf32_h8_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
    430 			   bfd *input_bfd, asection *input_section,
    431 			   bfd_byte *contents, Elf_Internal_Rela *relocs,
    432 			   Elf_Internal_Sym *local_syms,
    433 			   asection **local_sections)
    434 {
    435   Elf_Internal_Shdr *symtab_hdr;
    436   struct elf_link_hash_entry **sym_hashes;
    437   Elf_Internal_Rela *rel, *relend;
    438 
    439   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
    440   sym_hashes = elf_sym_hashes (input_bfd);
    441 
    442   rel = relocs;
    443   relend = relocs + input_section->reloc_count;
    444   for (; rel < relend; rel++)
    445     {
    446       unsigned int r_type;
    447       unsigned long r_symndx;
    448       Elf_Internal_Sym *sym;
    449       asection *sec;
    450       struct elf_link_hash_entry *h;
    451       bfd_vma relocation;
    452       bfd_reloc_status_type r;
    453       arelent bfd_reloc;
    454       reloc_howto_type *howto;
    455 
    456       elf32_h8_info_to_howto (input_bfd, &bfd_reloc, rel);
    457       howto = bfd_reloc.howto;
    458 
    459       r_symndx = ELF32_R_SYM (rel->r_info);
    460       r_type = ELF32_R_TYPE (rel->r_info);
    461       h = NULL;
    462       sym = NULL;
    463       sec = NULL;
    464       if (r_symndx < symtab_hdr->sh_info)
    465 	{
    466 	  sym = local_syms + r_symndx;
    467 	  sec = local_sections[r_symndx];
    468 	  relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
    469 	}
    470       else
    471 	{
    472 	  bfd_boolean unresolved_reloc, warned, ignored;
    473 
    474 	  RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
    475 				   r_symndx, symtab_hdr, sym_hashes,
    476 				   h, sec, relocation,
    477 				   unresolved_reloc, warned, ignored);
    478 	}
    479 
    480       if (sec != NULL && discarded_section (sec))
    481 	RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
    482 					 rel, 1, relend, howto, 0, contents);
    483 
    484       if (info->relocatable)
    485 	continue;
    486 
    487       r = elf32_h8_final_link_relocate (r_type, input_bfd, output_bfd,
    488 					input_section,
    489 					contents, rel->r_offset,
    490 					relocation, rel->r_addend,
    491 					info, sec, h == NULL);
    492 
    493       if (r != bfd_reloc_ok)
    494 	{
    495 	  const char *name;
    496 	  const char *msg = (const char *) 0;
    497 
    498 	  if (h != NULL)
    499 	    name = h->root.root.string;
    500 	  else
    501 	    {
    502 	      name = (bfd_elf_string_from_elf_section
    503 		      (input_bfd, symtab_hdr->sh_link, sym->st_name));
    504 	      if (name == NULL || *name == '\0')
    505 		name = bfd_section_name (input_bfd, sec);
    506 	    }
    507 
    508 	  switch (r)
    509 	    {
    510 	    case bfd_reloc_overflow:
    511 	      if (! ((*info->callbacks->reloc_overflow)
    512 		     (info, (h ? &h->root : NULL), name, howto->name,
    513 		      (bfd_vma) 0, input_bfd, input_section,
    514 		      rel->r_offset)))
    515 		return FALSE;
    516 	      break;
    517 
    518 	    case bfd_reloc_undefined:
    519 	      if (! ((*info->callbacks->undefined_symbol)
    520 		     (info, name, input_bfd, input_section,
    521 		      rel->r_offset, TRUE)))
    522 		return FALSE;
    523 	      break;
    524 
    525 	    case bfd_reloc_outofrange:
    526 	      msg = _("internal error: out of range error");
    527 	      goto common_error;
    528 
    529 	    case bfd_reloc_notsupported:
    530 	      msg = _("internal error: unsupported relocation error");
    531 	      goto common_error;
    532 
    533 	    case bfd_reloc_dangerous:
    534 	      msg = _("internal error: dangerous error");
    535 	      goto common_error;
    536 
    537 	    default:
    538 	      msg = _("internal error: unknown error");
    539 	      /* fall through */
    540 
    541 	    common_error:
    542 	      if (!((*info->callbacks->warning)
    543 		    (info, msg, name, input_bfd, input_section,
    544 		     rel->r_offset)))
    545 		return FALSE;
    546 	      break;
    547 	    }
    548 	}
    549     }
    550 
    551   return TRUE;
    552 }
    553 
    554 /* Object files encode the specific H8 model they were compiled
    555    for in the ELF flags field.
    556 
    557    Examine that field and return the proper BFD machine type for
    558    the object file.  */
    559 static unsigned long
    560 elf32_h8_mach (flagword flags)
    561 {
    562   switch (flags & EF_H8_MACH)
    563     {
    564     case E_H8_MACH_H8300:
    565     default:
    566       return bfd_mach_h8300;
    567 
    568     case E_H8_MACH_H8300H:
    569       return bfd_mach_h8300h;
    570 
    571     case E_H8_MACH_H8300S:
    572       return bfd_mach_h8300s;
    573 
    574     case E_H8_MACH_H8300HN:
    575       return bfd_mach_h8300hn;
    576 
    577     case E_H8_MACH_H8300SN:
    578       return bfd_mach_h8300sn;
    579 
    580     case E_H8_MACH_H8300SX:
    581       return bfd_mach_h8300sx;
    582 
    583     case E_H8_MACH_H8300SXN:
    584       return bfd_mach_h8300sxn;
    585     }
    586 }
    587 
    588 /* The final processing done just before writing out a H8 ELF object
    589    file.  We use this opportunity to encode the BFD machine type
    590    into the flags field in the object file.  */
    591 
    592 static void
    593 elf32_h8_final_write_processing (bfd *abfd,
    594 				 bfd_boolean linker ATTRIBUTE_UNUSED)
    595 {
    596   unsigned long val;
    597 
    598   switch (bfd_get_mach (abfd))
    599     {
    600     default:
    601     case bfd_mach_h8300:
    602       val = E_H8_MACH_H8300;
    603       break;
    604 
    605     case bfd_mach_h8300h:
    606       val = E_H8_MACH_H8300H;
    607       break;
    608 
    609     case bfd_mach_h8300s:
    610       val = E_H8_MACH_H8300S;
    611       break;
    612 
    613     case bfd_mach_h8300hn:
    614       val = E_H8_MACH_H8300HN;
    615       break;
    616 
    617     case bfd_mach_h8300sn:
    618       val = E_H8_MACH_H8300SN;
    619       break;
    620 
    621     case bfd_mach_h8300sx:
    622       val = E_H8_MACH_H8300SX;
    623       break;
    624 
    625     case bfd_mach_h8300sxn:
    626       val = E_H8_MACH_H8300SXN;
    627       break;
    628     }
    629 
    630   elf_elfheader (abfd)->e_flags &= ~ (EF_H8_MACH);
    631   elf_elfheader (abfd)->e_flags |= val;
    632 }
    633 
    634 /* Return nonzero if ABFD represents a valid H8 ELF object file; also
    635    record the encoded machine type found in the ELF flags.  */
    636 
    637 static bfd_boolean
    638 elf32_h8_object_p (bfd *abfd)
    639 {
    640   bfd_default_set_arch_mach (abfd, bfd_arch_h8300,
    641 			     elf32_h8_mach (elf_elfheader (abfd)->e_flags));
    642   return TRUE;
    643 }
    644 
    645 /* Merge backend specific data from an object file to the output
    646    object file when linking.  The only data we need to copy at this
    647    time is the architecture/machine information.  */
    648 
    649 static bfd_boolean
    650 elf32_h8_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
    651 {
    652   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
    653       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
    654     return TRUE;
    655 
    656   if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
    657       && bfd_get_mach (obfd) < bfd_get_mach (ibfd))
    658     {
    659       if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
    660 			       bfd_get_mach (ibfd)))
    661 	return FALSE;
    662     }
    663 
    664   return TRUE;
    665 }
    666 
    667 /* This function handles relaxing for the H8..
    668 
    669    There are a few relaxing opportunities available on the H8:
    670 
    671      jmp/jsr:24    ->    bra/bsr:8		2 bytes
    672      The jmp may be completely eliminated if the previous insn is a
    673      conditional branch to the insn after the jump.  In that case
    674      we invert the branch and delete the jump and save 4 bytes.
    675 
    676      bCC:16          ->    bCC:8                  2 bytes
    677      bsr:16          ->    bsr:8                  2 bytes
    678 
    679      bset:16	     ->    bset:8                 2 bytes
    680      bset:24/32	     ->    bset:8                 4 bytes
    681      (also applicable to other bit manipulation instructions)
    682 
    683      mov.b:16	     ->    mov.b:8                2 bytes
    684      mov.b:24/32     ->    mov.b:8                4 bytes
    685 
    686      bset:24/32	     ->    bset:16                2 bytes
    687      (also applicable to other bit manipulation instructions)
    688 
    689      mov.[bwl]:24/32 ->    mov.[bwl]:16           2 bytes
    690 
    691      mov.[bwl] @(displ:24/32+ERx) -> mov.[bwl] @(displ:16+ERx)  4 bytes.  */
    692 
    693 static bfd_boolean
    694 elf32_h8_relax_section (bfd *abfd, asection *sec,
    695 			struct bfd_link_info *link_info, bfd_boolean *again)
    696 {
    697   Elf_Internal_Shdr *symtab_hdr;
    698   Elf_Internal_Rela *internal_relocs;
    699   Elf_Internal_Rela *irel, *irelend;
    700   bfd_byte *contents = NULL;
    701   Elf_Internal_Sym *isymbuf = NULL;
    702   static asection *last_input_section = NULL;
    703   static Elf_Internal_Rela *last_reloc = NULL;
    704 
    705   /* Assume nothing changes.  */
    706   *again = FALSE;
    707 
    708   /* We don't have to do anything for a relocatable link, if
    709      this section does not have relocs, or if this is not a
    710      code section.  */
    711   if (link_info->relocatable
    712       || (sec->flags & SEC_RELOC) == 0
    713       || sec->reloc_count == 0
    714       || (sec->flags & SEC_CODE) == 0)
    715     return TRUE;
    716 
    717   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
    718 
    719   /* Get a copy of the native relocations.  */
    720   internal_relocs = (_bfd_elf_link_read_relocs
    721 		     (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
    722 		      link_info->keep_memory));
    723   if (internal_relocs == NULL)
    724     goto error_return;
    725 
    726   if (sec != last_input_section)
    727     last_reloc = NULL;
    728 
    729   last_input_section = sec;
    730 
    731   /* Walk through the relocs looking for relaxing opportunities.  */
    732   irelend = internal_relocs + sec->reloc_count;
    733   for (irel = internal_relocs; irel < irelend; irel++)
    734     {
    735       bfd_vma symval;
    736 
    737       {
    738 	arelent bfd_reloc;
    739 
    740 	elf32_h8_info_to_howto (abfd, &bfd_reloc, irel);
    741       }
    742       /* Keep track of the previous reloc so that we can delete
    743 	 some long jumps created by the compiler.  */
    744       if (irel != internal_relocs)
    745 	last_reloc = irel - 1;
    746 
    747       switch(ELF32_R_TYPE (irel->r_info))
    748 	{
    749 	case R_H8_DIR24R8:
    750 	case R_H8_PCREL16:
    751 	case R_H8_DIR16A8:
    752 	case R_H8_DIR24A8:
    753 	case R_H8_DIR32A16:
    754 	case R_H8_DISP32A16:
    755 	  break;
    756 	default:
    757 	  continue;
    758 	}
    759 
    760       /* Get the section contents if we haven't done so already.  */
    761       if (contents == NULL)
    762 	{
    763 	  /* Get cached copy if it exists.  */
    764 	  if (elf_section_data (sec)->this_hdr.contents != NULL)
    765 	    contents = elf_section_data (sec)->this_hdr.contents;
    766 	  else
    767 	    {
    768 	      /* Go get them off disk.  */
    769 	      if (!bfd_malloc_and_get_section (abfd, sec, &contents))
    770 		goto error_return;
    771 	    }
    772 	}
    773 
    774       /* Read this BFD's local symbols if we haven't done so already.  */
    775       if (isymbuf == NULL && symtab_hdr->sh_info != 0)
    776 	{
    777 	  isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
    778 	  if (isymbuf == NULL)
    779 	    isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
    780 					    symtab_hdr->sh_info, 0,
    781 					    NULL, NULL, NULL);
    782 	  if (isymbuf == NULL)
    783 	    goto error_return;
    784 	}
    785 
    786       /* Get the value of the symbol referred to by the reloc.  */
    787       if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
    788 	{
    789 	  /* A local symbol.  */
    790 	  Elf_Internal_Sym *isym;
    791 	  asection *sym_sec;
    792 
    793 	  isym = isymbuf + ELF32_R_SYM (irel->r_info);
    794 	  sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
    795 	  symval = isym->st_value;
    796 	  /* If the reloc is absolute, it will not have
    797 	     a symbol or section associated with it.  */
    798 	  if (sym_sec)
    799 	    symval += sym_sec->output_section->vma
    800 	      + sym_sec->output_offset;
    801 	}
    802       else
    803 	{
    804 	  unsigned long indx;
    805 	  struct elf_link_hash_entry *h;
    806 
    807 	  /* An external symbol.  */
    808 	  indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
    809 	  h = elf_sym_hashes (abfd)[indx];
    810 	  BFD_ASSERT (h != NULL);
    811 	  if (h->root.type != bfd_link_hash_defined
    812 	      && h->root.type != bfd_link_hash_defweak)
    813 	    {
    814 	      /* This appears to be a reference to an undefined
    815                  symbol.  Just ignore it--it will be caught by the
    816                  regular reloc processing.  */
    817 	      continue;
    818 	    }
    819 
    820 	  symval = (h->root.u.def.value
    821 		    + h->root.u.def.section->output_section->vma
    822 		    + h->root.u.def.section->output_offset);
    823 	}
    824 
    825       /* For simplicity of coding, we are going to modify the section
    826 	 contents, the section relocs, and the BFD symbol table.  We
    827 	 must tell the rest of the code not to free up this
    828 	 information.  It would be possible to instead create a table
    829 	 of changes which have to be made, as is done in coff-mips.c;
    830 	 that would be more work, but would require less memory when
    831 	 the linker is run.  */
    832       switch (ELF32_R_TYPE (irel->r_info))
    833 	{
    834 	  /* Try to turn a 24-bit absolute branch/call into an 8-bit
    835 	     pc-relative branch/call.  */
    836 	case R_H8_DIR24R8:
    837 	  {
    838 	    bfd_vma value = symval + irel->r_addend;
    839 	    bfd_vma dot, gap;
    840 
    841 	    /* Get the address of this instruction.  */
    842 	    dot = (sec->output_section->vma
    843 		   + sec->output_offset + irel->r_offset - 1);
    844 
    845 	    /* Compute the distance from this insn to the branch target.  */
    846 	    gap = value - dot;
    847 
    848 	    /* If the distance is within -126..+130 inclusive, then we can
    849 	       relax this jump.  +130 is valid since the target will move
    850 	       two bytes closer if we do relax this branch.  */
    851 	    if ((int) gap >= -126 && (int) gap <= 130)
    852 	      {
    853 		unsigned char code;
    854 
    855 		/* Note that we've changed the relocs, section contents,
    856 		   etc.  */
    857 		elf_section_data (sec)->relocs = internal_relocs;
    858 		elf_section_data (sec)->this_hdr.contents = contents;
    859 		symtab_hdr->contents = (unsigned char *) isymbuf;
    860 
    861 		/* Get the instruction code being relaxed.  */
    862 		code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
    863 
    864 		/* If the previous instruction conditionally jumped around
    865 		   this instruction, we may be able to reverse the condition
    866 		   and redirect the previous instruction to the target of
    867 		   this instruction.
    868 
    869 		   Such sequences are used by the compiler to deal with
    870 		   long conditional branches.
    871 
    872 		   Only perform this optimisation for jumps (code 0x5a) not
    873 		   subroutine calls, as otherwise it could transform:
    874 
    875 		   mov.w   r0,r0
    876 		   beq     .L1
    877 		   jsr     @_bar
    878 		   .L1:   rts
    879 		   _bar:  rts
    880 		   into:
    881 		   mov.w   r0,r0
    882 		   bne     _bar
    883 		   rts
    884 		   _bar:  rts
    885 
    886 		   which changes the call (jsr) into a branch (bne).  */
    887 		if (code == 0x5a	/* jmp24.  */
    888 		    && (int) gap <= 130
    889 		    && (int) gap >= -128
    890 		    && last_reloc
    891 		    && ELF32_R_TYPE (last_reloc->r_info) == R_H8_PCREL8
    892 		    && ELF32_R_SYM (last_reloc->r_info) < symtab_hdr->sh_info)
    893 		  {
    894 		    bfd_vma last_value;
    895 		    asection *last_sym_sec;
    896 		    Elf_Internal_Sym *last_sym;
    897 
    898 		    /* We will need to examine the symbol used by the
    899 		       previous relocation.  */
    900 
    901 		    last_sym = isymbuf + ELF32_R_SYM (last_reloc->r_info);
    902 		    last_sym_sec
    903 		      = bfd_section_from_elf_index (abfd, last_sym->st_shndx);
    904 		    last_value = (last_sym->st_value
    905 				  + last_sym_sec->output_section->vma
    906 				  + last_sym_sec->output_offset);
    907 
    908 		    /* Verify that the previous relocation was for a
    909 		       branch around this instruction and that no symbol
    910 		       exists at the current location.  */
    911 		    if (last_value == dot + 4
    912 			&& last_reloc->r_offset + 2 == irel->r_offset
    913 			&& ! elf32_h8_symbol_address_p (abfd, sec, dot))
    914 		      {
    915 			/* We can eliminate this jump.  Twiddle the
    916 			   previous relocation as necessary.  */
    917 			irel->r_info
    918 			  = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
    919 					  ELF32_R_TYPE (R_H8_NONE));
    920 
    921 			last_reloc->r_info
    922 			  = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
    923 					  ELF32_R_TYPE (R_H8_PCREL8));
    924 			last_reloc->r_addend = irel->r_addend;
    925 
    926 			code = bfd_get_8 (abfd,
    927 					  contents + last_reloc->r_offset - 1);
    928 			code ^= 1;
    929 			bfd_put_8 (abfd,
    930 				   code,
    931 				   contents + last_reloc->r_offset - 1);
    932 
    933 			/* Delete four bytes of data.  */
    934 			if (!elf32_h8_relax_delete_bytes (abfd, sec,
    935 							  irel->r_offset - 1,
    936 							  4))
    937 			  goto error_return;
    938 
    939 			*again = TRUE;
    940 			break;
    941 		      }
    942 		  }
    943 
    944 		if (code == 0x5e)
    945 		  /* This is jsr24  */
    946 		  bfd_put_8 (abfd, 0x55, contents + irel->r_offset - 1);	/* bsr8. */
    947 		else if (code == 0x5a)
    948 		  /* This is jmp24  */
    949 		  bfd_put_8 (abfd, 0x40, contents + irel->r_offset - 1);	/* bra8. */
    950 		else
    951 		  abort ();
    952 
    953 		/* Fix the relocation's type.  */
    954 		irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
    955 					     R_H8_PCREL8);
    956 
    957 		/* Delete two bytes of data.  */
    958 		if (!elf32_h8_relax_delete_bytes (abfd, sec,
    959 						  irel->r_offset + 1, 2))
    960 		  goto error_return;
    961 
    962 		/* That will change things, so, we should relax again.
    963 		   Note that this is not required, and it may be slow.  */
    964 		*again = TRUE;
    965 	      }
    966 	    break;
    967 	  }
    968 
    969 	  /* Try to turn a 16-bit pc-relative branch into a 8-bit pc-relative
    970 	     branch.  */
    971 	case R_H8_PCREL16:
    972 	  {
    973 	    bfd_vma value = symval + irel->r_addend;
    974 	    bfd_vma dot;
    975 	    bfd_vma gap;
    976 
    977 	    /* Get the address of this instruction.  */
    978 	    dot = (sec->output_section->vma
    979 		   + sec->output_offset
    980 		   + irel->r_offset - 2);
    981 
    982 	    gap = value - dot;
    983 
    984 	    /* If the distance is within -126..+130 inclusive, then we can
    985 	       relax this jump.  +130 is valid since the target will move
    986 	       two bytes closer if we do relax this branch.  */
    987 	    if ((int) gap >= -126 && (int) gap <= 130)
    988 	      {
    989 		unsigned char code;
    990 
    991 		/* Note that we've changed the relocs, section contents,
    992 		   etc.  */
    993 		elf_section_data (sec)->relocs = internal_relocs;
    994 		elf_section_data (sec)->this_hdr.contents = contents;
    995 		symtab_hdr->contents = (unsigned char *) isymbuf;
    996 
    997 		/* Get the opcode.  */
    998 		code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
    999 
   1000 		if (code == 0x58)
   1001 		  {
   1002 		    /* bCC:16 -> bCC:8 */
   1003 		    /* Get the second byte of the original insn, which
   1004 		       contains the condition code.  */
   1005 		    code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
   1006 
   1007 		    /* Compute the first byte of the relaxed
   1008 		       instruction.  The original sequence 0x58 0xX0
   1009 		       is relaxed to 0x4X, where X represents the
   1010 		       condition code.  */
   1011 		    code &= 0xf0;
   1012 		    code >>= 4;
   1013 		    code |= 0x40;
   1014 		    bfd_put_8 (abfd, code, contents + irel->r_offset - 2); /* bCC:8.  */
   1015 		  }
   1016 		else if (code == 0x5c)	/* bsr16.  */
   1017 		  /* This is bsr.  */
   1018 		  bfd_put_8 (abfd, 0x55, contents + irel->r_offset - 2);  /* bsr8.  */
   1019 		else
   1020 		  /* Might be MOVSD.  */
   1021 		  break;
   1022 
   1023 		/* Fix the relocation's type.  */
   1024 		irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
   1025 					     R_H8_PCREL8);
   1026 		irel->r_offset--;
   1027 
   1028 		/* Delete two bytes of data.  */
   1029 		if (!elf32_h8_relax_delete_bytes (abfd, sec,
   1030 						  irel->r_offset + 1, 2))
   1031 		  goto error_return;
   1032 
   1033 		/* That will change things, so, we should relax again.
   1034 		   Note that this is not required, and it may be slow.  */
   1035 		*again = TRUE;
   1036 	      }
   1037 	    break;
   1038 	  }
   1039 
   1040 	  /* This is a 16-bit absolute address in one of the following
   1041 	     instructions:
   1042 
   1043 	     "band", "bclr", "biand", "bild", "bior", "bist", "bixor",
   1044 	     "bld", "bnot", "bor", "bset", "bst", "btst", "bxor", and
   1045 	     "mov.b"
   1046 
   1047 	     We may relax this into an 8-bit absolute address if it's in
   1048 	     the right range.  */
   1049 	case R_H8_DIR16A8:
   1050 	  {
   1051 	    bfd_vma value;
   1052 
   1053 	    value = bfd_h8300_pad_address (abfd, symval + irel->r_addend);
   1054 	    if (value >= 0xffffff00u)
   1055 	      {
   1056 		unsigned char code;
   1057 		unsigned char temp_code;
   1058 
   1059 		/* Note that we've changed the relocs, section contents,
   1060 		   etc.  */
   1061 		elf_section_data (sec)->relocs = internal_relocs;
   1062 		elf_section_data (sec)->this_hdr.contents = contents;
   1063 		symtab_hdr->contents = (unsigned char *) isymbuf;
   1064 
   1065 		/* Get the opcode.  */
   1066 		code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
   1067 
   1068 		/* All instructions with R_H8_DIR16A8 start with
   1069 		   0x6a.  */
   1070 		if (code != 0x6a)
   1071 		  abort ();
   1072 
   1073 		temp_code = code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
   1074 		/* If this is a mov.b instruction, clear the lower
   1075 		   nibble, which contains the source/destination
   1076 		   register number.  */
   1077 		if ((temp_code & 0x10) != 0x10)
   1078 		  temp_code &= 0xf0;
   1079 
   1080 		switch (temp_code)
   1081 		  {
   1082 		  case 0x00:
   1083 		    /* This is mov.b @aa:16,Rd.  */
   1084 		    bfd_put_8 (abfd, (code & 0xf) | 0x20,
   1085 			       contents + irel->r_offset - 2);
   1086 		    break;
   1087 		  case 0x80:
   1088 		    /* This is mov.b Rs,@aa:16.  */
   1089 		    bfd_put_8 (abfd, (code & 0xf) | 0x30,
   1090 			       contents + irel->r_offset - 2);
   1091 		    break;
   1092 		  case 0x18:
   1093 		    /* This is a bit-maniputation instruction that
   1094 		       stores one bit into memory, one of "bclr",
   1095 		       "bist", "bnot", "bset", and "bst".  */
   1096 		    bfd_put_8 (abfd, 0x7f, contents + irel->r_offset - 2);
   1097 		    break;
   1098 		  case 0x10:
   1099 		    /* This is a bit-maniputation instruction that
   1100 		       loads one bit from memory, one of "band",
   1101 		       "biand", "bild", "bior", "bixor", "bld", "bor",
   1102 		       "btst", and "bxor".  */
   1103 		    bfd_put_8 (abfd, 0x7e, contents + irel->r_offset - 2);
   1104 		    break;
   1105 		  default:
   1106 		    abort ();
   1107 		  }
   1108 
   1109 		/* Fix the relocation's type.  */
   1110 		irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
   1111 					     R_H8_DIR8);
   1112 
   1113 		/* Move the relocation.  */
   1114 		irel->r_offset--;
   1115 
   1116 		/* Delete two bytes of data.  */
   1117 		if (!elf32_h8_relax_delete_bytes (abfd, sec,
   1118 						  irel->r_offset + 1, 2))
   1119 		  goto error_return;
   1120 
   1121 		/* That will change things, so, we should relax again.
   1122 		   Note that this is not required, and it may be slow.  */
   1123 		*again = TRUE;
   1124 	      }
   1125 	    break;
   1126 	  }
   1127 
   1128 	  /* This is a 24-bit absolute address in one of the following
   1129 	     instructions:
   1130 
   1131 	     "band", "bclr", "biand", "bild", "bior", "bist", "bixor",
   1132 	     "bld", "bnot", "bor", "bset", "bst", "btst", "bxor", and
   1133 	     "mov.b"
   1134 
   1135 	     We may relax this into an 8-bit absolute address if it's in
   1136 	     the right range.  */
   1137 	case R_H8_DIR24A8:
   1138 	  {
   1139 	    bfd_vma value;
   1140 
   1141 	    value = bfd_h8300_pad_address (abfd, symval + irel->r_addend);
   1142 	    if (value >= 0xffffff00u)
   1143 	      {
   1144 		unsigned char code;
   1145 		unsigned char temp_code;
   1146 
   1147 		/* Note that we've changed the relocs, section contents,
   1148 		   etc.  */
   1149 		elf_section_data (sec)->relocs = internal_relocs;
   1150 		elf_section_data (sec)->this_hdr.contents = contents;
   1151 		symtab_hdr->contents = (unsigned char *) isymbuf;
   1152 
   1153 		/* Get the opcode.  */
   1154 		code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
   1155 
   1156 		/* All instructions with R_H8_DIR24A8 start with
   1157 		   0x6a.  */
   1158 		if (code != 0x6a)
   1159 		  abort ();
   1160 
   1161 		temp_code = code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
   1162 
   1163 		/* If this is a mov.b instruction, clear the lower
   1164 		   nibble, which contains the source/destination
   1165 		   register number.  */
   1166 		if ((temp_code & 0x30) != 0x30)
   1167 		  temp_code &= 0xf0;
   1168 
   1169 		switch (temp_code)
   1170 		  {
   1171 		  case 0x20:
   1172 		    /* This is mov.b @aa:24/32,Rd.  */
   1173 		    bfd_put_8 (abfd, (code & 0xf) | 0x20,
   1174 			       contents + irel->r_offset - 2);
   1175 		    break;
   1176 		  case 0xa0:
   1177 		    /* This is mov.b Rs,@aa:24/32.  */
   1178 		    bfd_put_8 (abfd, (code & 0xf) | 0x30,
   1179 			       contents + irel->r_offset - 2);
   1180 		    break;
   1181 		  case 0x38:
   1182 		    /* This is a bit-maniputation instruction that
   1183 		       stores one bit into memory, one of "bclr",
   1184 		       "bist", "bnot", "bset", and "bst".  */
   1185 		    bfd_put_8 (abfd, 0x7f, contents + irel->r_offset - 2);
   1186 		    break;
   1187 		  case 0x30:
   1188 		    /* This is a bit-maniputation instruction that
   1189 		       loads one bit from memory, one of "band",
   1190 		       "biand", "bild", "bior", "bixor", "bld", "bor",
   1191 		       "btst", and "bxor".  */
   1192 		    bfd_put_8 (abfd, 0x7e, contents + irel->r_offset - 2);
   1193 		    break;
   1194 		  default:
   1195 		    abort();
   1196 		  }
   1197 
   1198 		/* Fix the relocation's type.  */
   1199 		irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
   1200 					     R_H8_DIR8);
   1201 		irel->r_offset--;
   1202 
   1203 		/* Delete four bytes of data.  */
   1204 		if (!elf32_h8_relax_delete_bytes (abfd, sec,
   1205 						  irel->r_offset + 1, 4))
   1206 		  goto error_return;
   1207 
   1208 		/* That will change things, so, we should relax again.
   1209 		   Note that this is not required, and it may be slow.  */
   1210 		*again = TRUE;
   1211 		break;
   1212 	      }
   1213 	  }
   1214 
   1215 	  /* Fall through.  */
   1216 
   1217 	  /* This is a 24-/32-bit absolute address in one of the
   1218 	     following instructions:
   1219 
   1220 	     "band", "bclr", "biand", "bild", "bior", "bist",
   1221 	     "bixor", "bld", "bnot", "bor", "bset", "bst", "btst",
   1222 	     "bxor", "ldc.w", "stc.w" and "mov.[bwl]"
   1223 
   1224 	     We may relax this into an 16-bit absolute address if it's
   1225 	     in the right range.  */
   1226 	case R_H8_DIR32A16:
   1227 	  {
   1228 	    bfd_vma value;
   1229 
   1230 	    value = bfd_h8300_pad_address (abfd, symval + irel->r_addend);
   1231 	    if (value <= 0x7fff || value >= 0xffff8000u)
   1232 	      {
   1233 		unsigned char code;
   1234 		unsigned char op0, op1, op2, op3;
   1235 		unsigned char *op_ptr;
   1236 
   1237 		/* Note that we've changed the relocs, section contents,
   1238 		   etc.  */
   1239 		elf_section_data (sec)->relocs = internal_relocs;
   1240 		elf_section_data (sec)->this_hdr.contents = contents;
   1241 		symtab_hdr->contents = (unsigned char *) isymbuf;
   1242 
   1243 		if (irel->r_offset >= 4)
   1244 		  {
   1245 		    /* Check for 4-byte MOVA relaxation (SH-specific).  */
   1246 		    int second_reloc = 0;
   1247 
   1248 		    op_ptr = contents + irel->r_offset - 4;
   1249 
   1250 		    if (last_reloc)
   1251 		      {
   1252 			arelent bfd_reloc;
   1253 			reloc_howto_type *h;
   1254 			bfd_vma last_reloc_size;
   1255 
   1256 			elf32_h8_info_to_howto (abfd, &bfd_reloc, last_reloc);
   1257 			h = bfd_reloc.howto;
   1258 			last_reloc_size = 1 << h->size;
   1259 			if (last_reloc->r_offset + last_reloc_size
   1260 			    == irel->r_offset)
   1261 			  {
   1262 			    op_ptr -= last_reloc_size;
   1263 			    second_reloc = 1;
   1264 			  }
   1265 		      }
   1266 
   1267 		    if (irel + 1 < irelend)
   1268 		      {
   1269 			Elf_Internal_Rela *next_reloc = irel + 1;
   1270 			arelent bfd_reloc;
   1271 			reloc_howto_type *h;
   1272 			bfd_vma next_reloc_size;
   1273 
   1274 			elf32_h8_info_to_howto (abfd, &bfd_reloc, next_reloc);
   1275 			h = bfd_reloc.howto;
   1276 			next_reloc_size = 1 << h->size;
   1277 			if (next_reloc->r_offset + next_reloc_size
   1278 			    == irel->r_offset)
   1279 			  {
   1280 			    op_ptr -= next_reloc_size;
   1281 			    second_reloc = 1;
   1282 			  }
   1283 		      }
   1284 
   1285 		    op0 = bfd_get_8 (abfd, op_ptr + 0);
   1286 		    op1 = bfd_get_8 (abfd, op_ptr + 1);
   1287 		    op2 = bfd_get_8 (abfd, op_ptr + 2);
   1288 		    op3 = bfd_get_8 (abfd, op_ptr + 3);
   1289 
   1290 		    if (op0 == 0x01
   1291 			&& (op1 & 0xdf) == 0x5f
   1292 			&& (op2 & 0x40) == 0x40
   1293 			&& (op3 & 0x80) == 0x80)
   1294 		      {
   1295 			if ((op2 & 0x08) == 0)
   1296 			  second_reloc = 1;
   1297 
   1298 			if (second_reloc)
   1299 			  {
   1300 			    op3 &= ~0x08;
   1301 			    bfd_put_8 (abfd, op3, op_ptr + 3);
   1302 			  }
   1303 			else
   1304 			  {
   1305 			    op2 &= ~0x08;
   1306 			    bfd_put_8 (abfd, op2, op_ptr + 2);
   1307 			  }
   1308 			goto r_h8_dir32a16_common;
   1309 		      }
   1310 		  }
   1311 
   1312 		/* Now check for short version of MOVA.  (SH-specific) */
   1313 		op_ptr = contents + irel->r_offset - 2;
   1314 		op0 = bfd_get_8 (abfd, op_ptr + 0);
   1315 		op1 = bfd_get_8 (abfd, op_ptr + 1);
   1316 
   1317 		if (op0 == 0x7a
   1318 		    && (op1 & 0x88) == 0x80)
   1319 		  {
   1320 		    op1 |= 0x08;
   1321 		    bfd_put_8 (abfd, op1, op_ptr + 1);
   1322 		    goto r_h8_dir32a16_common;
   1323 		  }
   1324 
   1325 		/* Get the opcode.  */
   1326 		code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
   1327 
   1328 		/* Fix the opcode.  For all the instructions that
   1329 		   belong to this relaxation, we simply need to turn
   1330 		   off bit 0x20 in the previous byte.  */
   1331 		code &= ~0x20;
   1332 
   1333 		bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
   1334 
   1335 	      r_h8_dir32a16_common:
   1336 		/* Fix the relocation's type.  */
   1337 		irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
   1338 					     R_H8_DIR16);
   1339 
   1340 		/* Delete two bytes of data.  */
   1341 		if (!elf32_h8_relax_delete_bytes (abfd, sec,
   1342 						  irel->r_offset + 1, 2))
   1343 		  goto error_return;
   1344 
   1345 		/* That will change things, so, we should relax again.
   1346 		   Note that this is not required, and it may be slow.  */
   1347 		*again = TRUE;
   1348 	      }
   1349 	    break;	/* case R_H8_DIR32A16 */
   1350 	  }
   1351 
   1352 	case R_H8_DISP32A16:
   1353 	  /* mov.[bwl] @(displ:24/32+ERx) -> mov.[bwl] @(displ:16+ERx)  4 bytes
   1354 	     It is assured that instruction uses at least 4 bytes opcode before
   1355 	     reloc entry addressing mode "register indirect with displacement"
   1356 	     relaxing options (all saving 4 bytes):
   1357 	     0x78 0sss0000 0x6A 0010dddd disp:32  mov.b @(d:32,ERs),Rd  ->
   1358 	     0x6E 0sssdddd disp:16  mov.b @(d:16,ERs),Rd
   1359 	     0x78 0sss0000 0x6B 0010dddd disp:32  mov.w @(d:32,ERs),Rd  ->
   1360 	     0x6F 0sssdddd disp:16  mov.w @(d:16,ERs),Rd
   1361 	     0x01 0x00 0x78 0sss0000 0x6B 00100ddd disp:32  mov.l @(d:32,ERs),ERd ->
   1362 	     0x01 0x00 0x6F 0sss0ddd disp:16  mov.l @(d:16,ERs),ERd
   1363 
   1364 	     0x78 0ddd0000 0x6A 1010ssss disp:32  mov.b Rs,@(d:32,ERd)  ->
   1365 	     0x6E 1dddssss disp:16  mov.b Rs,@(d:16,ERd)
   1366 	     0x78 0ddd0000 0x6B 1010ssss disp:32  mov.w Rs,@(d:32,ERd)  ->
   1367 	     0x6F 1dddssss disp:16  mov.w Rs,@(d:16,ERd)
   1368 	     0x01 0x00 0x78 xddd0000 0x6B 10100sss disp:32  mov.l ERs,@(d:32,ERd) ->
   1369 	     0x01 0x00 0x6F 1ddd0sss disp:16  mov.l ERs,@(d:16,ERd)
   1370 	     mov.l prefix 0x01 0x00 can be left as is and mov.l handled same
   1371 	     as mov.w/  */
   1372 	  {
   1373 	    bfd_vma value;
   1374 
   1375 	    value = bfd_h8300_pad_address (abfd, symval + irel->r_addend);
   1376 	    if (value <= 0x7fff || value >= 0xffff8000u)
   1377 	      {
   1378 		unsigned char op0, op1, op2, op3, op0n, op1n;
   1379 		int relax = 0;
   1380 
   1381 		/* Note that we've changed the relocs, section contents,
   1382 		   etc.  */
   1383 		elf_section_data (sec)->relocs = internal_relocs;
   1384 		elf_section_data (sec)->this_hdr.contents = contents;
   1385 		symtab_hdr->contents = (unsigned char *) isymbuf;
   1386 
   1387 		if (irel->r_offset >= 4)
   1388 		  {
   1389 		    op0 = bfd_get_8 (abfd, contents + irel->r_offset - 4);
   1390 		    op1 = bfd_get_8 (abfd, contents + irel->r_offset - 3);
   1391 		    op2 = bfd_get_8 (abfd, contents + irel->r_offset - 2);
   1392 		    op3 = bfd_get_8 (abfd, contents + irel->r_offset - 1);
   1393 
   1394 		    if (op0 == 0x78)
   1395 		      {
   1396 			switch(op2)
   1397 			  {
   1398 			  case 0x6A:
   1399 			    if ((op1 & 0x8F) == 0x00 && (op3 & 0x70) == 0x20)
   1400 			      {
   1401 				/* mov.b.  */
   1402 				op0n = 0x6E;
   1403 				relax = 1;
   1404 			      }
   1405 			    break;
   1406 			  case 0x6B:
   1407 			    if ((op1 & 0x0F) == 0x00 && (op3 & 0x70) == 0x20)
   1408 			      {
   1409 				/* mov.w/l.  */
   1410 				op0n = 0x6F;
   1411 				relax = 1;
   1412 			      }
   1413 			    break;
   1414 			  default:
   1415 			    break;
   1416 			  }
   1417 		      }
   1418 		  }
   1419 
   1420 		if (relax)
   1421 		  {
   1422 		    op1n = (op3 & 0x8F) | (op1 & 0x70);
   1423 		    bfd_put_8 (abfd, op0n, contents + irel->r_offset - 4);
   1424 		    bfd_put_8 (abfd, op1n, contents + irel->r_offset - 3);
   1425 
   1426 		    /* Fix the relocation's type.  */
   1427 		    irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_H8_DIR16);
   1428 		    irel->r_offset -= 2;
   1429 
   1430 		    /* Delete four bytes of data.  */
   1431 		    if (!elf32_h8_relax_delete_bytes (abfd, sec, irel->r_offset + 2, 4))
   1432 		      goto error_return;
   1433 
   1434 		    /* That will change things, so, we should relax again.
   1435 		       Note that this is not required, and it may be slow.  */
   1436 		    *again = TRUE;
   1437 		  }
   1438 	      }
   1439 	  }
   1440 	  break;
   1441 
   1442 	default:
   1443 	  break;
   1444 	}
   1445     }
   1446 
   1447   if (isymbuf != NULL
   1448       && symtab_hdr->contents != (unsigned char *) isymbuf)
   1449     {
   1450       if (! link_info->keep_memory)
   1451 	free (isymbuf);
   1452       else
   1453 	symtab_hdr->contents = (unsigned char *) isymbuf;
   1454     }
   1455 
   1456   if (contents != NULL
   1457       && elf_section_data (sec)->this_hdr.contents != contents)
   1458     {
   1459       if (! link_info->keep_memory)
   1460 	free (contents);
   1461       else
   1462 	{
   1463 	  /* Cache the section contents for elf_link_input_bfd.  */
   1464 	  elf_section_data (sec)->this_hdr.contents = contents;
   1465 	}
   1466     }
   1467 
   1468   if (internal_relocs != NULL
   1469       && elf_section_data (sec)->relocs != internal_relocs)
   1470     free (internal_relocs);
   1471 
   1472   return TRUE;
   1473 
   1474  error_return:
   1475   if (isymbuf != NULL
   1476       && symtab_hdr->contents != (unsigned char *) isymbuf)
   1477     free (isymbuf);
   1478   if (contents != NULL
   1479       && elf_section_data (sec)->this_hdr.contents != contents)
   1480     free (contents);
   1481   if (internal_relocs != NULL
   1482       && elf_section_data (sec)->relocs != internal_relocs)
   1483     free (internal_relocs);
   1484   return FALSE;
   1485 }
   1486 
   1487 /* Delete some bytes from a section while relaxing.  */
   1488 
   1489 static bfd_boolean
   1490 elf32_h8_relax_delete_bytes (bfd *abfd, asection *sec, bfd_vma addr, int count)
   1491 {
   1492   Elf_Internal_Shdr *symtab_hdr;
   1493   unsigned int sec_shndx;
   1494   bfd_byte *contents;
   1495   Elf_Internal_Rela *irel, *irelend;
   1496   Elf_Internal_Sym *isym;
   1497   Elf_Internal_Sym *isymend;
   1498   bfd_vma toaddr;
   1499   struct elf_link_hash_entry **sym_hashes;
   1500   struct elf_link_hash_entry **end_hashes;
   1501   unsigned int symcount;
   1502 
   1503   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
   1504 
   1505   contents = elf_section_data (sec)->this_hdr.contents;
   1506 
   1507   toaddr = sec->size;
   1508 
   1509   irel = elf_section_data (sec)->relocs;
   1510   irelend = irel + sec->reloc_count;
   1511 
   1512   /* Actually delete the bytes.  */
   1513   memmove (contents + addr, contents + addr + count,
   1514 	   (size_t) (toaddr - addr - count));
   1515   sec->size -= count;
   1516 
   1517   /* Adjust all the relocs.  */
   1518   for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
   1519     {
   1520       /* Get the new reloc address.  */
   1521       if ((irel->r_offset > addr
   1522 	   && irel->r_offset <= toaddr))
   1523 	irel->r_offset -= count;
   1524     }
   1525 
   1526   /* Adjust the local symbols defined in this section.  */
   1527   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
   1528   isym = (Elf_Internal_Sym *) symtab_hdr->contents;
   1529   isymend = isym + symtab_hdr->sh_info;
   1530   for (; isym < isymend; isym++)
   1531     {
   1532       if (isym->st_shndx == sec_shndx
   1533 	  && isym->st_value > addr
   1534 	  && isym->st_value <= toaddr)
   1535 	isym->st_value -= count;
   1536     }
   1537 
   1538   /* Now adjust the global symbols defined in this section.  */
   1539   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
   1540 	      - symtab_hdr->sh_info);
   1541   sym_hashes = elf_sym_hashes (abfd);
   1542   end_hashes = sym_hashes + symcount;
   1543   for (; sym_hashes < end_hashes; sym_hashes++)
   1544     {
   1545       struct elf_link_hash_entry *sym_hash = *sym_hashes;
   1546 
   1547       if ((sym_hash->root.type == bfd_link_hash_defined
   1548 	   || sym_hash->root.type == bfd_link_hash_defweak)
   1549 	  && sym_hash->root.u.def.section == sec
   1550 	  && sym_hash->root.u.def.value > addr
   1551 	  && sym_hash->root.u.def.value <= toaddr)
   1552 	sym_hash->root.u.def.value -= count;
   1553     }
   1554 
   1555   return TRUE;
   1556 }
   1557 
   1558 /* Return TRUE if a symbol exists at the given address, else return
   1559    FALSE.  */
   1560 static bfd_boolean
   1561 elf32_h8_symbol_address_p (bfd *abfd, asection *sec, bfd_vma addr)
   1562 {
   1563   Elf_Internal_Shdr *symtab_hdr;
   1564   unsigned int sec_shndx;
   1565   Elf_Internal_Sym *isym;
   1566   Elf_Internal_Sym *isymend;
   1567   struct elf_link_hash_entry **sym_hashes;
   1568   struct elf_link_hash_entry **end_hashes;
   1569   unsigned int symcount;
   1570 
   1571   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
   1572 
   1573   /* Examine all the symbols.  */
   1574   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
   1575   isym = (Elf_Internal_Sym *) symtab_hdr->contents;
   1576   isymend = isym + symtab_hdr->sh_info;
   1577   for (; isym < isymend; isym++)
   1578     {
   1579       if (isym->st_shndx == sec_shndx
   1580 	  && isym->st_value == addr)
   1581 	return TRUE;
   1582     }
   1583 
   1584   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
   1585 	      - symtab_hdr->sh_info);
   1586   sym_hashes = elf_sym_hashes (abfd);
   1587   end_hashes = sym_hashes + symcount;
   1588   for (; sym_hashes < end_hashes; sym_hashes++)
   1589     {
   1590       struct elf_link_hash_entry *sym_hash = *sym_hashes;
   1591       if ((sym_hash->root.type == bfd_link_hash_defined
   1592 	   || sym_hash->root.type == bfd_link_hash_defweak)
   1593 	  && sym_hash->root.u.def.section == sec
   1594 	  && sym_hash->root.u.def.value == addr)
   1595 	return TRUE;
   1596     }
   1597 
   1598   return FALSE;
   1599 }
   1600 
   1601 /* This is a version of bfd_generic_get_relocated_section_contents
   1602    which uses elf32_h8_relocate_section.  */
   1603 
   1604 static bfd_byte *
   1605 elf32_h8_get_relocated_section_contents (bfd *output_bfd,
   1606 					 struct bfd_link_info *link_info,
   1607 					 struct bfd_link_order *link_order,
   1608 					 bfd_byte *data,
   1609 					 bfd_boolean relocatable,
   1610 					 asymbol **symbols)
   1611 {
   1612   Elf_Internal_Shdr *symtab_hdr;
   1613   asection *input_section = link_order->u.indirect.section;
   1614   bfd *input_bfd = input_section->owner;
   1615   asection **sections = NULL;
   1616   Elf_Internal_Rela *internal_relocs = NULL;
   1617   Elf_Internal_Sym *isymbuf = NULL;
   1618 
   1619   /* We only need to handle the case of relaxing, or of having a
   1620      particular set of section contents, specially.  */
   1621   if (relocatable
   1622       || elf_section_data (input_section)->this_hdr.contents == NULL)
   1623     return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
   1624 						       link_order, data,
   1625 						       relocatable,
   1626 						       symbols);
   1627 
   1628   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
   1629 
   1630   memcpy (data, elf_section_data (input_section)->this_hdr.contents,
   1631 	  (size_t) input_section->size);
   1632 
   1633   if ((input_section->flags & SEC_RELOC) != 0
   1634       && input_section->reloc_count > 0)
   1635     {
   1636       asection **secpp;
   1637       Elf_Internal_Sym *isym, *isymend;
   1638       bfd_size_type amt;
   1639 
   1640       internal_relocs = (_bfd_elf_link_read_relocs
   1641 			 (input_bfd, input_section, NULL,
   1642 			  (Elf_Internal_Rela *) NULL, FALSE));
   1643       if (internal_relocs == NULL)
   1644 	goto error_return;
   1645 
   1646       if (symtab_hdr->sh_info != 0)
   1647 	{
   1648 	  isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
   1649 	  if (isymbuf == NULL)
   1650 	    isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
   1651 					    symtab_hdr->sh_info, 0,
   1652 					    NULL, NULL, NULL);
   1653 	  if (isymbuf == NULL)
   1654 	    goto error_return;
   1655 	}
   1656 
   1657       amt = symtab_hdr->sh_info;
   1658       amt *= sizeof (asection *);
   1659       sections = (asection **) bfd_malloc (amt);
   1660       if (sections == NULL && amt != 0)
   1661 	goto error_return;
   1662 
   1663       isymend = isymbuf + symtab_hdr->sh_info;
   1664       for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
   1665 	{
   1666 	  asection *isec;
   1667 
   1668 	  if (isym->st_shndx == SHN_UNDEF)
   1669 	    isec = bfd_und_section_ptr;
   1670 	  else if (isym->st_shndx == SHN_ABS)
   1671 	    isec = bfd_abs_section_ptr;
   1672 	  else if (isym->st_shndx == SHN_COMMON)
   1673 	    isec = bfd_com_section_ptr;
   1674 	  else
   1675 	    isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
   1676 
   1677 	  *secpp = isec;
   1678 	}
   1679 
   1680       if (! elf32_h8_relocate_section (output_bfd, link_info, input_bfd,
   1681 				       input_section, data, internal_relocs,
   1682 				       isymbuf, sections))
   1683 	goto error_return;
   1684 
   1685       if (sections != NULL)
   1686 	free (sections);
   1687       if (isymbuf != NULL
   1688 	  && symtab_hdr->contents != (unsigned char *) isymbuf)
   1689 	free (isymbuf);
   1690       if (elf_section_data (input_section)->relocs != internal_relocs)
   1691 	free (internal_relocs);
   1692     }
   1693 
   1694   return data;
   1695 
   1696  error_return:
   1697   if (sections != NULL)
   1698     free (sections);
   1699   if (isymbuf != NULL
   1700       && symtab_hdr->contents != (unsigned char *) isymbuf)
   1701     free (isymbuf);
   1702   if (internal_relocs != NULL
   1703       && elf_section_data (input_section)->relocs != internal_relocs)
   1704     free (internal_relocs);
   1705   return NULL;
   1706 }
   1707 
   1708 
   1709 #define TARGET_BIG_SYM			h8300_elf32_vec
   1710 #define TARGET_BIG_NAME			"elf32-h8300"
   1711 #define ELF_ARCH			bfd_arch_h8300
   1712 #define ELF_MACHINE_CODE		EM_H8_300
   1713 #define ELF_MAXPAGESIZE			0x1
   1714 #define bfd_elf32_bfd_reloc_type_lookup elf32_h8_reloc_type_lookup
   1715 #define bfd_elf32_bfd_reloc_name_lookup elf32_h8_reloc_name_lookup
   1716 #define elf_info_to_howto		elf32_h8_info_to_howto
   1717 #define elf_info_to_howto_rel		elf32_h8_info_to_howto_rel
   1718 
   1719 /* So we can set/examine bits in e_flags to get the specific
   1720    H8 architecture in use.  */
   1721 #define elf_backend_final_write_processing \
   1722   elf32_h8_final_write_processing
   1723 #define elf_backend_object_p \
   1724   elf32_h8_object_p
   1725 #define bfd_elf32_bfd_merge_private_bfd_data \
   1726   elf32_h8_merge_private_bfd_data
   1727 
   1728 /* ??? when elf_backend_relocate_section is not defined, elf32-target.h
   1729    defaults to using _bfd_generic_link_hash_table_create, but
   1730    bfd_elf_size_dynamic_sections uses
   1731    dynobj = elf_hash_table (info)->dynobj;
   1732    and thus requires an elf hash table.  */
   1733 #define bfd_elf32_bfd_link_hash_table_create _bfd_elf_link_hash_table_create
   1734 
   1735 /* Use an H8 specific linker, not the ELF generic linker.  */
   1736 #define elf_backend_relocate_section elf32_h8_relocate_section
   1737 #define elf_backend_rela_normal		1
   1738 #define elf_backend_can_gc_sections	1
   1739 
   1740 /* And relaxing stuff.  */
   1741 #define bfd_elf32_bfd_relax_section     elf32_h8_relax_section
   1742 #define bfd_elf32_bfd_get_relocated_section_contents \
   1743                                 elf32_h8_get_relocated_section_contents
   1744 
   1745 #define elf_symbol_leading_char '_'
   1746 
   1747 #include "elf32-target.h"
   1748