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, 2009 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       {
 726         arelent bfd_reloc;
 727         reloc_howto_type *h;
 728
 729         elf32_h8_info_to_howto (abfd, &bfd_reloc, irel);
 730         h = bfd_reloc.howto;
 731       }
 732       /* Keep track of the previous reloc so that we can delete
 733          some long jumps created by the compiler.  */
 734       if (irel != internal_relocs)
 735         last_reloc = irel - 1;
 736
 737       if (ELF32_R_TYPE (irel->r_info) != R_H8_DIR24R8
 738           && ELF32_R_TYPE (irel->r_info) != R_H8_PCREL16
 739           && ELF32_R_TYPE (irel->r_info) != R_H8_DIR16A8
 740           && ELF32_R_TYPE (irel->r_info) != R_H8_DIR24A8
 741           && ELF32_R_TYPE (irel->r_info) != R_H8_DIR32A16)
 742         continue;
 743
 744       /* Get the section contents if we haven't done so already.  */
 745       if (contents == NULL)
 746         {
 747           /* Get cached copy if it exists.  */
 748           if (elf_section_data (sec)->this_hdr.contents != NULL)
 749             contents = elf_section_data (sec)->this_hdr.contents;
 750           else
 751             {
 752               /* Go get them off disk.  */
 753               if (!bfd_malloc_and_get_section (abfd, sec, &contents))
 754                 goto error_return;
 755             }
 756         }
 757
 758       /* Read this BFD's local symbols if we haven't done so already.  */
 759       if (isymbuf == NULL && symtab_hdr->sh_info != 0)
 760         {
 761           isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
 762           if (isymbuf == NULL)
 763             isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
 764                                             symtab_hdr->sh_info, 0,
 765                                             NULL, NULL, NULL);
 766           if (isymbuf == NULL)
 767             goto error_return;
 768         }
 769
 770       /* Get the value of the symbol referred to by the reloc.  */
 771       if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
 772         {
 773           /* A local symbol.  */
 774           Elf_Internal_Sym *isym;
 775           asection *sym_sec;
 776
 777           isym = isymbuf + ELF32_R_SYM (irel->r_info);
 778           sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
 779           symval = isym->st_value;
 780           /* If the reloc is absolute, it will not have
 781              a symbol or section associated with it.  */
 782           if (sym_sec)
 783             symval += sym_sec->output_section->vma
 784               + sym_sec->output_offset;
 785         }
 786       else
 787         {
 788           unsigned long indx;
 789           struct elf_link_hash_entry *h;
 790
 791           /* An external symbol.  */
 792           indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
 793           h = elf_sym_hashes (abfd)[indx];
 794           BFD_ASSERT (h != NULL);
 795           if (h->root.type != bfd_link_hash_defined
 796               && h->root.type != bfd_link_hash_defweak)
 797             {
 798               /* This appears to be a reference to an undefined
 799                  symbol.  Just ignore it--it will be caught by the
 800                  regular reloc processing.  */
 801               continue;
 802             }
 803
 804           symval = (h->root.u.def.value
 805                     + h->root.u.def.section->output_section->vma
 806                     + h->root.u.def.section->output_offset);
 807         }
 808
 809       /* For simplicity of coding, we are going to modify the section
 810          contents, the section relocs, and the BFD symbol table.  We
 811          must tell the rest of the code not to free up this
 812          information.  It would be possible to instead create a table
 813          of changes which have to be made, as is done in coff-mips.c;
 814          that would be more work, but would require less memory when
 815          the linker is run.  */
 816       switch (ELF32_R_TYPE (irel->r_info))
 817         {
 818         /* Try to turn a 24-bit absolute branch/call into an 8-bit
 819            pc-relative branch/call.  */
 820         case R_H8_DIR24R8:
 821           {
 822             bfd_vma value = symval + irel->r_addend;
 823             bfd_vma dot, gap;
 824
 825             /* Get the address of this instruction.  */
 826             dot = (sec->output_section->vma
 827                    + sec->output_offset + irel->r_offset - 1);
 828
 829             /* Compute the distance from this insn to the branch target.  */
 830             gap = value - dot;
 831
 832             /* If the distance is within -126..+130 inclusive, then we can
 833                relax this jump.  +130 is valid since the target will move
 834                two bytes closer if we do relax this branch.  */
 835             if ((int) gap >= -126 && (int) gap <= 130)
 836               {
 837                 unsigned char code;
 838
 839                 /* Note that we've changed the relocs, section contents,
 840                    etc.  */
 841                 elf_section_data (sec)->relocs = internal_relocs;
 842                 elf_section_data (sec)->this_hdr.contents = contents;
 843                 symtab_hdr->contents = (unsigned char *) isymbuf;
 844
 845                 /* Get the instruction code being relaxed.  */
 846                 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
 847
 848                 /* If the previous instruction conditionally jumped around
 849                    this instruction, we may be able to reverse the condition
 850                    and redirect the previous instruction to the target of
 851                    this instruction.
 852
 853                    Such sequences are used by the compiler to deal with
 854                    long conditional branches.
 855
 856                    Only perform this optimisation for jumps (code 0x5a) not
 857                    subroutine calls, as otherwise it could transform:
 858
 859                                      mov.w   r0,r0
 860                                      beq     .L1
 861                                      jsr     @_bar
 862                               .L1:   rts
 863                               _bar:  rts
 864                    into:
 865                                      mov.w   r0,r0
 866                                      bne     _bar
 867                                      rts
 868                               _bar:  rts
 869
 870                    which changes the call (jsr) into a branch (bne).  */
 871                 if (code == 0x5a
 872                     && (int) gap <= 130
 873                     && (int) gap >= -128
 874                     && last_reloc
 875                     && ELF32_R_TYPE (last_reloc->r_info) == R_H8_PCREL8
 876                     && ELF32_R_SYM (last_reloc->r_info) < symtab_hdr->sh_info)
 877                   {
 878                     bfd_vma last_value;
 879                     asection *last_sym_sec;
 880                     Elf_Internal_Sym *last_sym;
 881
 882                     /* We will need to examine the symbol used by the
 883                        previous relocation.  */
 884
 885                     last_sym = isymbuf + ELF32_R_SYM (last_reloc->r_info);
 886                     last_sym_sec
 887                       = bfd_section_from_elf_index (abfd, last_sym->st_shndx);
 888                     last_value = (last_sym->st_value
 889                                   + last_sym_sec->output_section->vma
 890                                   + last_sym_sec->output_offset);
 891
 892                     /* Verify that the previous relocation was for a
 893                        branch around this instruction and that no symbol
 894                        exists at the current location.  */
 895                     if (last_value == dot + 4
 896                         && last_reloc->r_offset + 2 == irel->r_offset
 897                         && ! elf32_h8_symbol_address_p (abfd, sec, dot))
 898                       {
 899                         /* We can eliminate this jump.  Twiddle the
 900                            previous relocation as necessary.  */
 901                         irel->r_info
 902                           = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
 903                                           ELF32_R_TYPE (R_H8_NONE));
 904
 905                         last_reloc->r_info
 906                           = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
 907                                           ELF32_R_TYPE (R_H8_PCREL8));
 908                         last_reloc->r_addend = irel->r_addend;
 909
 910                         code = bfd_get_8 (abfd,
 911                                           contents + last_reloc->r_offset - 1);
 912                         code ^= 1;
 913                         bfd_put_8 (abfd,
 914                                    code,
 915                         contents + last_reloc->r_offset - 1);
 916
 917                         /* Delete four bytes of data.  */
 918                         if (!elf32_h8_relax_delete_bytes (abfd, sec,
 919                                                           irel->r_offset - 1,
 920                                                           4))
 921                           goto error_return;
 922
 923                         *again = TRUE;
 924                         break;
 925                       }
 926                   }
 927
 928                 if (code == 0x5e)
 929                   /* This is jsr.  */
 930                   bfd_put_8 (abfd, 0x55, contents + irel->r_offset - 1);
 931                 else if (code == 0x5a)
 932                   /* This is jmp.  */
 933                   bfd_put_8 (abfd, 0x40, contents + irel->r_offset - 1);
 934                 else
 935                   abort ();
 936
 937                 /* Fix the relocation's type.  */
 938                 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
 939                                              R_H8_PCREL8);
 940
 941                 /* Delete two bytes of data.  */
 942                 if (!elf32_h8_relax_delete_bytes (abfd, sec,
 943                                                   irel->r_offset + 1, 2))
 944                   goto error_return;
 945
 946                 /* That will change things, so, we should relax again.
 947                    Note that this is not required, and it may be slow.  */
 948                 *again = TRUE;
 949               }
 950             break;
 951           }
 952
 953         /* Try to turn a 16-bit pc-relative branch into a 8-bit pc-relative
 954            branch.  */
 955         case R_H8_PCREL16:
 956           {
 957             bfd_vma value = symval + irel->r_addend;
 958             bfd_vma dot;
 959             bfd_vma gap;
 960
 961             /* Get the address of this instruction.  */
 962             dot = (sec->output_section->vma
 963                    + sec->output_offset
 964                    + irel->r_offset - 2);
 965
 966             gap = value - dot;
 967
 968             /* If the distance is within -126..+130 inclusive, then we can
 969                relax this jump.  +130 is valid since the target will move
 970                two bytes closer if we do relax this branch.  */
 971             if ((int) gap >= -126 && (int) gap <= 130)
 972               {
 973                 unsigned char code;
 974
 975                 /* Note that we've changed the relocs, section contents,
 976                    etc.  */
 977                 elf_section_data (sec)->relocs = internal_relocs;
 978                 elf_section_data (sec)->this_hdr.contents = contents;
 979                 symtab_hdr->contents = (unsigned char *) isymbuf;
 980
 981                 /* Get the opcode.  */
 982                 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
 983
 984                 if (code == 0x58)
 985                   {
 986                     /* bCC:16 -> bCC:8 */
 987                     /* Get the second byte of the original insn, which
 988                        contains the condition code.  */
 989                     code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
 990
 991                     /* Compute the fisrt byte of the relaxed
 992                        instruction.  The original sequence 0x58 0xX0
 993                        is relaxed to 0x4X, where X represents the
 994                        condition code.  */
 995                     code &= 0xf0;
 996                     code >>= 4;
 997                     code |= 0x40;
 998                     bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
 999                   }
1000                 else if (code == 0x5c)
1001                   /* This is bsr.  */
1002                   bfd_put_8 (abfd, 0x55, contents + irel->r_offset - 2);
1003                 else
1004                   /* Might be MOVSD.  */
1005                   break;
1006
1007                 /* Fix the relocation's type.  */
1008                 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1009                                              R_H8_PCREL8);
1010                 irel->r_offset--;
1011
1012                 /* Delete two bytes of data.  */
1013                 if (!elf32_h8_relax_delete_bytes (abfd, sec,
1014                                                   irel->r_offset + 1, 2))
1015                   goto error_return;
1016
1017                 /* That will change things, so, we should relax again.
1018                    Note that this is not required, and it may be slow.  */
1019                 *again = TRUE;
1020               }
1021             break;
1022           }
1023
1024         /* This is a 16-bit absolute address in one of the following
1025            instructions:
1026
1027              "band", "bclr", "biand", "bild", "bior", "bist", "bixor",
1028              "bld", "bnot", "bor", "bset", "bst", "btst", "bxor", and
1029              "mov.b"
1030
1031            We may relax this into an 8-bit absolute address if it's in
1032            the right range.  */
1033         case R_H8_DIR16A8:
1034           {
1035             bfd_vma value;
1036
1037             value = bfd_h8300_pad_address (abfd, symval + irel->r_addend);
1038             if (value >= 0xffffff00u)
1039               {
1040                 unsigned char code;
1041                 unsigned char temp_code;
1042
1043                 /* Note that we've changed the relocs, section contents,
1044                    etc.  */
1045                 elf_section_data (sec)->relocs = internal_relocs;
1046                 elf_section_data (sec)->this_hdr.contents = contents;
1047                 symtab_hdr->contents = (unsigned char *) isymbuf;
1048
1049                 /* Get the opcode.  */
1050                 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
1051
1052                 /* All instructions with R_H8_DIR16A8 start with
1053                    0x6a.  */
1054                 if (code != 0x6a)
1055                   abort ();
1056
1057                 temp_code = code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1058                 /* If this is a mov.b instruction, clear the lower
1059                    nibble, which contains the source/destination
1060                    register number.  */
1061                 if ((temp_code & 0x10) != 0x10)
1062                   temp_code &= 0xf0;
1063
1064                 switch (temp_code)
1065                   {
1066                   case 0x00:
1067                     /* This is mov.b @aa:16,Rd.  */
1068                     bfd_put_8 (abfd, (code & 0xf) | 0x20,
1069                                contents + irel->r_offset - 2);
1070                     break;
1071                   case 0x80:
1072                     /* This is mov.b Rs,@aa:16.  */
1073                     bfd_put_8 (abfd, (code & 0xf) | 0x30,
1074                                contents + irel->r_offset - 2);
1075                     break;
1076                   case 0x18:
1077                     /* This is a bit-maniputation instruction that
1078                        stores one bit into memory, one of "bclr",
1079                        "bist", "bnot", "bset", and "bst".  */
1080                     bfd_put_8 (abfd, 0x7f, contents + irel->r_offset - 2);
1081                     break;
1082                   case 0x10:
1083                     /* This is a bit-maniputation instruction that
1084                        loads one bit from memory, one of "band",
1085                        "biand", "bild", "bior", "bixor", "bld", "bor",
1086                        "btst", and "bxor".  */
1087                     bfd_put_8 (abfd, 0x7e, contents + irel->r_offset - 2);
1088                     break;
1089                   default:
1090                     abort ();
1091                   }
1092
1093                 /* Fix the relocation's type.  */
1094                 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1095                                              R_H8_DIR8);
1096
1097                 /* Move the relocation.  */
1098                 irel->r_offset--;
1099
1100                 /* Delete two bytes of data.  */
1101                 if (!elf32_h8_relax_delete_bytes (abfd, sec,
1102                                                   irel->r_offset + 1, 2))
1103                   goto error_return;
1104
1105                 /* That will change things, so, we should relax again.
1106                    Note that this is not required, and it may be slow.  */
1107                 *again = TRUE;
1108               }
1109             break;
1110           }
1111
1112         /* This is a 24-bit absolute address in one of the following
1113            instructions:
1114
1115              "band", "bclr", "biand", "bild", "bior", "bist", "bixor",
1116              "bld", "bnot", "bor", "bset", "bst", "btst", "bxor", and
1117              "mov.b"
1118
1119            We may relax this into an 8-bit absolute address if it's in
1120            the right range.  */
1121         case R_H8_DIR24A8:
1122           {
1123             bfd_vma value;
1124
1125             value = bfd_h8300_pad_address (abfd, symval + irel->r_addend);
1126             if (value >= 0xffffff00u)
1127               {
1128                 unsigned char code;
1129                 unsigned char temp_code;
1130
1131                 /* Note that we've changed the relocs, section contents,
1132                    etc.  */
1133                 elf_section_data (sec)->relocs = internal_relocs;
1134                 elf_section_data (sec)->this_hdr.contents = contents;
1135                 symtab_hdr->contents = (unsigned char *) isymbuf;
1136
1137                 /* Get the opcode.  */
1138                 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
1139
1140                 /* All instructions with R_H8_DIR24A8 start with
1141                    0x6a.  */
1142                 if (code != 0x6a)
1143                   abort ();
1144
1145                 temp_code = code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1146
1147                 /* If this is a mov.b instruction, clear the lower
1148                    nibble, which contains the source/destination
1149                    register number.  */
1150                 if ((temp_code & 0x30) != 0x30)
1151                   temp_code &= 0xf0;
1152
1153                 switch (temp_code)
1154                   {
1155                   case 0x20:
1156                     /* This is mov.b @aa:24/32,Rd.  */
1157                     bfd_put_8 (abfd, (code & 0xf) | 0x20,
1158                                contents + irel->r_offset - 2);
1159                     break;
1160                   case 0xa0:
1161                     /* This is mov.b Rs,@aa:24/32.  */
1162                     bfd_put_8 (abfd, (code & 0xf) | 0x30,
1163                                contents + irel->r_offset - 2);
1164                     break;
1165                   case 0x38:
1166                     /* This is a bit-maniputation instruction that
1167                        stores one bit into memory, one of "bclr",
1168                        "bist", "bnot", "bset", and "bst".  */
1169                     bfd_put_8 (abfd, 0x7f, contents + irel->r_offset - 2);
1170                     break;
1171                   case 0x30:
1172                     /* This is a bit-maniputation instruction that
1173                        loads one bit from memory, one of "band",
1174                        "biand", "bild", "bior", "bixor", "bld", "bor",
1175                        "btst", and "bxor".  */
1176                     bfd_put_8 (abfd, 0x7e, contents + irel->r_offset - 2);
1177                     break;
1178                   default:
1179                     abort();
1180                   }
1181
1182                 /* Fix the relocation's type.  */
1183                 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1184                                              R_H8_DIR8);
1185                 irel->r_offset--;
1186
1187                 /* Delete two bytes of data.  */
1188                 if (!elf32_h8_relax_delete_bytes (abfd, sec,
1189                                                   irel->r_offset + 1, 4))
1190                   goto error_return;
1191
1192                 /* That will change things, so, we should relax again.
1193                    Note that this is not required, and it may be slow.  */
1194                 *again = TRUE;
1195                 break;
1196               }
1197           }
1198
1199           /* Fall through.  */
1200
1201           /* This is a 24-/32-bit absolute address in one of the
1202              following instructions:
1203
1204                "band", "bclr", "biand", "bild", "bior", "bist",
1205                "bixor", "bld", "bnot", "bor", "bset", "bst", "btst",
1206                "bxor", "ldc.w", "stc.w" and "mov.[bwl]"
1207
1208              We may relax this into an 16-bit absolute address if it's
1209              in the right range.  */
1210         case R_H8_DIR32A16:
1211           {
1212             bfd_vma value;
1213
1214             value = bfd_h8300_pad_address (abfd, symval + irel->r_addend);
1215             if (value <= 0x7fff || value >= 0xffff8000u)
1216               {
1217                 unsigned char code;
1218                 unsigned char op0, op1, op2, op3;
1219                 unsigned char *op_ptr;
1220
1221                 /* Note that we've changed the relocs, section contents,
1222                    etc.  */
1223                 elf_section_data (sec)->relocs = internal_relocs;
1224                 elf_section_data (sec)->this_hdr.contents = contents;
1225                 symtab_hdr->contents = (unsigned char *) isymbuf;
1226
1227                 if (irel->r_offset >= 4)
1228                   {
1229                     /* Check for 4-byte MOVA relaxation.  */
1230                     int second_reloc = 0;
1231
1232                     op_ptr = contents + irel->r_offset - 4;
1233
1234                     if (last_reloc)
1235                       {
1236                         arelent bfd_reloc;
1237                         reloc_howto_type *h;
1238                         bfd_vma last_reloc_size;
1239
1240                         elf32_h8_info_to_howto (abfd, &bfd_reloc, last_reloc);
1241                         h = bfd_reloc.howto;
1242                         last_reloc_size = 1 << h->size;
1243                         if (last_reloc->r_offset + last_reloc_size
1244                             == irel->r_offset)
1245                           {
1246                             op_ptr -= last_reloc_size;
1247                             second_reloc = 1;
1248                           }
1249                       }
1250                     if (irel < irelend)
1251                       {
1252                         Elf_Internal_Rela *next_reloc = irel + 1;
1253                         arelent bfd_reloc;
1254                         reloc_howto_type *h;
1255                         bfd_vma next_reloc_size;
1256
1257                         elf32_h8_info_to_howto (abfd, &bfd_reloc, next_reloc);
1258                         h = bfd_reloc.howto;
1259                         next_reloc_size = 1 << h->size;
1260                         if (next_reloc->r_offset + next_reloc_size
1261                             == irel->r_offset)
1262                           {
1263                             op_ptr -= next_reloc_size;
1264                             second_reloc = 1;
1265                           }
1266                       }
1267
1268                     op0 = bfd_get_8 (abfd, op_ptr + 0);
1269                     op1 = bfd_get_8 (abfd, op_ptr + 1);
1270                     op2 = bfd_get_8 (abfd, op_ptr + 2);
1271                     op3 = bfd_get_8 (abfd, op_ptr + 3);
1272
1273                     if (op0 == 0x01
1274                         && (op1 & 0xdf) == 0x5f
1275                         && (op2 & 0x40) == 0x40
1276                         && (op3 & 0x80) == 0x80)
1277                       {
1278                         if ((op2 & 0x08) == 0)
1279                           second_reloc = 1;
1280
1281                         if (second_reloc)
1282                           {
1283                             op3 &= ~0x08;
1284                             bfd_put_8 (abfd, op3, op_ptr + 3);
1285                           }
1286                         else
1287                           {
1288                             op2 &= ~0x08;
1289                             bfd_put_8 (abfd, op2, op_ptr + 2);
1290                           }
1291                         goto r_h8_dir32a16_common;
1292                       }
1293                   }
1294
1295                 /* Now check for short version of MOVA.  */
1296                 op_ptr = contents + irel->r_offset - 2;
1297                 op0 = bfd_get_8 (abfd, op_ptr + 0);
1298                 op1 = bfd_get_8 (abfd, op_ptr + 1);
1299
1300                 if (op0 == 0x7a
1301                     && (op1 & 0x88) == 0x80)
1302                   {
1303                     op1 |= 0x08;
1304                     bfd_put_8 (abfd, op1, op_ptr + 1);
1305                     goto r_h8_dir32a16_common;
1306                   }
1307
1308                 /* Get the opcode.  */
1309                 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1310
1311                 /* Fix the opcode.  For all the instructions that
1312                    belong to this relaxation, we simply need to turn
1313                    off bit 0x20 in the previous byte.  */
1314                 code &= ~0x20;
1315
1316                 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
1317
1318               r_h8_dir32a16_common:
1319                 /* Fix the relocation's type.  */
1320                 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1321                                              R_H8_DIR16);
1322
1323                 /* Delete two bytes of data.  */
1324                 if (!elf32_h8_relax_delete_bytes (abfd, sec,
1325                                                   irel->r_offset + 1, 2))
1326                   goto error_return;
1327
1328                 /* That will change things, so, we should relax again.
1329                    Note that this is not required, and it may be slow.  */
1330                 *again = TRUE;
1331               }
1332             break;
1333           }
1334
1335         default:
1336           break;
1337         }
1338     }
1339
1340   if (isymbuf != NULL
1341       && symtab_hdr->contents != (unsigned char *) isymbuf)
1342     {
1343       if (! link_info->keep_memory)
1344         free (isymbuf);
1345       else
1346         symtab_hdr->contents = (unsigned char *) isymbuf;
1347     }
1348
1349   if (contents != NULL
1350       && elf_section_data (sec)->this_hdr.contents != contents)
1351     {
1352       if (! link_info->keep_memory)
1353         free (contents);
1354       else
1355         {
1356           /* Cache the section contents for elf_link_input_bfd.  */
1357           elf_section_data (sec)->this_hdr.contents = contents;
1358         }
1359     }
1360
1361   if (internal_relocs != NULL
1362       && elf_section_data (sec)->relocs != internal_relocs)
1363     free (internal_relocs);
1364
1365   return TRUE;
1366
1367  error_return:
1368   if (isymbuf != NULL
1369       && symtab_hdr->contents != (unsigned char *) isymbuf)
1370     free (isymbuf);
1371   if (contents != NULL
1372       && elf_section_data (sec)->this_hdr.contents != contents)
1373     free (contents);
1374   if (internal_relocs != NULL
1375       && elf_section_data (sec)->relocs != internal_relocs)
1376     free (internal_relocs);
1377   return FALSE;
1378 }
1379
1380 /* Delete some bytes from a section while relaxing.  */
1381
1382 static bfd_boolean
1383 elf32_h8_relax_delete_bytes (bfd *abfd, asection *sec, bfd_vma addr, int count)
1384 {
1385   Elf_Internal_Shdr *symtab_hdr;
1386   unsigned int sec_shndx;
1387   bfd_byte *contents;
1388   Elf_Internal_Rela *irel, *irelend;
1389   Elf_Internal_Rela *irelalign;
1390   Elf_Internal_Sym *isym;
1391   Elf_Internal_Sym *isymend;
1392   bfd_vma toaddr;
1393   struct elf_link_hash_entry **sym_hashes;
1394   struct elf_link_hash_entry **end_hashes;
1395   unsigned int symcount;
1396
1397   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1398
1399   contents = elf_section_data (sec)->this_hdr.contents;
1400
1401   /* The deletion must stop at the next ALIGN reloc for an aligment
1402      power larger than the number of bytes we are deleting.  */
1403
1404   irelalign = NULL;
1405   toaddr = sec->size;
1406
1407   irel = elf_section_data (sec)->relocs;
1408   irelend = irel + sec->reloc_count;
1409
1410   /* Actually delete the bytes.  */
1411   memmove (contents + addr, contents + addr + count,
1412            (size_t) (toaddr - addr - count));
1413   sec->size -= count;
1414
1415   /* Adjust all the relocs.  */
1416   for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1417     {
1418       /* Get the new reloc address.  */
1419       if ((irel->r_offset > addr
1420            && irel->r_offset < toaddr))
1421         irel->r_offset -= count;
1422     }
1423
1424   /* Adjust the local symbols defined in this section.  */
1425   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1426   isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1427   isymend = isym + symtab_hdr->sh_info;
1428   for (; isym < isymend; isym++)
1429     {
1430       if (isym->st_shndx == sec_shndx
1431           && isym->st_value > addr
1432           && isym->st_value < toaddr)
1433         isym->st_value -= count;
1434     }
1435
1436   /* Now adjust the global symbols defined in this section.  */
1437   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1438               - symtab_hdr->sh_info);
1439   sym_hashes = elf_sym_hashes (abfd);
1440   end_hashes = sym_hashes + symcount;
1441   for (; sym_hashes < end_hashes; sym_hashes++)
1442     {
1443       struct elf_link_hash_entry *sym_hash = *sym_hashes;
1444       if ((sym_hash->root.type == bfd_link_hash_defined
1445            || sym_hash->root.type == bfd_link_hash_defweak)
1446           && sym_hash->root.u.def.section == sec
1447           && sym_hash->root.u.def.value > addr
1448           && sym_hash->root.u.def.value < toaddr)
1449         {
1450           sym_hash->root.u.def.value -= count;
1451         }
1452     }
1453
1454   return TRUE;
1455 }
1456
1457 /* Return TRUE if a symbol exists at the given address, else return
1458    FALSE.  */
1459 static bfd_boolean
1460 elf32_h8_symbol_address_p (bfd *abfd, asection *sec, bfd_vma addr)
1461 {
1462   Elf_Internal_Shdr *symtab_hdr;
1463   unsigned int sec_shndx;
1464   Elf_Internal_Sym *isym;
1465   Elf_Internal_Sym *isymend;
1466   struct elf_link_hash_entry **sym_hashes;
1467   struct elf_link_hash_entry **end_hashes;
1468   unsigned int symcount;
1469
1470   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1471
1472   /* Examine all the symbols.  */
1473   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1474   isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1475   isymend = isym + symtab_hdr->sh_info;
1476   for (; isym < isymend; isym++)
1477     {
1478       if (isym->st_shndx == sec_shndx
1479           && isym->st_value == addr)
1480         return TRUE;
1481     }
1482
1483   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1484               - symtab_hdr->sh_info);
1485   sym_hashes = elf_sym_hashes (abfd);
1486   end_hashes = sym_hashes + symcount;
1487   for (; sym_hashes < end_hashes; sym_hashes++)
1488     {
1489       struct elf_link_hash_entry *sym_hash = *sym_hashes;
1490       if ((sym_hash->root.type == bfd_link_hash_defined
1491            || sym_hash->root.type == bfd_link_hash_defweak)
1492           && sym_hash->root.u.def.section == sec
1493           && sym_hash->root.u.def.value == addr)
1494         return TRUE;
1495     }
1496
1497   return FALSE;
1498 }
1499
1500 /* This is a version of bfd_generic_get_relocated_section_contents
1501    which uses elf32_h8_relocate_section.  */
1502
1503 static bfd_byte *
1504 elf32_h8_get_relocated_section_contents (bfd *output_bfd,
1505                                          struct bfd_link_info *link_info,
1506                                          struct bfd_link_order *link_order,
1507                                          bfd_byte *data,
1508                                          bfd_boolean relocatable,
1509                                          asymbol **symbols)
1510 {
1511   Elf_Internal_Shdr *symtab_hdr;
1512   asection *input_section = link_order->u.indirect.section;
1513   bfd *input_bfd = input_section->owner;
1514   asection **sections = NULL;
1515   Elf_Internal_Rela *internal_relocs = NULL;
1516   Elf_Internal_Sym *isymbuf = NULL;
1517
1518   /* We only need to handle the case of relaxing, or of having a
1519      particular set of section contents, specially.  */
1520   if (relocatable
1521       || elf_section_data (input_section)->this_hdr.contents == NULL)
1522     return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
1523                                                        link_order, data,
1524                                                        relocatable,
1525                                                        symbols);
1526
1527   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1528
1529   memcpy (data, elf_section_data (input_section)->this_hdr.contents,
1530           (size_t) input_section->size);
1531
1532   if ((input_section->flags & SEC_RELOC) != 0
1533       && input_section->reloc_count > 0)
1534     {
1535       asection **secpp;
1536       Elf_Internal_Sym *isym, *isymend;
1537       bfd_size_type amt;
1538
1539       internal_relocs = (_bfd_elf_link_read_relocs
1540                          (input_bfd, input_section, (PTR) NULL,
1541                           (Elf_Internal_Rela *) NULL, FALSE));
1542       if (internal_relocs == NULL)
1543         goto error_return;
1544
1545       if (symtab_hdr->sh_info != 0)
1546         {
1547           isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1548           if (isymbuf == NULL)
1549             isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
1550                                             symtab_hdr->sh_info, 0,
1551                                             NULL, NULL, NULL);
1552           if (isymbuf == NULL)
1553             goto error_return;
1554         }
1555
1556       amt = symtab_hdr->sh_info;
1557       amt *= sizeof (asection *);
1558       sections = (asection **) bfd_malloc (amt);
1559       if (sections == NULL && amt != 0)
1560         goto error_return;
1561
1562       isymend = isymbuf + symtab_hdr->sh_info;
1563       for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
1564         {
1565           asection *isec;
1566
1567           if (isym->st_shndx == SHN_UNDEF)
1568             isec = bfd_und_section_ptr;
1569           else if (isym->st_shndx == SHN_ABS)
1570             isec = bfd_abs_section_ptr;
1571           else if (isym->st_shndx == SHN_COMMON)
1572             isec = bfd_com_section_ptr;
1573           else
1574             isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
1575
1576           *secpp = isec;
1577         }
1578
1579       if (! elf32_h8_relocate_section (output_bfd, link_info, input_bfd,
1580                                        input_section, data, internal_relocs,
1581                                        isymbuf, sections))
1582         goto error_return;
1583
1584       if (sections != NULL)
1585         free (sections);
1586       if (isymbuf != NULL
1587           && symtab_hdr->contents != (unsigned char *) isymbuf)
1588         free (isymbuf);
1589       if (elf_section_data (input_section)->relocs != internal_relocs)
1590         free (internal_relocs);
1591     }
1592
1593   return data;
1594
1595  error_return:
1596   if (sections != NULL)
1597     free (sections);
1598   if (isymbuf != NULL
1599       && symtab_hdr->contents != (unsigned char *) isymbuf)
1600     free (isymbuf);
1601   if (internal_relocs != NULL
1602       && elf_section_data (input_section)->relocs != internal_relocs)
1603     free (internal_relocs);
1604   return NULL;
1605 }
1606
1607
1608 #define TARGET_BIG_SYM                  bfd_elf32_h8300_vec
1609 #define TARGET_BIG_NAME                 "elf32-h8300"
1610 #define ELF_ARCH                        bfd_arch_h8300
1611 #define ELF_MACHINE_CODE                EM_H8_300
1612 #define ELF_MAXPAGESIZE                 0x1
1613 #define bfd_elf32_bfd_reloc_type_lookup elf32_h8_reloc_type_lookup
1614 #define bfd_elf32_bfd_reloc_name_lookup elf32_h8_reloc_name_lookup
1615 #define elf_info_to_howto               elf32_h8_info_to_howto
1616 #define elf_info_to_howto_rel           elf32_h8_info_to_howto_rel
1617
1618 /* So we can set/examine bits in e_flags to get the specific
1619    H8 architecture in use.  */
1620 #define elf_backend_final_write_processing \
1621   elf32_h8_final_write_processing
1622 #define elf_backend_object_p \
1623   elf32_h8_object_p
1624 #define bfd_elf32_bfd_merge_private_bfd_data \
1625   elf32_h8_merge_private_bfd_data
1626
1627 /* ??? when elf_backend_relocate_section is not defined, elf32-target.h
1628    defaults to using _bfd_generic_link_hash_table_create, but
1629    bfd_elf_size_dynamic_sections uses
1630    dynobj = elf_hash_table (info)->dynobj;
1631    and thus requires an elf hash table.  */
1632 #define bfd_elf32_bfd_link_hash_table_create _bfd_elf_link_hash_table_create
1633
1634 /* Use an H8 specific linker, not the ELF generic linker.  */
1635 #define elf_backend_relocate_section elf32_h8_relocate_section
1636 #define elf_backend_rela_normal         1
1637 #define elf_backend_can_gc_sections     1
1638
1639 /* And relaxing stuff.  */
1640 #define bfd_elf32_bfd_relax_section     elf32_h8_relax_section
1641 #define bfd_elf32_bfd_get_relocated_section_contents \
1642                                 elf32_h8_get_relocated_section_contents
1643
1644
1645 #include "elf32-target.h"