bfd/elf32-h8300.c

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