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 #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      Elf32_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      Elf32_Internal_Rel *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 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 }
 578
 579 /* The final processing done just before writing out a H8 ELF object
 580    file.  We use this opportunity to encode the BFD machine type
 581    into the flags field in the object file.  */
 582
 583 static void
 584 elf32_h8_final_write_processing (abfd, linker)
 585      bfd *abfd;
 586      boolean linker ATTRIBUTE_UNUSED;
 587 {
 588   unsigned long val;
 589
 590   switch (bfd_get_mach (abfd))
 591     {
 592     default:
 593     case bfd_mach_h8300:
 594       val = E_H8_MACH_H8300;
 595       break;
 596
 597     case bfd_mach_h8300h:
 598       val = E_H8_MACH_H8300H;
 599       break;
 600
 601     case bfd_mach_h8300s:
 602       val = E_H8_MACH_H8300S;
 603       break;
 604     }
 605
 606   elf_elfheader (abfd)->e_flags &= ~ (EF_H8_MACH);
 607   elf_elfheader (abfd)->e_flags |= val;
 608 }
 609
 610 /* Return nonzero if ABFD represents a valid H8 ELF object file; also
 611    record the encoded machine type found in the ELF flags.  */
 612
 613 static boolean
 614 elf32_h8_object_p (abfd)
 615      bfd *abfd;
 616 {
 617   bfd_default_set_arch_mach (abfd, bfd_arch_h8300,
 618                              elf32_h8_mach (elf_elfheader (abfd)->e_flags));
 619   return true;
 620 }
 621
 622 /* Merge backend specific data from an object file to the output
 623    object file when linking.  The only data we need to copy at this
 624    time is the architecture/machine information.  */
 625
 626 static boolean
 627 elf32_h8_merge_private_bfd_data (ibfd, obfd)
 628      bfd *ibfd;
 629      bfd *obfd;
 630 {
 631   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
 632       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
 633     return true;
 634
 635   if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
 636       && bfd_get_mach (obfd) < bfd_get_mach (ibfd))
 637     {
 638       if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
 639                                bfd_get_mach (ibfd)))
 640         return false;
 641     }
 642
 643   return true;
 644 }
 645
 646 /* This function handles relaxing for the H8..
 647
 648    There's a few relaxing opportunites available on the H8:
 649
 650      jmp/jsr:24    ->    bra/bsr:8              2 bytes
 651      The jmp may be completely eliminated if the previous insn is a
 652      conditional branch to the insn after the jump.  In that case
 653      we invert the branch and delete the jump and save 4 bytes.
 654
 655      bCC:16          ->    bCC:8                  2 bytes
 656      bsr:16          ->    bsr:8                  2 bytes
 657
 658      mov.b:16        ->    mov.b:8                2 bytes
 659      mov.b:24/32     ->    mov.b:8                4 bytes
 660
 661      mov.[bwl]:24/32 ->    mov.[bwl]:16           2 bytes */
 662
 663 static boolean
 664 elf32_h8_relax_section (abfd, sec, link_info, again)
 665      bfd *abfd;
 666      asection *sec;
 667      struct bfd_link_info *link_info;
 668      boolean *again;
 669 {
 670   Elf_Internal_Shdr *symtab_hdr;
 671   Elf_Internal_Rela *internal_relocs;
 672   Elf_Internal_Rela *irel, *irelend;
 673   bfd_byte *contents = NULL;
 674   Elf_Internal_Sym *isymbuf = NULL;
 675   static asection *last_input_section = NULL;
 676   static Elf_Internal_Rela *last_reloc = NULL;
 677
 678   /* Assume nothing changes.  */
 679   *again = false;
 680
 681   /* We don't have to do anything for a relocateable link, if
 682      this section does not have relocs, or if this is not a
 683      code section.  */
 684   if (link_info->relocateable
 685       || (sec->flags & SEC_RELOC) == 0
 686       || sec->reloc_count == 0
 687       || (sec->flags & SEC_CODE) == 0)
 688     return true;
 689
 690   /* If this is the first time we have been called for this section,
 691      initialize the cooked size.  */
 692   if (sec->_cooked_size == 0)
 693     sec->_cooked_size = sec->_raw_size;
 694
 695   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 696
 697   /* Get a copy of the native relocations.  */
 698   internal_relocs = (_bfd_elf32_link_read_relocs
 699                      (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
 700                       link_info->keep_memory));
 701   if (internal_relocs == NULL)
 702     goto error_return;
 703
 704   if (sec != last_input_section)
 705     last_reloc = NULL;
 706
 707   last_input_section = sec;
 708
 709   /* Walk through the relocs looking for relaxing opportunities.  */
 710   irelend = internal_relocs + sec->reloc_count;
 711   for (irel = internal_relocs; irel < irelend; irel++)
 712     {
 713       bfd_vma symval;
 714
 715       /* Keep track of the previous reloc so that we can delete
 716          some long jumps created by the compiler.  */
 717       if (irel != internal_relocs)
 718         last_reloc = irel - 1;
 719
 720       if (ELF32_R_TYPE (irel->r_info) != R_H8_DIR24R8
 721           && ELF32_R_TYPE (irel->r_info) != R_H8_PCREL16
 722           && ELF32_R_TYPE (irel->r_info) != R_H8_DIR16A8
 723           && ELF32_R_TYPE (irel->r_info) != R_H8_DIR24A8
 724           && ELF32_R_TYPE (irel->r_info) != R_H8_DIR32A16)
 725         continue;
 726
 727       /* Get the section contents if we haven't done so already.  */
 728       if (contents == NULL)
 729         {
 730           /* Get cached copy if it exists.  */
 731           if (elf_section_data (sec)->this_hdr.contents != NULL)
 732             contents = elf_section_data (sec)->this_hdr.contents;
 733           else
 734             {
 735               /* Go get them off disk.  */
 736               contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
 737               if (contents == NULL)
 738                 goto error_return;
 739
 740               if (! bfd_get_section_contents (abfd, sec, contents,
 741                                               (file_ptr) 0, sec->_raw_size))
 742                 goto error_return;
 743             }
 744         }
 745
 746       /* Read this BFD's local symbols if we haven't done so already.  */
 747       if (isymbuf == NULL && symtab_hdr->sh_info != 0)
 748         {
 749           isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
 750           if (isymbuf == NULL)
 751             isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
 752                                             symtab_hdr->sh_info, 0,
 753                                             NULL, NULL, NULL);
 754           if (isymbuf == NULL)
 755             goto error_return;
 756         }
 757
 758       /* Get the value of the symbol referred to by the reloc.  */
 759       if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
 760         {
 761           /* A local symbol.  */
 762           Elf_Internal_Sym *isym;
 763           asection *sym_sec;
 764
 765           isym = isymbuf + ELF32_R_SYM (irel->r_info);
 766           sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
 767           symval = (isym->st_value
 768                     + sym_sec->output_section->vma
 769                     + sym_sec->output_offset);
 770         }
 771       else
 772         {
 773           unsigned long indx;
 774           struct elf_link_hash_entry *h;
 775
 776           /* An external symbol.  */
 777           indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
 778           h = elf_sym_hashes (abfd)[indx];
 779           BFD_ASSERT (h != NULL);
 780           if (h->root.type != bfd_link_hash_defined
 781               && h->root.type != bfd_link_hash_defweak)
 782             {
 783               /* This appears to be a reference to an undefined
 784                  symbol.  Just ignore it--it will be caught by the
 785                  regular reloc processing.  */
 786               continue;
 787             }
 788
 789           symval = (h->root.u.def.value
 790                     + h->root.u.def.section->output_section->vma
 791                     + h->root.u.def.section->output_offset);
 792         }
 793
 794       /* For simplicity of coding, we are going to modify the section
 795          contents, the section relocs, and the BFD symbol table.  We
 796          must tell the rest of the code not to free up this
 797          information.  It would be possible to instead create a table
 798          of changes which have to be made, as is done in coff-mips.c;
 799          that would be more work, but would require less memory when
 800          the linker is run.  */
 801       switch (ELF32_R_TYPE (irel->r_info))
 802         {
 803         /* Try to turn a 24 bit absolute branch/call into an 8 bit
 804            pc-relative branch/call.  */
 805         case R_H8_DIR24R8:
 806           {
 807             bfd_vma value = symval + irel->r_addend;
 808             bfd_vma dot, gap;
 809
 810             /* Get the address of this instruction.  */
 811             dot = (sec->output_section->vma
 812                    + sec->output_offset + irel->r_offset - 1);
 813
 814             /* Compute the distance from this insn to the branch target.  */
 815             gap = value - dot;
 816
 817             /* If the distance is within -126..+130 inclusive, then we can
 818                relax this jump.  +130 is valid since the target will move
 819                two bytes closer if we do relax this branch.  */
 820             if ((int) gap >= -126 && (int) gap <= 130)
 821               {
 822                 unsigned char code;
 823
 824                 /* Note that we've changed the relocs, section contents,
 825                    etc.  */
 826                 elf_section_data (sec)->relocs = internal_relocs;
 827                 elf_section_data (sec)->this_hdr.contents = contents;
 828                 symtab_hdr->contents = (unsigned char *) isymbuf;
 829
 830                 /* Get the instruction code being relaxed.  */
 831                 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
 832
 833                 /* If the previous instruction conditionally jumped around
 834                    this instruction, we may be able to reverse the condition
 835                    and redirect the previous instruction to the target of
 836                    this instruction.
 837
 838                    Such sequences are used by the compiler to deal with
 839                    long conditional branches.
 840
 841                    Only perform this optimisation for jumps (code 0x5a) not
 842                    subroutine calls, as otherwise it could transform:
 843
 844                                      mov.w   r0,r0
 845                                      beq     .L1
 846                                      jsr     @_bar
 847                               .L1:   rts
 848                               _bar:  rts
 849                    into:
 850                                      mov.w   r0,r0
 851                                      bne     _bar
 852                                      rts
 853                               _bar:  rts
 854
 855                    which changes the call (jsr) into a branch (bne).  */
 856                 if (code == 0x5a
 857                     && (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                         code = bfd_get_8 (abfd,
 896                                           contents + last_reloc->r_offset - 1);
 897                         code ^= 1;
 898                         bfd_put_8 (abfd,
 899                                    code,
 900                         contents + last_reloc->r_offset - 1);
 901
 902                         /* Delete four bytes of data.  */
 903                         if (!elf32_h8_relax_delete_bytes (abfd, sec,
 904                                                           irel->r_offset - 1,
 905                                                           4))
 906                           goto error_return;
 907
 908                         *again = true;
 909                         break;
 910                       }
 911                   }
 912
 913                 if (code == 0x5e)
 914                   bfd_put_8 (abfd, 0x55, contents + irel->r_offset - 1);
 915                 else if (code == 0x5a)
 916                   bfd_put_8 (abfd, 0x40, contents + irel->r_offset - 1);
 917                 else
 918                   abort ();
 919
 920                 /* Fix the relocation's type.  */
 921                 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
 922                                              R_H8_PCREL8);
 923
 924                 /* Delete two bytes of data.  */
 925                 if (!elf32_h8_relax_delete_bytes (abfd, sec,
 926                                                   irel->r_offset + 1, 2))
 927                   goto error_return;
 928
 929                 /* That will change things, so, we should relax again.
 930                    Note that this is not required, and it may be slow.  */
 931                 *again = true;
 932               }
 933             break;
 934           }
 935
 936         /* Try to turn a 16bit pc-relative branch into a 8bit pc-relative
 937            branch.  */
 938         case R_H8_PCREL16:
 939           {
 940             bfd_vma value = symval + irel->r_addend;
 941             bfd_vma dot;
 942             bfd_vma gap;
 943
 944             /* Get the address of this instruction.  */
 945             dot = (sec->output_section->vma
 946                    + sec->output_offset
 947                    + irel->r_offset - 2);
 948
 949             gap = value - dot;
 950
 951             /* If the distance is within -126..+130 inclusive, then we can
 952                relax this jump.  +130 is valid since the target will move
 953                two bytes closer if we do relax this branch.  */
 954             if ((int) gap >= -126 && (int) gap <= 130)
 955               {
 956                 unsigned char code;
 957
 958                 /* Note that we've changed the relocs, section contents,
 959                    etc.  */
 960                 elf_section_data (sec)->relocs = internal_relocs;
 961                 elf_section_data (sec)->this_hdr.contents = contents;
 962                 symtab_hdr->contents = (unsigned char *) isymbuf;
 963
 964                 /* Get the opcode.  */
 965                 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
 966
 967                 if (code == 0x58)
 968                   {
 969                     /* bCC:16 -> bCC:8 */
 970                     /* Get the condition code from the original insn.  */
 971                     code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
 972                     code &= 0xf0;
 973                     code >>= 4;
 974                     code |= 0x40;
 975                     bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
 976                   }
 977                 else if (code == 0x5c)
 978                   bfd_put_8 (abfd, 0x55, contents + irel->r_offset - 2);
 979                 else
 980                   abort ();
 981
 982                 /* Fix the relocation's type.  */
 983                 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
 984                                              R_H8_PCREL8);
 985                 irel->r_offset--;
 986
 987                 /* Delete two bytes of data.  */
 988                 if (!elf32_h8_relax_delete_bytes (abfd, sec,
 989                                                   irel->r_offset + 1, 2))
 990                   goto error_return;
 991
 992                 /* That will change things, so, we should relax again.
 993                    Note that this is not required, and it may be slow.  */
 994                 *again = true;
 995               }
 996             break;
 997           }
 998
 999         /* This is a 16 bit absolute address in a "mov.b" insn, which may
1000            become an 8 bit absolute address if its in the right range.  */
1001         case R_H8_DIR16A8:
1002           {
1003             bfd_vma value = symval + irel->r_addend;
1004
1005             if ((bfd_get_mach (abfd) == bfd_mach_h8300
1006                  && value >= 0xff00
1007                  && value <= 0xffff)
1008                 || ((bfd_get_mach (abfd) == bfd_mach_h8300h
1009                      || bfd_get_mach (abfd) == bfd_mach_h8300s)
1010                     && value >= 0xffff00
1011                     && value <= 0xffffff))
1012               {
1013                 unsigned char code;
1014
1015                 /* Note that we've changed the relocs, section contents,
1016                    etc.  */
1017                 elf_section_data (sec)->relocs = internal_relocs;
1018                 elf_section_data (sec)->this_hdr.contents = contents;
1019                 symtab_hdr->contents = (unsigned char *) isymbuf;
1020
1021                 /* Get the opcode.  */
1022                 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
1023
1024                 /* Sanity check.  */
1025                 if (code != 0x6a)
1026                   abort ();
1027
1028                 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1029
1030                 if ((code & 0xf0) == 0x00)
1031                   bfd_put_8 (abfd,
1032                              (code & 0xf) | 0x20,
1033                              contents + irel->r_offset - 2);
1034                 else if ((code & 0xf0) == 0x80)
1035                   bfd_put_8 (abfd,
1036                              (code & 0xf) | 0x30,
1037                              contents + irel->r_offset - 2);
1038                 else
1039                   abort ();
1040
1041                 /* Fix the relocation's type.  */
1042                 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1043                                              R_H8_DIR8);
1044
1045                 /* Delete two bytes of data.  */
1046                 if (!elf32_h8_relax_delete_bytes (abfd, sec,
1047                                                   irel->r_offset + 1, 2))
1048                   goto error_return;
1049
1050                 /* That will change things, so, we should relax again.
1051                    Note that this is not required, and it may be slow.  */
1052                 *again = true;
1053               }
1054             break;
1055           }
1056
1057         /* This is a 24 bit absolute address in a "mov.b" insn, which may
1058            become an 8 bit absolute address if its in the right range.  */
1059         case R_H8_DIR24A8:
1060           {
1061             bfd_vma value = symval + irel->r_addend;
1062
1063             if ((bfd_get_mach (abfd) == bfd_mach_h8300
1064                  && value >= 0xff00
1065                  && value <= 0xffff)
1066                 || ((bfd_get_mach (abfd) == bfd_mach_h8300h
1067                      || bfd_get_mach (abfd) == bfd_mach_h8300s)
1068                     && value >= 0xffff00
1069                     && value <= 0xffffff))
1070               {
1071                 unsigned char code;
1072
1073                 /* Note that we've changed the relocs, section contents,
1074                    etc.  */
1075                 elf_section_data (sec)->relocs = internal_relocs;
1076                 elf_section_data (sec)->this_hdr.contents = contents;
1077                 symtab_hdr->contents = (unsigned char *) isymbuf;
1078
1079                 /* Get the opcode.  */
1080                 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
1081
1082                 /* Sanity check.  */
1083                 if (code != 0x6a)
1084                   abort ();
1085
1086                 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1087
1088                 if ((code & 0xf0) == 0x00)
1089                   bfd_put_8 (abfd,
1090                              (code & 0xf) | 0x20,
1091                              contents + irel->r_offset - 2);
1092                 else if ((code & 0xf0) == 0x80)
1093                   bfd_put_8 (abfd,
1094                              (code & 0xf) | 0x30,
1095                              contents + irel->r_offset - 2);
1096                 else
1097                   abort ();
1098
1099                 /* Fix the relocation's type.  */
1100                 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1101                                              R_H8_DIR8);
1102
1103                 /* Delete two bytes of data.  */
1104                 if (!elf32_h8_relax_delete_bytes (abfd, sec, irel->r_offset, 2))
1105                   goto error_return;
1106
1107                 /* That will change things, so, we should relax again.
1108                    Note that this is not required, and it may be slow.  */
1109                 *again = true;
1110               }
1111           }
1112
1113         /* FALLTHRU */
1114
1115         /* This is a 24/32bit absolute address in a "mov" insn, which may
1116            become a 16bit absoulte address if it is in the right range.  */
1117         case R_H8_DIR32A16:
1118           {
1119             bfd_vma value = symval + irel->r_addend;
1120
1121             if (value <= 0x7fff || value >= 0xff8000)
1122               {
1123                 unsigned char code;
1124
1125                 /* Note that we've changed the relocs, section contents,
1126                    etc.  */
1127                 elf_section_data (sec)->relocs = internal_relocs;
1128                 elf_section_data (sec)->this_hdr.contents = contents;
1129                 symtab_hdr->contents = (unsigned char *) isymbuf;
1130
1131                 /* Get the opcode.  */
1132                 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1133
1134                 /* We just need to turn off bit 0x20.  */
1135                 code &= ~0x20;
1136
1137                 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
1138
1139                 /* Fix the relocation's type.  */
1140                 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1141                                              R_H8_DIR16A8);
1142
1143                 /* Delete two bytes of data.  */
1144                 if (!elf32_h8_relax_delete_bytes (abfd, sec,
1145                                                   irel->r_offset + 1, 2))
1146                   goto error_return;
1147
1148                 /* That will change things, so, we should relax again.
1149                    Note that this is not required, and it may be slow.  */
1150                 *again = true;
1151               }
1152             break;
1153           }
1154
1155         default:
1156           break;
1157         }
1158     }
1159
1160   if (isymbuf != NULL
1161       && symtab_hdr->contents != (unsigned char *) isymbuf)
1162     {
1163       if (! link_info->keep_memory)
1164         free (isymbuf);
1165       else
1166         symtab_hdr->contents = (unsigned char *) isymbuf;
1167     }
1168
1169   if (contents != NULL
1170       && elf_section_data (sec)->this_hdr.contents != contents)
1171     {
1172       if (! link_info->keep_memory)
1173         free (contents);
1174       else
1175         {
1176           /* Cache the section contents for elf_link_input_bfd.  */
1177           elf_section_data (sec)->this_hdr.contents = contents;
1178         }
1179     }
1180
1181   if (internal_relocs != NULL
1182       && elf_section_data (sec)->relocs != internal_relocs)
1183     free (internal_relocs);
1184
1185   return true;
1186
1187  error_return:
1188   if (isymbuf != NULL
1189       && symtab_hdr->contents != (unsigned char *) isymbuf)
1190     free (isymbuf);
1191   if (contents != NULL
1192       && elf_section_data (sec)->this_hdr.contents != contents)
1193     free (contents);
1194   if (internal_relocs != NULL
1195       && elf_section_data (sec)->relocs != internal_relocs)
1196     free (internal_relocs);
1197   return false;
1198 }
1199
1200 /* Delete some bytes from a section while relaxing.  */
1201
1202 static boolean
1203 elf32_h8_relax_delete_bytes (abfd, sec, addr, count)
1204      bfd *abfd;
1205      asection *sec;
1206      bfd_vma addr;
1207      int count;
1208 {
1209   Elf_Internal_Shdr *symtab_hdr;
1210   unsigned int sec_shndx;
1211   bfd_byte *contents;
1212   Elf_Internal_Rela *irel, *irelend;
1213   Elf_Internal_Rela *irelalign;
1214   Elf_Internal_Sym *isym;
1215   Elf_Internal_Sym *isymend;
1216   bfd_vma toaddr;
1217   struct elf_link_hash_entry **sym_hashes;
1218   struct elf_link_hash_entry **end_hashes;
1219   unsigned int symcount;
1220
1221   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1222
1223   contents = elf_section_data (sec)->this_hdr.contents;
1224
1225   /* The deletion must stop at the next ALIGN reloc for an aligment
1226      power larger than the number of bytes we are deleting.  */
1227
1228   irelalign = NULL;
1229   toaddr = sec->_cooked_size;
1230
1231   irel = elf_section_data (sec)->relocs;
1232   irelend = irel + sec->reloc_count;
1233
1234   /* Actually delete the bytes.  */
1235   memmove (contents + addr, contents + addr + count,
1236            (size_t) (toaddr - addr - count));
1237   sec->_cooked_size -= count;
1238
1239   /* Adjust all the relocs.  */
1240   for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1241     {
1242       /* Get the new reloc address.  */
1243       if ((irel->r_offset > addr
1244            && irel->r_offset < toaddr))
1245         irel->r_offset -= count;
1246     }
1247
1248   /* Adjust the local symbols defined in this section.  */
1249   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1250   isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1251   isymend = isym + symtab_hdr->sh_info;
1252   for (; isym < isymend; isym++)
1253     {
1254       if (isym->st_shndx == sec_shndx
1255           && isym->st_value > addr
1256           && isym->st_value < toaddr)
1257         isym->st_value -= count;
1258     }
1259
1260   /* Now adjust the global symbols defined in this section.  */
1261   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1262               - symtab_hdr->sh_info);
1263   sym_hashes = elf_sym_hashes (abfd);
1264   end_hashes = sym_hashes + symcount;
1265   for (; sym_hashes < end_hashes; sym_hashes++)
1266     {
1267       struct elf_link_hash_entry *sym_hash = *sym_hashes;
1268       if ((sym_hash->root.type == bfd_link_hash_defined
1269            || sym_hash->root.type == bfd_link_hash_defweak)
1270           && sym_hash->root.u.def.section == sec
1271           && sym_hash->root.u.def.value > addr
1272           && sym_hash->root.u.def.value < toaddr)
1273         {
1274           sym_hash->root.u.def.value -= count;
1275         }
1276     }
1277
1278   return true;
1279 }
1280
1281 /* Return true if a symbol exists at the given address, else return
1282    false.  */
1283 static boolean
1284 elf32_h8_symbol_address_p (abfd, sec, addr)
1285      bfd *abfd;
1286      asection *sec;
1287      bfd_vma addr;
1288 {
1289   Elf_Internal_Shdr *symtab_hdr;
1290   unsigned int sec_shndx;
1291   Elf_Internal_Sym *isym;
1292   Elf_Internal_Sym *isymend;
1293   struct elf_link_hash_entry **sym_hashes;
1294   struct elf_link_hash_entry **end_hashes;
1295   unsigned int symcount;
1296
1297   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1298
1299   /* Examine all the symbols.  */
1300   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1301   isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1302   isymend = isym + symtab_hdr->sh_info;
1303   for (; isym < isymend; isym++)
1304     {
1305       if (isym->st_shndx == sec_shndx
1306           && isym->st_value == addr)
1307         return true;
1308     }
1309
1310   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1311               - symtab_hdr->sh_info);
1312   sym_hashes = elf_sym_hashes (abfd);
1313   end_hashes = sym_hashes + symcount;
1314   for (; sym_hashes < end_hashes; sym_hashes++)
1315     {
1316       struct elf_link_hash_entry *sym_hash = *sym_hashes;
1317       if ((sym_hash->root.type == bfd_link_hash_defined
1318            || sym_hash->root.type == bfd_link_hash_defweak)
1319           && sym_hash->root.u.def.section == sec
1320           && sym_hash->root.u.def.value == addr)
1321         return true;
1322     }
1323
1324   return false;
1325 }
1326
1327 /* This is a version of bfd_generic_get_relocated_section_contents
1328    which uses elf32_h8_relocate_section.  */
1329
1330 static bfd_byte *
1331 elf32_h8_get_relocated_section_contents (output_bfd, link_info, link_order,
1332                                          data, relocateable, symbols)
1333      bfd *output_bfd;
1334      struct bfd_link_info *link_info;
1335      struct bfd_link_order *link_order;
1336      bfd_byte *data;
1337      boolean relocateable;
1338      asymbol **symbols;
1339 {
1340   Elf_Internal_Shdr *symtab_hdr;
1341   asection *input_section = link_order->u.indirect.section;
1342   bfd *input_bfd = input_section->owner;
1343   asection **sections = NULL;
1344   Elf_Internal_Rela *internal_relocs = NULL;
1345   Elf_Internal_Sym *isymbuf = NULL;
1346
1347   /* We only need to handle the case of relaxing, or of having a
1348      particular set of section contents, specially.  */
1349   if (relocateable
1350       || elf_section_data (input_section)->this_hdr.contents == NULL)
1351     return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
1352                                                        link_order, data,
1353                                                        relocateable,
1354                                                        symbols);
1355
1356   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1357
1358   memcpy (data, elf_section_data (input_section)->this_hdr.contents,
1359           (size_t) input_section->_raw_size);
1360
1361   if ((input_section->flags & SEC_RELOC) != 0
1362       && input_section->reloc_count > 0)
1363     {
1364       asection **secpp;
1365       Elf_Internal_Sym *isym, *isymend;
1366       bfd_size_type amt;
1367
1368       internal_relocs = (_bfd_elf32_link_read_relocs
1369                          (input_bfd, input_section, (PTR) NULL,
1370                           (Elf_Internal_Rela *) NULL, false));
1371       if (internal_relocs == NULL)
1372         goto error_return;
1373
1374       if (symtab_hdr->sh_info != 0)
1375         {
1376           isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1377           if (isymbuf == NULL)
1378             isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
1379                                             symtab_hdr->sh_info, 0,
1380                                             NULL, NULL, NULL);
1381           if (isymbuf == NULL)
1382             goto error_return;
1383         }
1384
1385       amt = symtab_hdr->sh_info;
1386       amt *= sizeof (asection *);
1387       sections = (asection **) bfd_malloc (amt);
1388       if (sections == NULL && amt != 0)
1389         goto error_return;
1390
1391       isymend = isymbuf + symtab_hdr->sh_info;
1392       for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
1393         {
1394           asection *isec;
1395
1396           if (isym->st_shndx == SHN_UNDEF)
1397             isec = bfd_und_section_ptr;
1398           else if (isym->st_shndx == SHN_ABS)
1399             isec = bfd_abs_section_ptr;
1400           else if (isym->st_shndx == SHN_COMMON)
1401             isec = bfd_com_section_ptr;
1402           else
1403             isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
1404
1405           *secpp = isec;
1406         }
1407
1408       if (! elf32_h8_relocate_section (output_bfd, link_info, input_bfd,
1409                                        input_section, data, internal_relocs,
1410                                        isymbuf, sections))
1411         goto error_return;
1412
1413       if (sections != NULL)
1414         free (sections);
1415       if (isymbuf != NULL
1416           && symtab_hdr->contents != (unsigned char *) isymbuf)
1417         free (isymbuf);
1418       if (elf_section_data (input_section)->relocs != internal_relocs)
1419         free (internal_relocs);
1420     }
1421
1422   return data;
1423
1424  error_return:
1425   if (sections != NULL)
1426     free (sections);
1427   if (isymbuf != NULL
1428       && symtab_hdr->contents != (unsigned char *) isymbuf)
1429     free (isymbuf);
1430   if (internal_relocs != NULL
1431       && elf_section_data (input_section)->relocs != internal_relocs)
1432     free (internal_relocs);
1433   return NULL;
1434 }
1435
1436
1437 #define TARGET_BIG_SYM                  bfd_elf32_h8300_vec
1438 #define TARGET_BIG_NAME                 "elf32-h8300"
1439 #define ELF_ARCH                        bfd_arch_h8300
1440 #define ELF_MACHINE_CODE                EM_H8_300
1441 #define ELF_MAXPAGESIZE                 0x1
1442 #define bfd_elf32_bfd_reloc_type_lookup elf32_h8_reloc_type_lookup
1443 #define elf_info_to_howto               elf32_h8_info_to_howto
1444 #define elf_info_to_howto_rel           elf32_h8_info_to_howto_rel
1445
1446 /* So we can set/examine bits in e_flags to get the specific
1447    H8 architecture in use.  */
1448 #define elf_backend_final_write_processing \
1449   elf32_h8_final_write_processing
1450 #define elf_backend_object_p \
1451   elf32_h8_object_p
1452 #define bfd_elf32_bfd_merge_private_bfd_data \
1453   elf32_h8_merge_private_bfd_data
1454
1455 /* ??? when elf_backend_relocate_section is not defined, elf32-target.h
1456    defaults to using _bfd_generic_link_hash_table_create, but
1457    elflink.h:bfd_elf32_size_dynamic_sections uses
1458    dynobj = elf_hash_table (info)->dynobj;
1459    and thus requires an elf hash table.  */
1460 #define bfd_elf32_bfd_link_hash_table_create _bfd_elf_link_hash_table_create
1461
1462 /* Use an H8 specific linker, not the ELF generic linker.  */
1463 #define elf_backend_relocate_section elf32_h8_relocate_section
1464 #define elf_backend_rela_normal         1
1465
1466 /* And relaxing stuff.  */
1467 #define bfd_elf32_bfd_relax_section     elf32_h8_relax_section
1468 #define bfd_elf32_bfd_get_relocated_section_contents \
1469                                 elf32_h8_get_relocated_section_contents
1470
1471
1472 #include "elf32-target.h"