bfd/elf32-h8300.c

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