bfd/elf32-h8300.c

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