bfd/elf32-h8300.c

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