bfd/elf32-h8300.c

   1 /* BFD back-end for Renesas H8/300 ELF binaries.
   2    Copyright 1993, 1995, 1998, 1999, 2001, 2002, 2003, 2004
   3    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 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 #include "bfd.h"
  22 #include "sysdep.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 asection *elf32_h8_gc_mark_hook
  46   (asection *, struct bfd_link_info *, Elf_Internal_Rela *,
  47    struct elf_link_hash_entry *, Elf_Internal_Sym *);
  48 static bfd_boolean elf32_h8_gc_sweep_hook
  49   (bfd *, struct bfd_link_info *, asection *, const Elf_Internal_Rela *);
  50 static bfd_reloc_status_type elf32_h8_final_link_relocate
  51   (unsigned long, bfd *, bfd *, asection *,
  52    bfd_byte *, bfd_vma, bfd_vma, bfd_vma,
  53    struct bfd_link_info *, asection *, int);
  54 static bfd_boolean elf32_h8_relocate_section
  55   (bfd *, struct bfd_link_info *, bfd *, asection *,
  56    bfd_byte *, Elf_Internal_Rela *,
  57    Elf_Internal_Sym *, asection **);
  58 static bfd_reloc_status_type special
  59   (bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **);
  60
  61 /* This does not include any relocation information, but should be
  62    good enough for GDB or objdump to read the file.  */
  63
  64 static reloc_howto_type h8_elf_howto_table[] = {
  65 #define R_H8_NONE_X 0
  66   HOWTO (R_H8_NONE,             /* type */
  67          0,                     /* rightshift */
  68          0,                     /* size (0 = byte, 1 = short, 2 = long) */
  69          0,                     /* bitsize */
  70          FALSE,                 /* pc_relative */
  71          0,                     /* bitpos */
  72          complain_overflow_dont,/* complain_on_overflow */
  73          special,               /* special_function */
  74          "R_H8_NONE",           /* name */
  75          FALSE,                 /* partial_inplace */
  76          0,                     /* src_mask */
  77          0,                     /* dst_mask */
  78          FALSE),                /* pcrel_offset */
  79 #define R_H8_DIR32_X (R_H8_NONE_X + 1)
  80   HOWTO (R_H8_DIR32,            /* type */
  81          0,                     /* rightshift */
  82          2,                     /* size (0 = byte, 1 = short, 2 = long) */
  83          32,                    /* bitsize */
  84          FALSE,                 /* pc_relative */
  85          0,                     /* bitpos */
  86          complain_overflow_dont,/* complain_on_overflow */
  87          special,               /* special_function */
  88          "R_H8_DIR32",          /* name */
  89          FALSE,                 /* partial_inplace */
  90          0,                     /* src_mask */
  91          0xffffffff,            /* dst_mask */
  92          FALSE),                /* pcrel_offset */
  93 #define R_H8_DIR16_X (R_H8_DIR32_X + 1)
  94   HOWTO (R_H8_DIR16,            /* type */
  95          0,                     /* rightshift */
  96          1,                     /* size (0 = byte, 1 = short, 2 = long) */
  97          16,                    /* bitsize */
  98          FALSE,                 /* pc_relative */
  99          0,                     /* bitpos */
 100          complain_overflow_dont,/* complain_on_overflow */
 101          special,               /* special_function */
 102          "R_H8_DIR16",          /* name */
 103          FALSE,                 /* partial_inplace */
 104          0,                     /* src_mask */
 105          0x0000ffff,            /* dst_mask */
 106          FALSE),                /* pcrel_offset */
 107 #define R_H8_DIR8_X (R_H8_DIR16_X + 1)
 108   HOWTO (R_H8_DIR8,             /* type */
 109          0,                     /* rightshift */
 110          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 111          8,                     /* bitsize */
 112          FALSE,                 /* pc_relative */
 113          0,                     /* bitpos */
 114          complain_overflow_dont,/* complain_on_overflow */
 115          special,               /* special_function */
 116          "R_H8_DIR8",           /* name */
 117          FALSE,                 /* partial_inplace */
 118          0,                     /* src_mask */
 119          0x000000ff,            /* dst_mask */
 120          FALSE),                /* pcrel_offset */
 121 #define R_H8_DIR16A8_X (R_H8_DIR8_X + 1)
 122   HOWTO (R_H8_DIR16A8,          /* type */
 123          0,                     /* rightshift */
 124          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 125          16,                    /* bitsize */
 126          FALSE,                 /* pc_relative */
 127          0,                     /* bitpos */
 128          complain_overflow_bitfield, /* complain_on_overflow */
 129          special,               /* special_function */
 130          "R_H8_DIR16A8",        /* name */
 131          FALSE,                 /* partial_inplace */
 132          0,                     /* src_mask */
 133          0x0000ffff,            /* dst_mask */
 134          FALSE),                /* pcrel_offset */
 135 #define R_H8_DIR16R8_X (R_H8_DIR16A8_X + 1)
 136   HOWTO (R_H8_DIR16R8,          /* type */
 137          0,                     /* rightshift */
 138          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 139          16,                    /* bitsize */
 140          FALSE,                 /* pc_relative */
 141          0,                     /* bitpos */
 142          complain_overflow_bitfield, /* complain_on_overflow */
 143          special,               /* special_function */
 144          "R_H8_DIR16R8",        /* name */
 145          FALSE,                 /* partial_inplace */
 146          0,                     /* src_mask */
 147          0x0000ffff,            /* dst_mask */
 148          FALSE),                /* pcrel_offset */
 149 #define R_H8_DIR24A8_X (R_H8_DIR16R8_X + 1)
 150   HOWTO (R_H8_DIR24A8,          /* type */
 151          0,                     /* rightshift */
 152          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 153          24,                    /* bitsize */
 154          FALSE,                 /* pc_relative */
 155          0,                     /* bitpos */
 156          complain_overflow_bitfield, /* complain_on_overflow */
 157          special,               /* special_function */
 158          "R_H8_DIR24A8",        /* name */
 159          TRUE,                  /* partial_inplace */
 160          0xff000000,            /* src_mask */
 161          0x00ffffff,            /* dst_mask */
 162          FALSE),                /* pcrel_offset */
 163 #define R_H8_DIR24R8_X (R_H8_DIR24A8_X + 1)
 164   HOWTO (R_H8_DIR24R8,          /* type */
 165          0,                     /* rightshift */
 166          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 167          24,                    /* bitsize */
 168          FALSE,                 /* pc_relative */
 169          0,                     /* bitpos */
 170          complain_overflow_bitfield, /* complain_on_overflow */
 171          special,               /* special_function */
 172          "R_H8_DIR24R8",        /* name */
 173          TRUE,                  /* partial_inplace */
 174          0xff000000,            /* src_mask */
 175          0x00ffffff,            /* dst_mask */
 176          FALSE),                /* pcrel_offset */
 177 #define R_H8_DIR32A16_X (R_H8_DIR24R8_X + 1)
 178   HOWTO (R_H8_DIR32A16,         /* type */
 179          0,                     /* rightshift */
 180          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 181          32,                    /* bitsize */
 182          FALSE,                 /* pc_relative */
 183          0,                     /* bitpos */
 184          complain_overflow_dont,/* complain_on_overflow */
 185          special,               /* special_function */
 186          "R_H8_DIR32A16",       /* name */
 187          FALSE,                 /* partial_inplace */
 188          0,                     /* src_mask */
 189          0xffffffff,            /* dst_mask */
 190          FALSE),                /* pcrel_offset */
 191 #define R_H8_PCREL16_X (R_H8_DIR32A16_X + 1)
 192   HOWTO (R_H8_PCREL16,          /* type */
 193          0,                     /* rightshift */
 194          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 195          16,                    /* bitsize */
 196          TRUE,                  /* pc_relative */
 197          0,                     /* bitpos */
 198          complain_overflow_signed,/* complain_on_overflow */
 199          special,               /* special_function */
 200          "R_H8_PCREL16",        /* name */
 201          FALSE,                 /* partial_inplace */
 202          0xffff,                /* src_mask */
 203          0xffff,                /* dst_mask */
 204          TRUE),                 /* pcrel_offset */
 205 #define R_H8_PCREL8_X (R_H8_PCREL16_X + 1)
 206   HOWTO (R_H8_PCREL8,           /* type */
 207          0,                     /* rightshift */
 208          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 209          8,                     /* bitsize */
 210          TRUE,                  /* pc_relative */
 211          0,                     /* bitpos */
 212          complain_overflow_signed,/* complain_on_overflow */
 213          special,               /* special_function */
 214          "R_H8_PCREL8",         /* name */
 215          FALSE,                 /* partial_inplace */
 216          0xff,                  /* src_mask */
 217          0xff,                  /* dst_mask */
 218          TRUE),                 /* pcrel_offset */
 219 };
 220
 221 /* This structure is used to map BFD reloc codes to H8 ELF relocs.  */
 222
 223 struct elf_reloc_map {
 224   bfd_reloc_code_real_type bfd_reloc_val;
 225   unsigned char howto_index;
 226 };
 227
 228 /* An array mapping BFD reloc codes to H8 ELF relocs.  */
 229
 230 static const struct elf_reloc_map h8_reloc_map[] = {
 231   { BFD_RELOC_NONE, R_H8_NONE_X },
 232   { BFD_RELOC_32, R_H8_DIR32_X },
 233   { BFD_RELOC_16, R_H8_DIR16_X },
 234   { BFD_RELOC_8, R_H8_DIR8_X },
 235   { BFD_RELOC_H8_DIR16A8, R_H8_DIR16A8_X },
 236   { BFD_RELOC_H8_DIR16R8, R_H8_DIR16R8_X },
 237   { BFD_RELOC_H8_DIR24A8, R_H8_DIR24A8_X },
 238   { BFD_RELOC_H8_DIR24R8, R_H8_DIR24R8_X },
 239   { BFD_RELOC_H8_DIR32A16, R_H8_DIR32A16_X },
 240   { BFD_RELOC_16_PCREL, R_H8_PCREL16_X },
 241   { BFD_RELOC_8_PCREL, R_H8_PCREL8_X },
 242 };
 243
 244
 245 static reloc_howto_type *
 246 elf32_h8_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 247                             bfd_reloc_code_real_type code)
 248 {
 249   unsigned int i;
 250
 251   for (i = 0; i < sizeof (h8_reloc_map) / sizeof (struct elf_reloc_map); i++)
 252     {
 253       if (h8_reloc_map[i].bfd_reloc_val == code)
 254         return &h8_elf_howto_table[(int) h8_reloc_map[i].howto_index];
 255     }
 256   return NULL;
 257 }
 258
 259 static void
 260 elf32_h8_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *bfd_reloc,
 261                         Elf_Internal_Rela *elf_reloc)
 262 {
 263   unsigned int r;
 264   unsigned int i;
 265
 266   r = ELF32_R_TYPE (elf_reloc->r_info);
 267   for (i = 0; i < sizeof (h8_elf_howto_table) / sizeof (reloc_howto_type); i++)
 268     if (h8_elf_howto_table[i].type == r)
 269       {
 270         bfd_reloc->howto = &h8_elf_howto_table[i];
 271         return;
 272       }
 273   abort ();
 274 }
 275
 276 static void
 277 elf32_h8_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED, arelent *bfd_reloc,
 278                             Elf_Internal_Rela *elf_reloc ATTRIBUTE_UNUSED)
 279 {
 280   unsigned int r;
 281
 282   abort ();
 283   r = ELF32_R_TYPE (elf_reloc->r_info);
 284   bfd_reloc->howto = &h8_elf_howto_table[r];
 285 }
 286
 287 /* Special handling for H8/300 relocs.
 288    We only come here for pcrel stuff and return normally if not an -r link.
 289    When doing -r, we can't do any arithmetic for the pcrel stuff, because
 290    we support relaxing on the H8/300 series chips.  */
 291 static bfd_reloc_status_type
 292 special (bfd *abfd ATTRIBUTE_UNUSED,
 293          arelent *reloc_entry ATTRIBUTE_UNUSED,
 294          asymbol *symbol ATTRIBUTE_UNUSED,
 295          PTR data ATTRIBUTE_UNUSED,
 296          asection *input_section ATTRIBUTE_UNUSED,
 297          bfd *output_bfd,
 298          char **error_message ATTRIBUTE_UNUSED)
 299 {
 300   if (output_bfd == (bfd *) NULL)
 301     return bfd_reloc_continue;
 302
 303   /* Adjust the reloc address to that in the output section.  */
 304   reloc_entry->address += input_section->output_offset;
 305   return bfd_reloc_ok;
 306 }
 307
 308 /* Perform a relocation as part of a final link.  */
 309 static bfd_reloc_status_type
 310 elf32_h8_final_link_relocate (unsigned long r_type, bfd *input_bfd,
 311                               bfd *output_bfd ATTRIBUTE_UNUSED,
 312                               asection *input_section ATTRIBUTE_UNUSED,
 313                               bfd_byte *contents, bfd_vma offset,
 314                               bfd_vma value, bfd_vma addend,
 315                               struct bfd_link_info *info ATTRIBUTE_UNUSED,
 316                               asection *sym_sec ATTRIBUTE_UNUSED,
 317                               int is_local ATTRIBUTE_UNUSED)
 318 {
 319   bfd_byte *hit_data = contents + offset;
 320
 321   switch (r_type)
 322     {
 323     case R_H8_NONE:
 324       return bfd_reloc_ok;
 325
 326     case R_H8_DIR32:
 327     case R_H8_DIR32A16:
 328     case R_H8_DIR24A8:
 329       value += addend;
 330       bfd_put_32 (input_bfd, value, hit_data);
 331       return bfd_reloc_ok;
 332
 333     case R_H8_DIR16:
 334     case R_H8_DIR16A8:
 335     case R_H8_DIR16R8:
 336       value += addend;
 337       bfd_put_16 (input_bfd, value, hit_data);
 338       return bfd_reloc_ok;
 339
 340     /* AKA R_RELBYTE */
 341     case R_H8_DIR8:
 342       value += addend;
 343
 344       bfd_put_8 (input_bfd, value, hit_data);
 345       return bfd_reloc_ok;
 346
 347     case R_H8_DIR24R8:
 348       value += addend;
 349
 350       /* HIT_DATA is the address for the first byte for the relocated
 351          value.  Subtract 1 so that we can manipulate the data in 32bit
 352          hunks.  */
 353       hit_data--;
 354
 355       /* Clear out the top byte in value.  */
 356       value &= 0xffffff;
 357
 358       /* Retrieve the type byte for value from the section contents.  */
 359       value |= (bfd_get_32 (input_bfd, hit_data) & 0xff000000);
 360
 361       /* Now scribble it out in one 32bit hunk.  */
 362       bfd_put_32 (input_bfd, value, hit_data);
 363       return bfd_reloc_ok;
 364
 365     case R_H8_PCREL16:
 366       value -= (input_section->output_section->vma
 367                 + input_section->output_offset);
 368       value -= offset;
 369       value += addend;
 370
 371       /* The value is relative to the start of the instruction,
 372          not the relocation offset.  Subtract 2 to account for
 373          this minor issue.  */
 374       value -= 2;
 375
 376       bfd_put_16 (input_bfd, value, hit_data);
 377       return bfd_reloc_ok;
 378
 379     case R_H8_PCREL8:
 380       value -= (input_section->output_section->vma
 381                 + input_section->output_offset);
 382       value -= offset;
 383       value += addend;
 384
 385       /* The value is relative to the start of the instruction,
 386          not the relocation offset.  Subtract 1 to account for
 387          this minor issue.  */
 388       value -= 1;
 389
 390       bfd_put_8 (input_bfd, value, hit_data);
 391       return bfd_reloc_ok;
 392
 393     default:
 394       return bfd_reloc_notsupported;
 395     }
 396 }
 397 \f
 398 /* Relocate an H8 ELF section.  */
 399 static bfd_boolean
 400 elf32_h8_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
 401                            bfd *input_bfd, asection *input_section,
 402                            bfd_byte *contents, Elf_Internal_Rela *relocs,
 403                            Elf_Internal_Sym *local_syms,
 404                            asection **local_sections)
 405 {
 406   Elf_Internal_Shdr *symtab_hdr;
 407   struct elf_link_hash_entry **sym_hashes;
 408   Elf_Internal_Rela *rel, *relend;
 409
 410   if (info->relocatable)
 411     return TRUE;
 412
 413   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
 414   sym_hashes = elf_sym_hashes (input_bfd);
 415
 416   rel = relocs;
 417   relend = relocs + input_section->reloc_count;
 418   for (; rel < relend; rel++)
 419     {
 420       unsigned int r_type;
 421       unsigned long r_symndx;
 422       Elf_Internal_Sym *sym;
 423       asection *sec;
 424       struct elf_link_hash_entry *h;
 425       bfd_vma relocation;
 426       bfd_reloc_status_type r;
 427
 428       /* This is a final link.  */
 429       r_symndx = ELF32_R_SYM (rel->r_info);
 430       r_type = ELF32_R_TYPE (rel->r_info);
 431       h = NULL;
 432       sym = NULL;
 433       sec = NULL;
 434       if (r_symndx < symtab_hdr->sh_info)
 435         {
 436           sym = local_syms + r_symndx;
 437           sec = local_sections[r_symndx];
 438           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
 439         }
 440       else
 441         {
 442           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 443           while (h->root.type == bfd_link_hash_indirect
 444                  || h->root.type == bfd_link_hash_warning)
 445             h = (struct elf_link_hash_entry *) h->root.u.i.link;
 446           if (h->root.type == bfd_link_hash_defined
 447               || h->root.type == bfd_link_hash_defweak)
 448             {
 449               sec = h->root.u.def.section;
 450               relocation = (h->root.u.def.value
 451                             + sec->output_section->vma
 452                             + sec->output_offset);
 453             }
 454           else if (h->root.type == bfd_link_hash_undefweak)
 455             relocation = 0;
 456           else
 457             {
 458               if (! ((*info->callbacks->undefined_symbol)
 459                      (info, h->root.root.string, input_bfd,
 460                       input_section, rel->r_offset, TRUE)))
 461                 return FALSE;
 462               relocation = 0;
 463             }
 464         }
 465
 466       r = elf32_h8_final_link_relocate (r_type, input_bfd, output_bfd,
 467                                         input_section,
 468                                         contents, rel->r_offset,
 469                                         relocation, rel->r_addend,
 470                                         info, sec, h == NULL);
 471
 472       if (r != bfd_reloc_ok)
 473         {
 474           const char *name;
 475           const char *msg = (const char *) 0;
 476           arelent bfd_reloc;
 477           reloc_howto_type *howto;
 478
 479           elf32_h8_info_to_howto (input_bfd, &bfd_reloc, rel);
 480           howto = bfd_reloc.howto;
 481
 482           if (h != NULL)
 483             name = h->root.root.string;
 484           else
 485             {
 486               name = (bfd_elf_string_from_elf_section
 487                       (input_bfd, symtab_hdr->sh_link, sym->st_name));
 488               if (name == NULL || *name == '\0')
 489                 name = bfd_section_name (input_bfd, sec);
 490             }
 491
 492           switch (r)
 493             {
 494             case bfd_reloc_overflow:
 495               if (! ((*info->callbacks->reloc_overflow)
 496                      (info, name, howto->name, (bfd_vma) 0,
 497                       input_bfd, input_section, 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      mov.[bwl]:24/32 ->    mov.[bwl]:16           2 bytes */
 670
 671 static bfd_boolean
 672 elf32_h8_relax_section (bfd *abfd, asection *sec,
 673                         struct bfd_link_info *link_info, bfd_boolean *again)
 674 {
 675   Elf_Internal_Shdr *symtab_hdr;
 676   Elf_Internal_Rela *internal_relocs;
 677   Elf_Internal_Rela *irel, *irelend;
 678   bfd_byte *contents = NULL;
 679   Elf_Internal_Sym *isymbuf = NULL;
 680   static asection *last_input_section = NULL;
 681   static Elf_Internal_Rela *last_reloc = NULL;
 682
 683   /* Assume nothing changes.  */
 684   *again = FALSE;
 685
 686   /* We don't have to do anything for a relocatable link, if
 687      this section does not have relocs, or if this is not a
 688      code section.  */
 689   if (link_info->relocatable
 690       || (sec->flags & SEC_RELOC) == 0
 691       || sec->reloc_count == 0
 692       || (sec->flags & SEC_CODE) == 0)
 693     return TRUE;
 694
 695   /* If this is the first time we have been called for this section,
 696      initialize the cooked size.  */
 697   if (sec->_cooked_size == 0)
 698     sec->_cooked_size = sec->_raw_size;
 699
 700   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 701
 702   /* Get a copy of the native relocations.  */
 703   internal_relocs = (_bfd_elf_link_read_relocs
 704                      (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
 705                       link_info->keep_memory));
 706   if (internal_relocs == NULL)
 707     goto error_return;
 708
 709   if (sec != last_input_section)
 710     last_reloc = NULL;
 711
 712   last_input_section = sec;
 713
 714   /* Walk through the relocs looking for relaxing opportunities.  */
 715   irelend = internal_relocs + sec->reloc_count;
 716   for (irel = internal_relocs; irel < irelend; irel++)
 717     {
 718       bfd_vma symval;
 719
 720       /* Keep track of the previous reloc so that we can delete
 721          some long jumps created by the compiler.  */
 722       if (irel != internal_relocs)
 723         last_reloc = irel - 1;
 724
 725       if (ELF32_R_TYPE (irel->r_info) != R_H8_DIR24R8
 726           && ELF32_R_TYPE (irel->r_info) != R_H8_PCREL16
 727           && ELF32_R_TYPE (irel->r_info) != R_H8_DIR16A8
 728           && ELF32_R_TYPE (irel->r_info) != R_H8_DIR24A8
 729           && ELF32_R_TYPE (irel->r_info) != R_H8_DIR32A16)
 730         continue;
 731
 732       /* Get the section contents if we haven't done so already.  */
 733       if (contents == NULL)
 734         {
 735           /* Get cached copy if it exists.  */
 736           if (elf_section_data (sec)->this_hdr.contents != NULL)
 737             contents = elf_section_data (sec)->this_hdr.contents;
 738           else
 739             {
 740               /* Go get them off disk.  */
 741               contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
 742               if (contents == NULL)
 743                 goto error_return;
 744
 745               if (! bfd_get_section_contents (abfd, sec, contents,
 746                                               (file_ptr) 0, sec->_raw_size))
 747                 goto error_return;
 748             }
 749         }
 750
 751       /* Read this BFD's local symbols if we haven't done so already.  */
 752       if (isymbuf == NULL && symtab_hdr->sh_info != 0)
 753         {
 754           isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
 755           if (isymbuf == NULL)
 756             isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
 757                                             symtab_hdr->sh_info, 0,
 758                                             NULL, NULL, NULL);
 759           if (isymbuf == NULL)
 760             goto error_return;
 761         }
 762
 763       /* Get the value of the symbol referred to by the reloc.  */
 764       if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
 765         {
 766           /* A local symbol.  */
 767           Elf_Internal_Sym *isym;
 768           asection *sym_sec;
 769
 770           isym = isymbuf + ELF32_R_SYM (irel->r_info);
 771           sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
 772           symval = isym->st_value;
 773           /* If the reloc is absolute, it will not have
 774              a symbol or section associated with it.  */
 775           if (sym_sec)
 776             symval += sym_sec->output_section->vma
 777               + sym_sec->output_offset;
 778         }
 779       else
 780         {
 781           unsigned long indx;
 782           struct elf_link_hash_entry *h;
 783
 784           /* An external symbol.  */
 785           indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
 786           h = elf_sym_hashes (abfd)[indx];
 787           BFD_ASSERT (h != NULL);
 788           if (h->root.type != bfd_link_hash_defined
 789               && h->root.type != bfd_link_hash_defweak)
 790             {
 791               /* This appears to be a reference to an undefined
 792                  symbol.  Just ignore it--it will be caught by the
 793                  regular reloc processing.  */
 794               continue;
 795             }
 796
 797           symval = (h->root.u.def.value
 798                     + h->root.u.def.section->output_section->vma
 799                     + h->root.u.def.section->output_offset);
 800         }
 801
 802       /* For simplicity of coding, we are going to modify the section
 803          contents, the section relocs, and the BFD symbol table.  We
 804          must tell the rest of the code not to free up this
 805          information.  It would be possible to instead create a table
 806          of changes which have to be made, as is done in coff-mips.c;
 807          that would be more work, but would require less memory when
 808          the linker is run.  */
 809       switch (ELF32_R_TYPE (irel->r_info))
 810         {
 811         /* Try to turn a 24 bit absolute branch/call into an 8 bit
 812            pc-relative branch/call.  */
 813         case R_H8_DIR24R8:
 814           {
 815             bfd_vma value = symval + irel->r_addend;
 816             bfd_vma dot, gap;
 817
 818             /* Get the address of this instruction.  */
 819             dot = (sec->output_section->vma
 820                    + sec->output_offset + irel->r_offset - 1);
 821
 822             /* Compute the distance from this insn to the branch target.  */
 823             gap = value - dot;
 824
 825             /* If the distance is within -126..+130 inclusive, then we can
 826                relax this jump.  +130 is valid since the target will move
 827                two bytes closer if we do relax this branch.  */
 828             if ((int) gap >= -126 && (int) gap <= 130)
 829               {
 830                 unsigned char code;
 831
 832                 /* Note that we've changed the relocs, section contents,
 833                    etc.  */
 834                 elf_section_data (sec)->relocs = internal_relocs;
 835                 elf_section_data (sec)->this_hdr.contents = contents;
 836                 symtab_hdr->contents = (unsigned char *) isymbuf;
 837
 838                 /* Get the instruction code being relaxed.  */
 839                 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
 840
 841                 /* If the previous instruction conditionally jumped around
 842                    this instruction, we may be able to reverse the condition
 843                    and redirect the previous instruction to the target of
 844                    this instruction.
 845
 846                    Such sequences are used by the compiler to deal with
 847                    long conditional branches.
 848
 849                    Only perform this optimisation for jumps (code 0x5a) not
 850                    subroutine calls, as otherwise it could transform:
 851
 852                                      mov.w   r0,r0
 853                                      beq     .L1
 854                                      jsr     @_bar
 855                               .L1:   rts
 856                               _bar:  rts
 857                    into:
 858                                      mov.w   r0,r0
 859                                      bne     _bar
 860                                      rts
 861                               _bar:  rts
 862
 863                    which changes the call (jsr) into a branch (bne).  */
 864                 if (code == 0x5a
 865                     && (int) gap <= 130
 866                     && (int) gap >= -128
 867                     && last_reloc
 868                     && ELF32_R_TYPE (last_reloc->r_info) == R_H8_PCREL8
 869                     && ELF32_R_SYM (last_reloc->r_info) < symtab_hdr->sh_info)
 870                   {
 871                     bfd_vma last_value;
 872                     asection *last_sym_sec;
 873                     Elf_Internal_Sym *last_sym;
 874
 875                     /* We will need to examine the symbol used by the
 876                        previous relocation.  */
 877
 878                     last_sym = isymbuf + ELF32_R_SYM (last_reloc->r_info);
 879                     last_sym_sec
 880                       = bfd_section_from_elf_index (abfd, last_sym->st_shndx);
 881                     last_value = (last_sym->st_value
 882                                   + last_sym_sec->output_section->vma
 883                                   + last_sym_sec->output_offset);
 884
 885                     /* Verify that the previous relocation was for a
 886                        branch around this instruction and that no symbol
 887                        exists at the current location.  */
 888                     if (last_value == dot + 4
 889                         && last_reloc->r_offset + 2 == irel->r_offset
 890                         && ! elf32_h8_symbol_address_p (abfd, sec, dot))
 891                       {
 892                         /* We can eliminate this jump.  Twiddle the
 893                            previous relocation as necessary.  */
 894                         irel->r_info
 895                           = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
 896                                           ELF32_R_TYPE (R_H8_NONE));
 897
 898                         last_reloc->r_info
 899                           = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
 900                                           ELF32_R_TYPE (R_H8_PCREL8));
 901                         last_reloc->r_addend = irel->r_addend;
 902
 903                         code = bfd_get_8 (abfd,
 904                                           contents + last_reloc->r_offset - 1);
 905                         code ^= 1;
 906                         bfd_put_8 (abfd,
 907                                    code,
 908                         contents + last_reloc->r_offset - 1);
 909
 910                         /* Delete four bytes of data.  */
 911                         if (!elf32_h8_relax_delete_bytes (abfd, sec,
 912                                                           irel->r_offset - 1,
 913                                                           4))
 914                           goto error_return;
 915
 916                         *again = TRUE;
 917                         break;
 918                       }
 919                   }
 920
 921                 if (code == 0x5e)
 922                   bfd_put_8 (abfd, 0x55, contents + irel->r_offset - 1);
 923                 else if (code == 0x5a)
 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 16bit pc-relative branch into a 8bit 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 condition code from the original insn.  */
 979                     code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
 980                     code &= 0xf0;
 981                     code >>= 4;
 982                     code |= 0x40;
 983                     bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
 984                   }
 985                 else if (code == 0x5c)
 986                   bfd_put_8 (abfd, 0x55, contents + irel->r_offset - 2);
 987                 else
 988                   abort ();
 989
 990                 /* Fix the relocation's type.  */
 991                 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
 992                                              R_H8_PCREL8);
 993                 irel->r_offset--;
 994
 995                 /* Delete two bytes of data.  */
 996                 if (!elf32_h8_relax_delete_bytes (abfd, sec,
 997                                                   irel->r_offset + 1, 2))
 998                   goto error_return;
 999
1000                 /* That will change things, so, we should relax again.
1001                    Note that this is not required, and it may be slow.  */
1002                 *again = TRUE;
1003               }
1004             break;
1005           }
1006
1007         /* This is a 16-bit absolute address in one of the following
1008            instructions:
1009
1010              "band", "bclr", "biand", "bild", "bior", "bist", "bixor",
1011              "bld", "bnot", "bor", "bset", "bst", "btst", "bxor", and
1012              "mov.b"
1013
1014            We may relax this into an 8-bit absolute address if it's in
1015            the right range.  */
1016         case R_H8_DIR16A8:
1017           {
1018             bfd_vma value;
1019
1020             value = bfd_h8300_pad_address (abfd, symval + irel->r_addend);
1021             if (value >= 0xffffff00u)
1022               {
1023                 unsigned char code;
1024                 unsigned char temp_code;
1025
1026                 /* Note that we've changed the relocs, section contents,
1027                    etc.  */
1028                 elf_section_data (sec)->relocs = internal_relocs;
1029                 elf_section_data (sec)->this_hdr.contents = contents;
1030                 symtab_hdr->contents = (unsigned char *) isymbuf;
1031
1032                 /* Get the opcode.  */
1033                 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
1034
1035                 /* All instructions with R_H8_DIR16A8 start with
1036                    0x6a.  */
1037                 if (code != 0x6a)
1038                   abort ();
1039
1040                 temp_code = code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1041                 /* If this is a mov.b instruction, clear the lower
1042                    nibble, which contains the source/destination
1043                    register number.  */
1044                 if ((temp_code & 0x10) != 0x10)
1045                   temp_code &= 0xf0;
1046
1047                 switch (temp_code)
1048                   {
1049                   case 0x00:
1050                     /* This is mov.b @aa:16,Rd.  */
1051                     bfd_put_8 (abfd, (code & 0xf) | 0x20,
1052                                contents + irel->r_offset - 2);
1053                     break;
1054                   case 0x80:
1055                     /* This is mov.b Rs,@aa:16.  */
1056                     bfd_put_8 (abfd, (code & 0xf) | 0x30,
1057                                contents + irel->r_offset - 2);
1058                     break;
1059                   case 0x18:
1060                     /* This is a bit-maniputation instruction that
1061                        stores one bit into memory, one of "bclr",
1062                        "bist", "bnot", "bset", and "bst".  */
1063                     bfd_put_8 (abfd, 0x7f, contents + irel->r_offset - 2);
1064                     break;
1065                   case 0x10:
1066                     /* This is a bit-maniputation instruction that
1067                        loads one bit from memory, one of "band",
1068                        "biand", "bild", "bior", "bixor", "bld", "bor",
1069                        "btst", and "bxor".  */
1070                     bfd_put_8 (abfd, 0x7e, contents + irel->r_offset - 2);
1071                     break;
1072                   default:
1073                     abort ();
1074                   }
1075
1076                 /* Fix the relocation's type.  */
1077                 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1078                                              R_H8_DIR8);
1079
1080                 /* Move the relocation.  */
1081                 irel->r_offset--;
1082
1083                 /* Delete two bytes of data.  */
1084                 if (!elf32_h8_relax_delete_bytes (abfd, sec,
1085                                                   irel->r_offset + 1, 2))
1086                   goto error_return;
1087
1088                 /* That will change things, so, we should relax again.
1089                    Note that this is not required, and it may be slow.  */
1090                 *again = TRUE;
1091               }
1092             break;
1093           }
1094
1095         /* This is a 24-bit absolute address in one of the following
1096            instructions:
1097
1098              "band", "bclr", "biand", "bild", "bior", "bist", "bixor",
1099              "bld", "bnot", "bor", "bset", "bst", "btst", "bxor", and
1100              "mov.b"
1101
1102            We may relax this into an 8-bit absolute address if it's in
1103            the right range.  */
1104         case R_H8_DIR24A8:
1105           {
1106             bfd_vma value;
1107
1108             value = bfd_h8300_pad_address (abfd, symval + irel->r_addend);
1109             if (value >= 0xffffff00u)
1110               {
1111                 unsigned char code;
1112                 unsigned char temp_code;
1113
1114                 /* Note that we've changed the relocs, section contents,
1115                    etc.  */
1116                 elf_section_data (sec)->relocs = internal_relocs;
1117                 elf_section_data (sec)->this_hdr.contents = contents;
1118                 symtab_hdr->contents = (unsigned char *) isymbuf;
1119
1120                 /* Get the opcode.  */
1121                 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
1122
1123                 /* All instructions with R_H8_DIR24A8 start with
1124                    0x6a.  */
1125                 if (code != 0x6a)
1126                   abort ();
1127
1128                 temp_code = code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1129
1130                 /* If this is a mov.b instruction, clear the lower
1131                    nibble, which contains the source/destination
1132                    register number.  */
1133                 if ((temp_code & 0x30) != 0x30)
1134                   temp_code &= 0xf0;
1135
1136                 switch (temp_code)
1137                   {
1138                   case 0x20:
1139                     /* This is mov.b @aa:24/32,Rd.  */
1140                     bfd_put_8 (abfd, (code & 0xf) | 0x20,
1141                                contents + irel->r_offset - 2);
1142                     break;
1143                   case 0xa0:
1144                     /* This is mov.b Rs,@aa:24/32.  */
1145                     bfd_put_8 (abfd, (code & 0xf) | 0x30,
1146                                contents + irel->r_offset - 2);
1147                     break;
1148                   case 0x38:
1149                     /* This is a bit-maniputation instruction that
1150                        stores one bit into memory, one of "bclr",
1151                        "bist", "bnot", "bset", and "bst".  */
1152                     bfd_put_8 (abfd, 0x7f, contents + irel->r_offset - 2);
1153                     break;
1154                   case 0x30:
1155                     /* This is a bit-maniputation instruction that
1156                        loads one bit from memory, one of "band",
1157                        "biand", "bild", "bior", "bixor", "bld", "bor",
1158                        "btst", and "bxor".  */
1159                     bfd_put_8 (abfd, 0x7e, contents + irel->r_offset - 2);
1160                     break;
1161                   default:
1162                     abort();
1163                   }
1164
1165                 /* Fix the relocation's type.  */
1166                 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1167                                              R_H8_DIR8);
1168                 irel->r_offset--;
1169
1170                 /* Delete two bytes of data.  */
1171                 if (!elf32_h8_relax_delete_bytes (abfd, sec,
1172                                                   irel->r_offset + 1, 4))
1173                   goto error_return;
1174
1175                 /* That will change things, so, we should relax again.
1176                    Note that this is not required, and it may be slow.  */
1177                 *again = TRUE;
1178                 break;
1179               }
1180           }
1181
1182         /* Fall through.  */
1183
1184         /* This is a 24/32bit absolute address in a "mov" insn, which may
1185            become a 16-bit absolute address if it is in the right range.  */
1186         case R_H8_DIR32A16:
1187           {
1188             bfd_vma value;
1189
1190             value = bfd_h8300_pad_address (abfd, symval + irel->r_addend);
1191             if (value <= 0x7fff || value >= 0xffff8000u)
1192               {
1193                 unsigned char code;
1194
1195                 /* Note that we've changed the relocs, section contents,
1196                    etc.  */
1197                 elf_section_data (sec)->relocs = internal_relocs;
1198                 elf_section_data (sec)->this_hdr.contents = contents;
1199                 symtab_hdr->contents = (unsigned char *) isymbuf;
1200
1201                 /* Get the opcode.  */
1202                 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1203
1204                 /* We just need to turn off bit 0x20.  */
1205                 code &= ~0x20;
1206
1207                 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
1208
1209                 /* Fix the relocation's type.  */
1210                 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1211                                              R_H8_DIR16);
1212
1213                 /* Delete two bytes of data.  */
1214                 if (!elf32_h8_relax_delete_bytes (abfd, sec,
1215                                                   irel->r_offset + 1, 2))
1216                   goto error_return;
1217
1218                 /* That will change things, so, we should relax again.
1219                    Note that this is not required, and it may be slow.  */
1220                 *again = TRUE;
1221               }
1222             break;
1223           }
1224
1225         default:
1226           break;
1227         }
1228     }
1229
1230   if (isymbuf != NULL
1231       && symtab_hdr->contents != (unsigned char *) isymbuf)
1232     {
1233       if (! link_info->keep_memory)
1234         free (isymbuf);
1235       else
1236         symtab_hdr->contents = (unsigned char *) isymbuf;
1237     }
1238
1239   if (contents != NULL
1240       && elf_section_data (sec)->this_hdr.contents != contents)
1241     {
1242       if (! link_info->keep_memory)
1243         free (contents);
1244       else
1245         {
1246           /* Cache the section contents for elf_link_input_bfd.  */
1247           elf_section_data (sec)->this_hdr.contents = contents;
1248         }
1249     }
1250
1251   if (internal_relocs != NULL
1252       && elf_section_data (sec)->relocs != internal_relocs)
1253     free (internal_relocs);
1254
1255   return TRUE;
1256
1257  error_return:
1258   if (isymbuf != NULL
1259       && symtab_hdr->contents != (unsigned char *) isymbuf)
1260     free (isymbuf);
1261   if (contents != NULL
1262       && elf_section_data (sec)->this_hdr.contents != contents)
1263     free (contents);
1264   if (internal_relocs != NULL
1265       && elf_section_data (sec)->relocs != internal_relocs)
1266     free (internal_relocs);
1267   return FALSE;
1268 }
1269
1270 /* Delete some bytes from a section while relaxing.  */
1271
1272 static bfd_boolean
1273 elf32_h8_relax_delete_bytes (bfd *abfd, asection *sec, bfd_vma addr, int count)
1274 {
1275   Elf_Internal_Shdr *symtab_hdr;
1276   unsigned int sec_shndx;
1277   bfd_byte *contents;
1278   Elf_Internal_Rela *irel, *irelend;
1279   Elf_Internal_Rela *irelalign;
1280   Elf_Internal_Sym *isym;
1281   Elf_Internal_Sym *isymend;
1282   bfd_vma toaddr;
1283   struct elf_link_hash_entry **sym_hashes;
1284   struct elf_link_hash_entry **end_hashes;
1285   unsigned int symcount;
1286
1287   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1288
1289   contents = elf_section_data (sec)->this_hdr.contents;
1290
1291   /* The deletion must stop at the next ALIGN reloc for an aligment
1292      power larger than the number of bytes we are deleting.  */
1293
1294   irelalign = NULL;
1295   toaddr = sec->_cooked_size;
1296
1297   irel = elf_section_data (sec)->relocs;
1298   irelend = irel + sec->reloc_count;
1299
1300   /* Actually delete the bytes.  */
1301   memmove (contents + addr, contents + addr + count,
1302            (size_t) (toaddr - addr - count));
1303   sec->_cooked_size -= count;
1304
1305   /* Adjust all the relocs.  */
1306   for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1307     {
1308       /* Get the new reloc address.  */
1309       if ((irel->r_offset > addr
1310            && irel->r_offset < toaddr))
1311         irel->r_offset -= count;
1312     }
1313
1314   /* Adjust the local symbols defined in this section.  */
1315   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1316   isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1317   isymend = isym + symtab_hdr->sh_info;
1318   for (; isym < isymend; isym++)
1319     {
1320       if (isym->st_shndx == sec_shndx
1321           && isym->st_value > addr
1322           && isym->st_value < toaddr)
1323         isym->st_value -= count;
1324     }
1325
1326   /* Now adjust the global symbols defined in this section.  */
1327   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1328               - symtab_hdr->sh_info);
1329   sym_hashes = elf_sym_hashes (abfd);
1330   end_hashes = sym_hashes + symcount;
1331   for (; sym_hashes < end_hashes; sym_hashes++)
1332     {
1333       struct elf_link_hash_entry *sym_hash = *sym_hashes;
1334       if ((sym_hash->root.type == bfd_link_hash_defined
1335            || sym_hash->root.type == bfd_link_hash_defweak)
1336           && sym_hash->root.u.def.section == sec
1337           && sym_hash->root.u.def.value > addr
1338           && sym_hash->root.u.def.value < toaddr)
1339         {
1340           sym_hash->root.u.def.value -= count;
1341         }
1342     }
1343
1344   return TRUE;
1345 }
1346
1347 /* Return TRUE if a symbol exists at the given address, else return
1348    FALSE.  */
1349 static bfd_boolean
1350 elf32_h8_symbol_address_p (bfd *abfd, asection *sec, bfd_vma addr)
1351 {
1352   Elf_Internal_Shdr *symtab_hdr;
1353   unsigned int sec_shndx;
1354   Elf_Internal_Sym *isym;
1355   Elf_Internal_Sym *isymend;
1356   struct elf_link_hash_entry **sym_hashes;
1357   struct elf_link_hash_entry **end_hashes;
1358   unsigned int symcount;
1359
1360   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1361
1362   /* Examine all the symbols.  */
1363   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1364   isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1365   isymend = isym + symtab_hdr->sh_info;
1366   for (; isym < isymend; isym++)
1367     {
1368       if (isym->st_shndx == sec_shndx
1369           && isym->st_value == addr)
1370         return TRUE;
1371     }
1372
1373   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1374               - symtab_hdr->sh_info);
1375   sym_hashes = elf_sym_hashes (abfd);
1376   end_hashes = sym_hashes + symcount;
1377   for (; sym_hashes < end_hashes; sym_hashes++)
1378     {
1379       struct elf_link_hash_entry *sym_hash = *sym_hashes;
1380       if ((sym_hash->root.type == bfd_link_hash_defined
1381            || sym_hash->root.type == bfd_link_hash_defweak)
1382           && sym_hash->root.u.def.section == sec
1383           && sym_hash->root.u.def.value == addr)
1384         return TRUE;
1385     }
1386
1387   return FALSE;
1388 }
1389
1390 /* This is a version of bfd_generic_get_relocated_section_contents
1391    which uses elf32_h8_relocate_section.  */
1392
1393 static bfd_byte *
1394 elf32_h8_get_relocated_section_contents (bfd *output_bfd,
1395                                          struct bfd_link_info *link_info,
1396                                          struct bfd_link_order *link_order,
1397                                          bfd_byte *data,
1398                                          bfd_boolean relocatable,
1399                                          asymbol **symbols)
1400 {
1401   Elf_Internal_Shdr *symtab_hdr;
1402   asection *input_section = link_order->u.indirect.section;
1403   bfd *input_bfd = input_section->owner;
1404   asection **sections = NULL;
1405   Elf_Internal_Rela *internal_relocs = NULL;
1406   Elf_Internal_Sym *isymbuf = NULL;
1407
1408   /* We only need to handle the case of relaxing, or of having a
1409      particular set of section contents, specially.  */
1410   if (relocatable
1411       || elf_section_data (input_section)->this_hdr.contents == NULL)
1412     return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
1413                                                        link_order, data,
1414                                                        relocatable,
1415                                                        symbols);
1416
1417   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1418
1419   memcpy (data, elf_section_data (input_section)->this_hdr.contents,
1420           (size_t) input_section->_raw_size);
1421
1422   if ((input_section->flags & SEC_RELOC) != 0
1423       && input_section->reloc_count > 0)
1424     {
1425       asection **secpp;
1426       Elf_Internal_Sym *isym, *isymend;
1427       bfd_size_type amt;
1428
1429       internal_relocs = (_bfd_elf_link_read_relocs
1430                          (input_bfd, input_section, (PTR) NULL,
1431                           (Elf_Internal_Rela *) NULL, FALSE));
1432       if (internal_relocs == NULL)
1433         goto error_return;
1434
1435       if (symtab_hdr->sh_info != 0)
1436         {
1437           isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1438           if (isymbuf == NULL)
1439             isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
1440                                             symtab_hdr->sh_info, 0,
1441                                             NULL, NULL, NULL);
1442           if (isymbuf == NULL)
1443             goto error_return;
1444         }
1445
1446       amt = symtab_hdr->sh_info;
1447       amt *= sizeof (asection *);
1448       sections = (asection **) bfd_malloc (amt);
1449       if (sections == NULL && amt != 0)
1450         goto error_return;
1451
1452       isymend = isymbuf + symtab_hdr->sh_info;
1453       for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
1454         {
1455           asection *isec;
1456
1457           if (isym->st_shndx == SHN_UNDEF)
1458             isec = bfd_und_section_ptr;
1459           else if (isym->st_shndx == SHN_ABS)
1460             isec = bfd_abs_section_ptr;
1461           else if (isym->st_shndx == SHN_COMMON)
1462             isec = bfd_com_section_ptr;
1463           else
1464             isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
1465
1466           *secpp = isec;
1467         }
1468
1469       if (! elf32_h8_relocate_section (output_bfd, link_info, input_bfd,
1470                                        input_section, data, internal_relocs,
1471                                        isymbuf, sections))
1472         goto error_return;
1473
1474       if (sections != NULL)
1475         free (sections);
1476       if (isymbuf != NULL
1477           && symtab_hdr->contents != (unsigned char *) isymbuf)
1478         free (isymbuf);
1479       if (elf_section_data (input_section)->relocs != internal_relocs)
1480         free (internal_relocs);
1481     }
1482
1483   return data;
1484
1485  error_return:
1486   if (sections != NULL)
1487     free (sections);
1488   if (isymbuf != NULL
1489       && symtab_hdr->contents != (unsigned char *) isymbuf)
1490     free (isymbuf);
1491   if (internal_relocs != NULL
1492       && elf_section_data (input_section)->relocs != internal_relocs)
1493     free (internal_relocs);
1494   return NULL;
1495 }
1496
1497 static asection *
1498 elf32_h8_gc_mark_hook (asection *sec,
1499                        struct bfd_link_info *info ATTRIBUTE_UNUSED,
1500                        Elf_Internal_Rela *rel ATTRIBUTE_UNUSED,
1501                        struct elf_link_hash_entry *h,
1502                        Elf_Internal_Sym *sym)
1503 {
1504   if (h != NULL)
1505     {
1506       switch (h->root.type)
1507         {
1508         case bfd_link_hash_defined:
1509         case bfd_link_hash_defweak:
1510           return h->root.u.def.section;
1511
1512         case bfd_link_hash_common:
1513           return h->root.u.c.p->section;
1514
1515         default:
1516           break;
1517         }
1518     }
1519   else
1520     return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
1521   return NULL;
1522 }
1523
1524 static bfd_boolean
1525 elf32_h8_gc_sweep_hook (bfd *abfd ATTRIBUTE_UNUSED,
1526                         struct bfd_link_info *info ATTRIBUTE_UNUSED,
1527                         asection *sec ATTRIBUTE_UNUSED,
1528                         const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED)
1529 {
1530   return TRUE;
1531 }
1532
1533
1534 #define TARGET_BIG_SYM                  bfd_elf32_h8300_vec
1535 #define TARGET_BIG_NAME                 "elf32-h8300"
1536 #define ELF_ARCH                        bfd_arch_h8300
1537 #define ELF_MACHINE_CODE                EM_H8_300
1538 #define ELF_MAXPAGESIZE                 0x1
1539 #define bfd_elf32_bfd_reloc_type_lookup elf32_h8_reloc_type_lookup
1540 #define elf_info_to_howto               elf32_h8_info_to_howto
1541 #define elf_info_to_howto_rel           elf32_h8_info_to_howto_rel
1542
1543 /* So we can set/examine bits in e_flags to get the specific
1544    H8 architecture in use.  */
1545 #define elf_backend_final_write_processing \
1546   elf32_h8_final_write_processing
1547 #define elf_backend_object_p \
1548   elf32_h8_object_p
1549 #define bfd_elf32_bfd_merge_private_bfd_data \
1550   elf32_h8_merge_private_bfd_data
1551 #define elf_backend_gc_mark_hook        elf32_h8_gc_mark_hook
1552 #define elf_backend_gc_sweep_hook       elf32_h8_gc_sweep_hook
1553
1554 /* ??? when elf_backend_relocate_section is not defined, elf32-target.h
1555    defaults to using _bfd_generic_link_hash_table_create, but
1556    elflink.h:bfd_elf32_size_dynamic_sections uses
1557    dynobj = elf_hash_table (info)->dynobj;
1558    and thus requires an elf hash table.  */
1559 #define bfd_elf32_bfd_link_hash_table_create _bfd_elf_link_hash_table_create
1560
1561 /* Use an H8 specific linker, not the ELF generic linker.  */
1562 #define elf_backend_relocate_section elf32_h8_relocate_section
1563 #define elf_backend_rela_normal         1
1564 #define elf_backend_can_gc_sections     1
1565
1566 /* And relaxing stuff.  */
1567 #define bfd_elf32_bfd_relax_section     elf32_h8_relax_section
1568 #define bfd_elf32_bfd_get_relocated_section_contents \
1569                                 elf32_h8_get_relocated_section_contents
1570
1571
1572 #include "elf32-target.h"