bfd/elf32-h8300.c

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