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 32-bit
 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 32-bit 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      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   /* If this is the first time we have been called for this section,
 699      initialize the cooked size.  */
 700   if (sec->_cooked_size == 0)
 701     sec->_cooked_size = sec->_raw_size;
 702
 703   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 704
 705   /* Get a copy of the native relocations.  */
 706   internal_relocs = (_bfd_elf_link_read_relocs
 707                      (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
 708                       link_info->keep_memory));
 709   if (internal_relocs == NULL)
 710     goto error_return;
 711
 712   if (sec != last_input_section)
 713     last_reloc = NULL;
 714
 715   last_input_section = sec;
 716
 717   /* Walk through the relocs looking for relaxing opportunities.  */
 718   irelend = internal_relocs + sec->reloc_count;
 719   for (irel = internal_relocs; irel < irelend; irel++)
 720     {
 721       bfd_vma symval;
 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               contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
 745               if (contents == NULL)
 746                 goto error_return;
 747
 748               if (! bfd_get_section_contents (abfd, sec, contents,
 749                                               (file_ptr) 0, sec->_raw_size))
 750                 goto error_return;
 751             }
 752         }
 753
 754       /* Read this BFD's local symbols if we haven't done so already.  */
 755       if (isymbuf == NULL && symtab_hdr->sh_info != 0)
 756         {
 757           isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
 758           if (isymbuf == NULL)
 759             isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
 760                                             symtab_hdr->sh_info, 0,
 761                                             NULL, NULL, NULL);
 762           if (isymbuf == NULL)
 763             goto error_return;
 764         }
 765
 766       /* Get the value of the symbol referred to by the reloc.  */
 767       if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
 768         {
 769           /* A local symbol.  */
 770           Elf_Internal_Sym *isym;
 771           asection *sym_sec;
 772
 773           isym = isymbuf + ELF32_R_SYM (irel->r_info);
 774           sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
 775           symval = isym->st_value;
 776           /* If the reloc is absolute, it will not have
 777              a symbol or section associated with it.  */
 778           if (sym_sec)
 779             symval += sym_sec->output_section->vma
 780               + sym_sec->output_offset;
 781         }
 782       else
 783         {
 784           unsigned long indx;
 785           struct elf_link_hash_entry *h;
 786
 787           /* An external symbol.  */
 788           indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
 789           h = elf_sym_hashes (abfd)[indx];
 790           BFD_ASSERT (h != NULL);
 791           if (h->root.type != bfd_link_hash_defined
 792               && h->root.type != bfd_link_hash_defweak)
 793             {
 794               /* This appears to be a reference to an undefined
 795                  symbol.  Just ignore it--it will be caught by the
 796                  regular reloc processing.  */
 797               continue;
 798             }
 799
 800           symval = (h->root.u.def.value
 801                     + h->root.u.def.section->output_section->vma
 802                     + h->root.u.def.section->output_offset);
 803         }
 804
 805       /* For simplicity of coding, we are going to modify the section
 806          contents, the section relocs, and the BFD symbol table.  We
 807          must tell the rest of the code not to free up this
 808          information.  It would be possible to instead create a table
 809          of changes which have to be made, as is done in coff-mips.c;
 810          that would be more work, but would require less memory when
 811          the linker is run.  */
 812       switch (ELF32_R_TYPE (irel->r_info))
 813         {
 814         /* Try to turn a 24-bit absolute branch/call into an 8-bit
 815            pc-relative branch/call.  */
 816         case R_H8_DIR24R8:
 817           {
 818             bfd_vma value = symval + irel->r_addend;
 819             bfd_vma dot, gap;
 820
 821             /* Get the address of this instruction.  */
 822             dot = (sec->output_section->vma
 823                    + sec->output_offset + irel->r_offset - 1);
 824
 825             /* Compute the distance from this insn to the branch target.  */
 826             gap = value - dot;
 827
 828             /* If the distance is within -126..+130 inclusive, then we can
 829                relax this jump.  +130 is valid since the target will move
 830                two bytes closer if we do relax this branch.  */
 831             if ((int) gap >= -126 && (int) gap <= 130)
 832               {
 833                 unsigned char code;
 834
 835                 /* Note that we've changed the relocs, section contents,
 836                    etc.  */
 837                 elf_section_data (sec)->relocs = internal_relocs;
 838                 elf_section_data (sec)->this_hdr.contents = contents;
 839                 symtab_hdr->contents = (unsigned char *) isymbuf;
 840
 841                 /* Get the instruction code being relaxed.  */
 842                 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
 843
 844                 /* If the previous instruction conditionally jumped around
 845                    this instruction, we may be able to reverse the condition
 846                    and redirect the previous instruction to the target of
 847                    this instruction.
 848
 849                    Such sequences are used by the compiler to deal with
 850                    long conditional branches.
 851
 852                    Only perform this optimisation for jumps (code 0x5a) not
 853                    subroutine calls, as otherwise it could transform:
 854
 855                                      mov.w   r0,r0
 856                                      beq     .L1
 857                                      jsr     @_bar
 858                               .L1:   rts
 859                               _bar:  rts
 860                    into:
 861                                      mov.w   r0,r0
 862                                      bne     _bar
 863                                      rts
 864                               _bar:  rts
 865
 866                    which changes the call (jsr) into a branch (bne).  */
 867                 if (code == 0x5a
 868                     && (int) gap <= 130
 869                     && (int) gap >= -128
 870                     && last_reloc
 871                     && ELF32_R_TYPE (last_reloc->r_info) == R_H8_PCREL8
 872                     && ELF32_R_SYM (last_reloc->r_info) < symtab_hdr->sh_info)
 873                   {
 874                     bfd_vma last_value;
 875                     asection *last_sym_sec;
 876                     Elf_Internal_Sym *last_sym;
 877
 878                     /* We will need to examine the symbol used by the
 879                        previous relocation.  */
 880
 881                     last_sym = isymbuf + ELF32_R_SYM (last_reloc->r_info);
 882                     last_sym_sec
 883                       = bfd_section_from_elf_index (abfd, last_sym->st_shndx);
 884                     last_value = (last_sym->st_value
 885                                   + last_sym_sec->output_section->vma
 886                                   + last_sym_sec->output_offset);
 887
 888                     /* Verify that the previous relocation was for a
 889                        branch around this instruction and that no symbol
 890                        exists at the current location.  */
 891                     if (last_value == dot + 4
 892                         && last_reloc->r_offset + 2 == irel->r_offset
 893                         && ! elf32_h8_symbol_address_p (abfd, sec, dot))
 894                       {
 895                         /* We can eliminate this jump.  Twiddle the
 896                            previous relocation as necessary.  */
 897                         irel->r_info
 898                           = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
 899                                           ELF32_R_TYPE (R_H8_NONE));
 900
 901                         last_reloc->r_info
 902                           = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
 903                                           ELF32_R_TYPE (R_H8_PCREL8));
 904                         last_reloc->r_addend = irel->r_addend;
 905
 906                         code = bfd_get_8 (abfd,
 907                                           contents + last_reloc->r_offset - 1);
 908                         code ^= 1;
 909                         bfd_put_8 (abfd,
 910                                    code,
 911                         contents + last_reloc->r_offset - 1);
 912
 913                         /* Delete four bytes of data.  */
 914                         if (!elf32_h8_relax_delete_bytes (abfd, sec,
 915                                                           irel->r_offset - 1,
 916                                                           4))
 917                           goto error_return;
 918
 919                         *again = TRUE;
 920                         break;
 921                       }
 922                   }
 923
 924                 if (code == 0x5e)
 925                   /* This is jsr.  */
 926                   bfd_put_8 (abfd, 0x55, contents + irel->r_offset - 1);
 927                 else if (code == 0x5a)
 928                   /* This is jmp.  */
 929                   bfd_put_8 (abfd, 0x40, contents + irel->r_offset - 1);
 930                 else
 931                   abort ();
 932
 933                 /* Fix the relocation's type.  */
 934                 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
 935                                              R_H8_PCREL8);
 936
 937                 /* Delete two bytes of data.  */
 938                 if (!elf32_h8_relax_delete_bytes (abfd, sec,
 939                                                   irel->r_offset + 1, 2))
 940                   goto error_return;
 941
 942                 /* That will change things, so, we should relax again.
 943                    Note that this is not required, and it may be slow.  */
 944                 *again = TRUE;
 945               }
 946             break;
 947           }
 948
 949         /* Try to turn a 16-bit pc-relative branch into a 8-bit pc-relative
 950            branch.  */
 951         case R_H8_PCREL16:
 952           {
 953             bfd_vma value = symval + irel->r_addend;
 954             bfd_vma dot;
 955             bfd_vma gap;
 956
 957             /* Get the address of this instruction.  */
 958             dot = (sec->output_section->vma
 959                    + sec->output_offset
 960                    + irel->r_offset - 2);
 961
 962             gap = value - dot;
 963
 964             /* If the distance is within -126..+130 inclusive, then we can
 965                relax this jump.  +130 is valid since the target will move
 966                two bytes closer if we do relax this branch.  */
 967             if ((int) gap >= -126 && (int) gap <= 130)
 968               {
 969                 unsigned char code;
 970
 971                 /* Note that we've changed the relocs, section contents,
 972                    etc.  */
 973                 elf_section_data (sec)->relocs = internal_relocs;
 974                 elf_section_data (sec)->this_hdr.contents = contents;
 975                 symtab_hdr->contents = (unsigned char *) isymbuf;
 976
 977                 /* Get the opcode.  */
 978                 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
 979
 980                 if (code == 0x58)
 981                   {
 982                     /* bCC:16 -> bCC:8 */
 983                     /* Get the second byte of the original insn, which
 984                        contains the condition code.  */
 985                     code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
 986
 987                     /* Compute the fisrt byte of the relaxed
 988                        instruction.  The original sequence 0x58 0xX0
 989                        is relaxed to 0x4X, where X represents the
 990                        condition code.  */
 991                     code &= 0xf0;
 992                     code >>= 4;
 993                     code |= 0x40;
 994                     bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
 995                   }
 996                 else if (code == 0x5c)
 997                   /* This is bsr.  */
 998                   bfd_put_8 (abfd, 0x55, contents + irel->r_offset - 2);
 999                 else
1000                   abort ();
1001
1002                 /* Fix the relocation's type.  */
1003                 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1004                                              R_H8_PCREL8);
1005                 irel->r_offset--;
1006
1007                 /* Delete two bytes of data.  */
1008                 if (!elf32_h8_relax_delete_bytes (abfd, sec,
1009                                                   irel->r_offset + 1, 2))
1010                   goto error_return;
1011
1012                 /* That will change things, so, we should relax again.
1013                    Note that this is not required, and it may be slow.  */
1014                 *again = TRUE;
1015               }
1016             break;
1017           }
1018
1019         /* This is a 16-bit absolute address in one of the following
1020            instructions:
1021
1022              "band", "bclr", "biand", "bild", "bior", "bist", "bixor",
1023              "bld", "bnot", "bor", "bset", "bst", "btst", "bxor", and
1024              "mov.b"
1025
1026            We may relax this into an 8-bit absolute address if it's in
1027            the right range.  */
1028         case R_H8_DIR16A8:
1029           {
1030             bfd_vma value;
1031
1032             value = bfd_h8300_pad_address (abfd, symval + irel->r_addend);
1033             if (value >= 0xffffff00u)
1034               {
1035                 unsigned char code;
1036                 unsigned char temp_code;
1037
1038                 /* Note that we've changed the relocs, section contents,
1039                    etc.  */
1040                 elf_section_data (sec)->relocs = internal_relocs;
1041                 elf_section_data (sec)->this_hdr.contents = contents;
1042                 symtab_hdr->contents = (unsigned char *) isymbuf;
1043
1044                 /* Get the opcode.  */
1045                 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
1046
1047                 /* All instructions with R_H8_DIR16A8 start with
1048                    0x6a.  */
1049                 if (code != 0x6a)
1050                   abort ();
1051
1052                 temp_code = code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1053                 /* If this is a mov.b instruction, clear the lower
1054                    nibble, which contains the source/destination
1055                    register number.  */
1056                 if ((temp_code & 0x10) != 0x10)
1057                   temp_code &= 0xf0;
1058
1059                 switch (temp_code)
1060                   {
1061                   case 0x00:
1062                     /* This is mov.b @aa:16,Rd.  */
1063                     bfd_put_8 (abfd, (code & 0xf) | 0x20,
1064                                contents + irel->r_offset - 2);
1065                     break;
1066                   case 0x80:
1067                     /* This is mov.b Rs,@aa:16.  */
1068                     bfd_put_8 (abfd, (code & 0xf) | 0x30,
1069                                contents + irel->r_offset - 2);
1070                     break;
1071                   case 0x18:
1072                     /* This is a bit-maniputation instruction that
1073                        stores one bit into memory, one of "bclr",
1074                        "bist", "bnot", "bset", and "bst".  */
1075                     bfd_put_8 (abfd, 0x7f, contents + irel->r_offset - 2);
1076                     break;
1077                   case 0x10:
1078                     /* This is a bit-maniputation instruction that
1079                        loads one bit from memory, one of "band",
1080                        "biand", "bild", "bior", "bixor", "bld", "bor",
1081                        "btst", and "bxor".  */
1082                     bfd_put_8 (abfd, 0x7e, contents + irel->r_offset - 2);
1083                     break;
1084                   default:
1085                     abort ();
1086                   }
1087
1088                 /* Fix the relocation's type.  */
1089                 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1090                                              R_H8_DIR8);
1091
1092                 /* Move the relocation.  */
1093                 irel->r_offset--;
1094
1095                 /* Delete two bytes of data.  */
1096                 if (!elf32_h8_relax_delete_bytes (abfd, sec,
1097                                                   irel->r_offset + 1, 2))
1098                   goto error_return;
1099
1100                 /* That will change things, so, we should relax again.
1101                    Note that this is not required, and it may be slow.  */
1102                 *again = TRUE;
1103               }
1104             break;
1105           }
1106
1107         /* This is a 24-bit absolute address in one of the following
1108            instructions:
1109
1110              "band", "bclr", "biand", "bild", "bior", "bist", "bixor",
1111              "bld", "bnot", "bor", "bset", "bst", "btst", "bxor", and
1112              "mov.b"
1113
1114            We may relax this into an 8-bit absolute address if it's in
1115            the right range.  */
1116         case R_H8_DIR24A8:
1117           {
1118             bfd_vma value;
1119
1120             value = bfd_h8300_pad_address (abfd, symval + irel->r_addend);
1121             if (value >= 0xffffff00u)
1122               {
1123                 unsigned char code;
1124                 unsigned char temp_code;
1125
1126                 /* Note that we've changed the relocs, section contents,
1127                    etc.  */
1128                 elf_section_data (sec)->relocs = internal_relocs;
1129                 elf_section_data (sec)->this_hdr.contents = contents;
1130                 symtab_hdr->contents = (unsigned char *) isymbuf;
1131
1132                 /* Get the opcode.  */
1133                 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
1134
1135                 /* All instructions with R_H8_DIR24A8 start with
1136                    0x6a.  */
1137                 if (code != 0x6a)
1138                   abort ();
1139
1140                 temp_code = code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1141
1142                 /* If this is a mov.b instruction, clear the lower
1143                    nibble, which contains the source/destination
1144                    register number.  */
1145                 if ((temp_code & 0x30) != 0x30)
1146                   temp_code &= 0xf0;
1147
1148                 switch (temp_code)
1149                   {
1150                   case 0x20:
1151                     /* This is mov.b @aa:24/32,Rd.  */
1152                     bfd_put_8 (abfd, (code & 0xf) | 0x20,
1153                                contents + irel->r_offset - 2);
1154                     break;
1155                   case 0xa0:
1156                     /* This is mov.b Rs,@aa:24/32.  */
1157                     bfd_put_8 (abfd, (code & 0xf) | 0x30,
1158                                contents + irel->r_offset - 2);
1159                     break;
1160                   case 0x38:
1161                     /* This is a bit-maniputation instruction that
1162                        stores one bit into memory, one of "bclr",
1163                        "bist", "bnot", "bset", and "bst".  */
1164                     bfd_put_8 (abfd, 0x7f, contents + irel->r_offset - 2);
1165                     break;
1166                   case 0x30:
1167                     /* This is a bit-maniputation instruction that
1168                        loads one bit from memory, one of "band",
1169                        "biand", "bild", "bior", "bixor", "bld", "bor",
1170                        "btst", and "bxor".  */
1171                     bfd_put_8 (abfd, 0x7e, contents + irel->r_offset - 2);
1172                     break;
1173                   default:
1174                     abort();
1175                   }
1176
1177                 /* Fix the relocation's type.  */
1178                 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1179                                              R_H8_DIR8);
1180                 irel->r_offset--;
1181
1182                 /* Delete two bytes of data.  */
1183                 if (!elf32_h8_relax_delete_bytes (abfd, sec,
1184                                                   irel->r_offset + 1, 4))
1185                   goto error_return;
1186
1187                 /* That will change things, so, we should relax again.
1188                    Note that this is not required, and it may be slow.  */
1189                 *again = TRUE;
1190                 break;
1191               }
1192           }
1193
1194           /* Fall through.  */
1195
1196           /* This is a 24-/32-bit absolute address in one of the
1197              following instructions:
1198
1199                "band", "bclr", "biand", "bild", "bior", "bist",
1200                "bixor", "bld", "bnot", "bor", "bset", "bst", "btst",
1201                "bxor", and "mov.[bwl]"
1202
1203              We may relax this into an 16-bit absolute address if it's
1204              in the right range.  */
1205         case R_H8_DIR32A16:
1206           {
1207             bfd_vma value;
1208
1209             value = bfd_h8300_pad_address (abfd, symval + irel->r_addend);
1210             if (value <= 0x7fff || value >= 0xffff8000u)
1211               {
1212                 unsigned char code;
1213
1214                 /* Note that we've changed the relocs, section contents,
1215                    etc.  */
1216                 elf_section_data (sec)->relocs = internal_relocs;
1217                 elf_section_data (sec)->this_hdr.contents = contents;
1218                 symtab_hdr->contents = (unsigned char *) isymbuf;
1219
1220                 /* Get the opcode.  */
1221                 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1222
1223                 /* Fix the opcode.  For all the instructions that
1224                    belong to this relaxation, we simply need to turn
1225                    off bit 0x20 in the previous byte.  */
1226                 code &= ~0x20;
1227
1228                 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
1229
1230                 /* Fix the relocation's type.  */
1231                 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1232                                              R_H8_DIR16);
1233
1234                 /* Delete two bytes of data.  */
1235                 if (!elf32_h8_relax_delete_bytes (abfd, sec,
1236                                                   irel->r_offset + 1, 2))
1237                   goto error_return;
1238
1239                 /* That will change things, so, we should relax again.
1240                    Note that this is not required, and it may be slow.  */
1241                 *again = TRUE;
1242               }
1243             break;
1244           }
1245
1246         default:
1247           break;
1248         }
1249     }
1250
1251   if (isymbuf != NULL
1252       && symtab_hdr->contents != (unsigned char *) isymbuf)
1253     {
1254       if (! link_info->keep_memory)
1255         free (isymbuf);
1256       else
1257         symtab_hdr->contents = (unsigned char *) isymbuf;
1258     }
1259
1260   if (contents != NULL
1261       && elf_section_data (sec)->this_hdr.contents != contents)
1262     {
1263       if (! link_info->keep_memory)
1264         free (contents);
1265       else
1266         {
1267           /* Cache the section contents for elf_link_input_bfd.  */
1268           elf_section_data (sec)->this_hdr.contents = contents;
1269         }
1270     }
1271
1272   if (internal_relocs != NULL
1273       && elf_section_data (sec)->relocs != internal_relocs)
1274     free (internal_relocs);
1275
1276   return TRUE;
1277
1278  error_return:
1279   if (isymbuf != NULL
1280       && symtab_hdr->contents != (unsigned char *) isymbuf)
1281     free (isymbuf);
1282   if (contents != NULL
1283       && elf_section_data (sec)->this_hdr.contents != contents)
1284     free (contents);
1285   if (internal_relocs != NULL
1286       && elf_section_data (sec)->relocs != internal_relocs)
1287     free (internal_relocs);
1288   return FALSE;
1289 }
1290
1291 /* Delete some bytes from a section while relaxing.  */
1292
1293 static bfd_boolean
1294 elf32_h8_relax_delete_bytes (bfd *abfd, asection *sec, bfd_vma addr, int count)
1295 {
1296   Elf_Internal_Shdr *symtab_hdr;
1297   unsigned int sec_shndx;
1298   bfd_byte *contents;
1299   Elf_Internal_Rela *irel, *irelend;
1300   Elf_Internal_Rela *irelalign;
1301   Elf_Internal_Sym *isym;
1302   Elf_Internal_Sym *isymend;
1303   bfd_vma toaddr;
1304   struct elf_link_hash_entry **sym_hashes;
1305   struct elf_link_hash_entry **end_hashes;
1306   unsigned int symcount;
1307
1308   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1309
1310   contents = elf_section_data (sec)->this_hdr.contents;
1311
1312   /* The deletion must stop at the next ALIGN reloc for an aligment
1313      power larger than the number of bytes we are deleting.  */
1314
1315   irelalign = NULL;
1316   toaddr = sec->_cooked_size;
1317
1318   irel = elf_section_data (sec)->relocs;
1319   irelend = irel + sec->reloc_count;
1320
1321   /* Actually delete the bytes.  */
1322   memmove (contents + addr, contents + addr + count,
1323            (size_t) (toaddr - addr - count));
1324   sec->_cooked_size -= count;
1325
1326   /* Adjust all the relocs.  */
1327   for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1328     {
1329       /* Get the new reloc address.  */
1330       if ((irel->r_offset > addr
1331            && irel->r_offset < toaddr))
1332         irel->r_offset -= count;
1333     }
1334
1335   /* Adjust the local symbols defined in this section.  */
1336   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1337   isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1338   isymend = isym + symtab_hdr->sh_info;
1339   for (; isym < isymend; isym++)
1340     {
1341       if (isym->st_shndx == sec_shndx
1342           && isym->st_value > addr
1343           && isym->st_value < toaddr)
1344         isym->st_value -= count;
1345     }
1346
1347   /* Now adjust the global symbols defined in this section.  */
1348   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1349               - symtab_hdr->sh_info);
1350   sym_hashes = elf_sym_hashes (abfd);
1351   end_hashes = sym_hashes + symcount;
1352   for (; sym_hashes < end_hashes; sym_hashes++)
1353     {
1354       struct elf_link_hash_entry *sym_hash = *sym_hashes;
1355       if ((sym_hash->root.type == bfd_link_hash_defined
1356            || sym_hash->root.type == bfd_link_hash_defweak)
1357           && sym_hash->root.u.def.section == sec
1358           && sym_hash->root.u.def.value > addr
1359           && sym_hash->root.u.def.value < toaddr)
1360         {
1361           sym_hash->root.u.def.value -= count;
1362         }
1363     }
1364
1365   return TRUE;
1366 }
1367
1368 /* Return TRUE if a symbol exists at the given address, else return
1369    FALSE.  */
1370 static bfd_boolean
1371 elf32_h8_symbol_address_p (bfd *abfd, asection *sec, bfd_vma addr)
1372 {
1373   Elf_Internal_Shdr *symtab_hdr;
1374   unsigned int sec_shndx;
1375   Elf_Internal_Sym *isym;
1376   Elf_Internal_Sym *isymend;
1377   struct elf_link_hash_entry **sym_hashes;
1378   struct elf_link_hash_entry **end_hashes;
1379   unsigned int symcount;
1380
1381   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1382
1383   /* Examine all the symbols.  */
1384   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1385   isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1386   isymend = isym + symtab_hdr->sh_info;
1387   for (; isym < isymend; isym++)
1388     {
1389       if (isym->st_shndx == sec_shndx
1390           && isym->st_value == addr)
1391         return TRUE;
1392     }
1393
1394   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1395               - symtab_hdr->sh_info);
1396   sym_hashes = elf_sym_hashes (abfd);
1397   end_hashes = sym_hashes + symcount;
1398   for (; sym_hashes < end_hashes; sym_hashes++)
1399     {
1400       struct elf_link_hash_entry *sym_hash = *sym_hashes;
1401       if ((sym_hash->root.type == bfd_link_hash_defined
1402            || sym_hash->root.type == bfd_link_hash_defweak)
1403           && sym_hash->root.u.def.section == sec
1404           && sym_hash->root.u.def.value == addr)
1405         return TRUE;
1406     }
1407
1408   return FALSE;
1409 }
1410
1411 /* This is a version of bfd_generic_get_relocated_section_contents
1412    which uses elf32_h8_relocate_section.  */
1413
1414 static bfd_byte *
1415 elf32_h8_get_relocated_section_contents (bfd *output_bfd,
1416                                          struct bfd_link_info *link_info,
1417                                          struct bfd_link_order *link_order,
1418                                          bfd_byte *data,
1419                                          bfd_boolean relocatable,
1420                                          asymbol **symbols)
1421 {
1422   Elf_Internal_Shdr *symtab_hdr;
1423   asection *input_section = link_order->u.indirect.section;
1424   bfd *input_bfd = input_section->owner;
1425   asection **sections = NULL;
1426   Elf_Internal_Rela *internal_relocs = NULL;
1427   Elf_Internal_Sym *isymbuf = NULL;
1428
1429   /* We only need to handle the case of relaxing, or of having a
1430      particular set of section contents, specially.  */
1431   if (relocatable
1432       || elf_section_data (input_section)->this_hdr.contents == NULL)
1433     return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
1434                                                        link_order, data,
1435                                                        relocatable,
1436                                                        symbols);
1437
1438   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1439
1440   memcpy (data, elf_section_data (input_section)->this_hdr.contents,
1441           (size_t) input_section->_raw_size);
1442
1443   if ((input_section->flags & SEC_RELOC) != 0
1444       && input_section->reloc_count > 0)
1445     {
1446       asection **secpp;
1447       Elf_Internal_Sym *isym, *isymend;
1448       bfd_size_type amt;
1449
1450       internal_relocs = (_bfd_elf_link_read_relocs
1451                          (input_bfd, input_section, (PTR) NULL,
1452                           (Elf_Internal_Rela *) NULL, FALSE));
1453       if (internal_relocs == NULL)
1454         goto error_return;
1455
1456       if (symtab_hdr->sh_info != 0)
1457         {
1458           isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1459           if (isymbuf == NULL)
1460             isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
1461                                             symtab_hdr->sh_info, 0,
1462                                             NULL, NULL, NULL);
1463           if (isymbuf == NULL)
1464             goto error_return;
1465         }
1466
1467       amt = symtab_hdr->sh_info;
1468       amt *= sizeof (asection *);
1469       sections = (asection **) bfd_malloc (amt);
1470       if (sections == NULL && amt != 0)
1471         goto error_return;
1472
1473       isymend = isymbuf + symtab_hdr->sh_info;
1474       for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
1475         {
1476           asection *isec;
1477
1478           if (isym->st_shndx == SHN_UNDEF)
1479             isec = bfd_und_section_ptr;
1480           else if (isym->st_shndx == SHN_ABS)
1481             isec = bfd_abs_section_ptr;
1482           else if (isym->st_shndx == SHN_COMMON)
1483             isec = bfd_com_section_ptr;
1484           else
1485             isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
1486
1487           *secpp = isec;
1488         }
1489
1490       if (! elf32_h8_relocate_section (output_bfd, link_info, input_bfd,
1491                                        input_section, data, internal_relocs,
1492                                        isymbuf, sections))
1493         goto error_return;
1494
1495       if (sections != NULL)
1496         free (sections);
1497       if (isymbuf != NULL
1498           && symtab_hdr->contents != (unsigned char *) isymbuf)
1499         free (isymbuf);
1500       if (elf_section_data (input_section)->relocs != internal_relocs)
1501         free (internal_relocs);
1502     }
1503
1504   return data;
1505
1506  error_return:
1507   if (sections != NULL)
1508     free (sections);
1509   if (isymbuf != NULL
1510       && symtab_hdr->contents != (unsigned char *) isymbuf)
1511     free (isymbuf);
1512   if (internal_relocs != NULL
1513       && elf_section_data (input_section)->relocs != internal_relocs)
1514     free (internal_relocs);
1515   return NULL;
1516 }
1517
1518 static asection *
1519 elf32_h8_gc_mark_hook (asection *sec,
1520                        struct bfd_link_info *info ATTRIBUTE_UNUSED,
1521                        Elf_Internal_Rela *rel ATTRIBUTE_UNUSED,
1522                        struct elf_link_hash_entry *h,
1523                        Elf_Internal_Sym *sym)
1524 {
1525   if (h != NULL)
1526     {
1527       switch (h->root.type)
1528         {
1529         case bfd_link_hash_defined:
1530         case bfd_link_hash_defweak:
1531           return h->root.u.def.section;
1532
1533         case bfd_link_hash_common:
1534           return h->root.u.c.p->section;
1535
1536         default:
1537           break;
1538         }
1539     }
1540   else
1541     return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
1542   return NULL;
1543 }
1544
1545 static bfd_boolean
1546 elf32_h8_gc_sweep_hook (bfd *abfd ATTRIBUTE_UNUSED,
1547                         struct bfd_link_info *info ATTRIBUTE_UNUSED,
1548                         asection *sec ATTRIBUTE_UNUSED,
1549                         const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED)
1550 {
1551   return TRUE;
1552 }
1553
1554
1555 #define TARGET_BIG_SYM                  bfd_elf32_h8300_vec
1556 #define TARGET_BIG_NAME                 "elf32-h8300"
1557 #define ELF_ARCH                        bfd_arch_h8300
1558 #define ELF_MACHINE_CODE                EM_H8_300
1559 #define ELF_MAXPAGESIZE                 0x1
1560 #define bfd_elf32_bfd_reloc_type_lookup elf32_h8_reloc_type_lookup
1561 #define elf_info_to_howto               elf32_h8_info_to_howto
1562 #define elf_info_to_howto_rel           elf32_h8_info_to_howto_rel
1563
1564 /* So we can set/examine bits in e_flags to get the specific
1565    H8 architecture in use.  */
1566 #define elf_backend_final_write_processing \
1567   elf32_h8_final_write_processing
1568 #define elf_backend_object_p \
1569   elf32_h8_object_p
1570 #define bfd_elf32_bfd_merge_private_bfd_data \
1571   elf32_h8_merge_private_bfd_data
1572 #define elf_backend_gc_mark_hook        elf32_h8_gc_mark_hook
1573 #define elf_backend_gc_sweep_hook       elf32_h8_gc_sweep_hook
1574
1575 /* ??? when elf_backend_relocate_section is not defined, elf32-target.h
1576    defaults to using _bfd_generic_link_hash_table_create, but
1577    elflink.h:bfd_elf32_size_dynamic_sections uses
1578    dynobj = elf_hash_table (info)->dynobj;
1579    and thus requires an elf hash table.  */
1580 #define bfd_elf32_bfd_link_hash_table_create _bfd_elf_link_hash_table_create
1581
1582 /* Use an H8 specific linker, not the ELF generic linker.  */
1583 #define elf_backend_relocate_section elf32_h8_relocate_section
1584 #define elf_backend_rela_normal         1
1585 #define elf_backend_can_gc_sections     1
1586
1587 /* And relaxing stuff.  */
1588 #define bfd_elf32_bfd_relax_section     elf32_h8_relax_section
1589 #define bfd_elf32_bfd_get_relocated_section_contents \
1590                                 elf32_h8_get_relocated_section_contents
1591
1592
1593 #include "elf32-target.h"