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