bfd/elf32-h8300.c

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