bfd/elf32-h8300.c

   1 /* BFD back-end for Renesas H8/300 ELF binaries.
   2    Copyright (C) 1993-2016 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          3,                     /* 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 (bfd_link_relocatable (info))
 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               (*info->callbacks->reloc_overflow)
 511                 (info, (h ? &h->root : NULL), name, howto->name,
 512                  (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
 513               break;
 514
 515             case bfd_reloc_undefined:
 516               (*info->callbacks->undefined_symbol)
 517                 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
 518               break;
 519
 520             case bfd_reloc_outofrange:
 521               msg = _("internal error: out of range error");
 522               goto common_error;
 523
 524             case bfd_reloc_notsupported:
 525               msg = _("internal error: unsupported relocation error");
 526               goto common_error;
 527
 528             case bfd_reloc_dangerous:
 529               msg = _("internal error: dangerous error");
 530               goto common_error;
 531
 532             default:
 533               msg = _("internal error: unknown error");
 534               /* fall through */
 535
 536             common_error:
 537               (*info->callbacks->warning) (info, msg, name, input_bfd,
 538                                            input_section, rel->r_offset);
 539               break;
 540             }
 541         }
 542     }
 543
 544   return TRUE;
 545 }
 546
 547 /* Object files encode the specific H8 model they were compiled
 548    for in the ELF flags field.
 549
 550    Examine that field and return the proper BFD machine type for
 551    the object file.  */
 552 static unsigned long
 553 elf32_h8_mach (flagword flags)
 554 {
 555   switch (flags & EF_H8_MACH)
 556     {
 557     case E_H8_MACH_H8300:
 558     default:
 559       return bfd_mach_h8300;
 560
 561     case E_H8_MACH_H8300H:
 562       return bfd_mach_h8300h;
 563
 564     case E_H8_MACH_H8300S:
 565       return bfd_mach_h8300s;
 566
 567     case E_H8_MACH_H8300HN:
 568       return bfd_mach_h8300hn;
 569
 570     case E_H8_MACH_H8300SN:
 571       return bfd_mach_h8300sn;
 572
 573     case E_H8_MACH_H8300SX:
 574       return bfd_mach_h8300sx;
 575
 576     case E_H8_MACH_H8300SXN:
 577       return bfd_mach_h8300sxn;
 578     }
 579 }
 580
 581 /* The final processing done just before writing out a H8 ELF object
 582    file.  We use this opportunity to encode the BFD machine type
 583    into the flags field in the object file.  */
 584
 585 static void
 586 elf32_h8_final_write_processing (bfd *abfd,
 587                                  bfd_boolean linker ATTRIBUTE_UNUSED)
 588 {
 589   unsigned long val;
 590
 591   switch (bfd_get_mach (abfd))
 592     {
 593     default:
 594     case bfd_mach_h8300:
 595       val = E_H8_MACH_H8300;
 596       break;
 597
 598     case bfd_mach_h8300h:
 599       val = E_H8_MACH_H8300H;
 600       break;
 601
 602     case bfd_mach_h8300s:
 603       val = E_H8_MACH_H8300S;
 604       break;
 605
 606     case bfd_mach_h8300hn:
 607       val = E_H8_MACH_H8300HN;
 608       break;
 609
 610     case bfd_mach_h8300sn:
 611       val = E_H8_MACH_H8300SN;
 612       break;
 613
 614     case bfd_mach_h8300sx:
 615       val = E_H8_MACH_H8300SX;
 616       break;
 617
 618     case bfd_mach_h8300sxn:
 619       val = E_H8_MACH_H8300SXN;
 620       break;
 621     }
 622
 623   elf_elfheader (abfd)->e_flags &= ~ (EF_H8_MACH);
 624   elf_elfheader (abfd)->e_flags |= val;
 625 }
 626
 627 /* Return nonzero if ABFD represents a valid H8 ELF object file; also
 628    record the encoded machine type found in the ELF flags.  */
 629
 630 static bfd_boolean
 631 elf32_h8_object_p (bfd *abfd)
 632 {
 633   bfd_default_set_arch_mach (abfd, bfd_arch_h8300,
 634                              elf32_h8_mach (elf_elfheader (abfd)->e_flags));
 635   return TRUE;
 636 }
 637
 638 /* Merge backend specific data from an object file to the output
 639    object file when linking.  The only data we need to copy at this
 640    time is the architecture/machine information.  */
 641
 642 static bfd_boolean
 643 elf32_h8_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
 644 {
 645   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
 646       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
 647     return TRUE;
 648
 649   if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
 650       && bfd_get_mach (obfd) < bfd_get_mach (ibfd))
 651     {
 652       if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
 653                                bfd_get_mach (ibfd)))
 654         return FALSE;
 655     }
 656
 657   return TRUE;
 658 }
 659
 660 /* This function handles relaxing for the H8..
 661
 662    There are a few relaxing opportunities available on the H8:
 663
 664      jmp/jsr:24    ->    bra/bsr:8              2 bytes
 665      The jmp may be completely eliminated if the previous insn is a
 666      conditional branch to the insn after the jump.  In that case
 667      we invert the branch and delete the jump and save 4 bytes.
 668
 669      bCC:16          ->    bCC:8                  2 bytes
 670      bsr:16          ->    bsr:8                  2 bytes
 671
 672      bset:16         ->    bset:8                 2 bytes
 673      bset:24/32      ->    bset:8                 4 bytes
 674      (also applicable to other bit manipulation instructions)
 675
 676      mov.b:16        ->    mov.b:8                2 bytes
 677      mov.b:24/32     ->    mov.b:8                4 bytes
 678
 679      bset:24/32      ->    bset:16                2 bytes
 680      (also applicable to other bit manipulation instructions)
 681
 682      mov.[bwl]:24/32 ->    mov.[bwl]:16           2 bytes
 683
 684      mov.[bwl] @(displ:24/32+ERx) -> mov.[bwl] @(displ:16+ERx)  4 bytes.  */
 685
 686 static bfd_boolean
 687 elf32_h8_relax_section (bfd *abfd, asection *sec,
 688                         struct bfd_link_info *link_info, bfd_boolean *again)
 689 {
 690   Elf_Internal_Shdr *symtab_hdr;
 691   Elf_Internal_Rela *internal_relocs;
 692   Elf_Internal_Rela *irel, *irelend;
 693   bfd_byte *contents = NULL;
 694   Elf_Internal_Sym *isymbuf = NULL;
 695   static asection *last_input_section = NULL;
 696   static Elf_Internal_Rela *last_reloc = NULL;
 697
 698   /* Assume nothing changes.  */
 699   *again = FALSE;
 700
 701   /* We don't have to do anything for a relocatable link, if
 702      this section does not have relocs, or if this is not a
 703      code section.  */
 704   if (bfd_link_relocatable (link_info)
 705       || (sec->flags & SEC_RELOC) == 0
 706       || sec->reloc_count == 0
 707       || (sec->flags & SEC_CODE) == 0)
 708     return TRUE;
 709
 710   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 711
 712   /* Get a copy of the native relocations.  */
 713   internal_relocs = (_bfd_elf_link_read_relocs
 714                      (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
 715                       link_info->keep_memory));
 716   if (internal_relocs == NULL)
 717     goto error_return;
 718
 719   if (sec != last_input_section)
 720     last_reloc = NULL;
 721
 722   last_input_section = sec;
 723
 724   /* Walk through the relocs looking for relaxing opportunities.  */
 725   irelend = internal_relocs + sec->reloc_count;
 726   for (irel = internal_relocs; irel < irelend; irel++)
 727     {
 728       bfd_vma symval;
 729
 730       {
 731         arelent bfd_reloc;
 732
 733         elf32_h8_info_to_howto (abfd, &bfd_reloc, irel);
 734       }
 735       /* Keep track of the previous reloc so that we can delete
 736          some long jumps created by the compiler.  */
 737       if (irel != internal_relocs)
 738         last_reloc = irel - 1;
 739
 740       switch(ELF32_R_TYPE (irel->r_info))
 741         {
 742         case R_H8_DIR24R8:
 743         case R_H8_PCREL16:
 744         case R_H8_DIR16A8:
 745         case R_H8_DIR24A8:
 746         case R_H8_DIR32A16:
 747         case R_H8_DISP32A16:
 748           break;
 749         default:
 750           continue;
 751         }
 752
 753       /* Get the section contents if we haven't done so already.  */
 754       if (contents == NULL)
 755         {
 756           /* Get cached copy if it exists.  */
 757           if (elf_section_data (sec)->this_hdr.contents != NULL)
 758             contents = elf_section_data (sec)->this_hdr.contents;
 759           else
 760             {
 761               /* Go get them off disk.  */
 762               if (!bfd_malloc_and_get_section (abfd, sec, &contents))
 763                 goto error_return;
 764             }
 765         }
 766
 767       /* Read this BFD's local symbols if we haven't done so already.  */
 768       if (isymbuf == NULL && symtab_hdr->sh_info != 0)
 769         {
 770           isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
 771           if (isymbuf == NULL)
 772             isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
 773                                             symtab_hdr->sh_info, 0,
 774                                             NULL, NULL, NULL);
 775           if (isymbuf == NULL)
 776             goto error_return;
 777         }
 778
 779       /* Get the value of the symbol referred to by the reloc.  */
 780       if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
 781         {
 782           /* A local symbol.  */
 783           Elf_Internal_Sym *isym;
 784           asection *sym_sec;
 785
 786           isym = isymbuf + ELF32_R_SYM (irel->r_info);
 787           sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
 788           symval = isym->st_value;
 789           /* If the reloc is absolute, it will not have
 790              a symbol or section associated with it.  */
 791           if (sym_sec)
 792             symval += sym_sec->output_section->vma
 793               + sym_sec->output_offset;
 794         }
 795       else
 796         {
 797           unsigned long indx;
 798           struct elf_link_hash_entry *h;
 799
 800           /* An external symbol.  */
 801           indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
 802           h = elf_sym_hashes (abfd)[indx];
 803           BFD_ASSERT (h != NULL);
 804           if (h->root.type != bfd_link_hash_defined
 805               && h->root.type != bfd_link_hash_defweak)
 806             {
 807               /* This appears to be a reference to an undefined
 808                  symbol.  Just ignore it--it will be caught by the
 809                  regular reloc processing.  */
 810               continue;
 811             }
 812
 813           symval = (h->root.u.def.value
 814                     + h->root.u.def.section->output_section->vma
 815                     + h->root.u.def.section->output_offset);
 816         }
 817
 818       /* For simplicity of coding, we are going to modify the section
 819          contents, the section relocs, and the BFD symbol table.  We
 820          must tell the rest of the code not to free up this
 821          information.  It would be possible to instead create a table
 822          of changes which have to be made, as is done in coff-mips.c;
 823          that would be more work, but would require less memory when
 824          the linker is run.  */
 825       switch (ELF32_R_TYPE (irel->r_info))
 826         {
 827           /* Try to turn a 24-bit absolute branch/call into an 8-bit
 828              pc-relative branch/call.  */
 829         case R_H8_DIR24R8:
 830           {
 831             bfd_vma value = symval + irel->r_addend;
 832             bfd_vma dot, gap;
 833
 834             /* Get the address of this instruction.  */
 835             dot = (sec->output_section->vma
 836                    + sec->output_offset + irel->r_offset - 1);
 837
 838             /* Compute the distance from this insn to the branch target.  */
 839             gap = value - dot;
 840
 841             /* If the distance is within -126..+130 inclusive, then we can
 842                relax this jump.  +130 is valid since the target will move
 843                two bytes closer if we do relax this branch.  */
 844             if ((int) gap >= -126 && (int) gap <= 130)
 845               {
 846                 unsigned char code;
 847
 848                 /* Note that we've changed the relocs, section contents,
 849                    etc.  */
 850                 elf_section_data (sec)->relocs = internal_relocs;
 851                 elf_section_data (sec)->this_hdr.contents = contents;
 852                 symtab_hdr->contents = (unsigned char *) isymbuf;
 853
 854                 /* Get the instruction code being relaxed.  */
 855                 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
 856
 857                 /* If the previous instruction conditionally jumped around
 858                    this instruction, we may be able to reverse the condition
 859                    and redirect the previous instruction to the target of
 860                    this instruction.
 861
 862                    Such sequences are used by the compiler to deal with
 863                    long conditional branches.
 864
 865                    Only perform this optimisation for jumps (code 0x5a) not
 866                    subroutine calls, as otherwise it could transform:
 867
 868                    mov.w   r0,r0
 869                    beq     .L1
 870                    jsr     @_bar
 871                    .L1:   rts
 872                    _bar:  rts
 873                    into:
 874                    mov.w   r0,r0
 875                    bne     _bar
 876                    rts
 877                    _bar:  rts
 878
 879                    which changes the call (jsr) into a branch (bne).  */
 880                 if (code == 0x5a        /* jmp24.  */
 881                     && (int) gap <= 130
 882                     && (int) gap >= -128
 883                     && last_reloc
 884                     && ELF32_R_TYPE (last_reloc->r_info) == R_H8_PCREL8
 885                     && ELF32_R_SYM (last_reloc->r_info) < symtab_hdr->sh_info)
 886                   {
 887                     bfd_vma last_value;
 888                     asection *last_sym_sec;
 889                     Elf_Internal_Sym *last_sym;
 890
 891                     /* We will need to examine the symbol used by the
 892                        previous relocation.  */
 893
 894                     last_sym = isymbuf + ELF32_R_SYM (last_reloc->r_info);
 895                     last_sym_sec
 896                       = bfd_section_from_elf_index (abfd, last_sym->st_shndx);
 897                     last_value = (last_sym->st_value
 898                                   + last_sym_sec->output_section->vma
 899                                   + last_sym_sec->output_offset);
 900
 901                     /* Verify that the previous relocation was for a
 902                        branch around this instruction and that no symbol
 903                        exists at the current location.  */
 904                     if (last_value == dot + 4
 905                         && last_reloc->r_offset + 2 == irel->r_offset
 906                         && ! elf32_h8_symbol_address_p (abfd, sec, dot))
 907                       {
 908                         /* We can eliminate this jump.  Twiddle the
 909                            previous relocation as necessary.  */
 910                         irel->r_info
 911                           = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
 912                                           ELF32_R_TYPE (R_H8_NONE));
 913
 914                         last_reloc->r_info
 915                           = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
 916                                           ELF32_R_TYPE (R_H8_PCREL8));
 917                         last_reloc->r_addend = irel->r_addend;
 918
 919                         code = bfd_get_8 (abfd,
 920                                           contents + last_reloc->r_offset - 1);
 921                         code ^= 1;
 922                         bfd_put_8 (abfd,
 923                                    code,
 924                                    contents + last_reloc->r_offset - 1);
 925
 926                         /* Delete four bytes of data.  */
 927                         if (!elf32_h8_relax_delete_bytes (abfd, sec,
 928                                                           irel->r_offset - 1,
 929                                                           4))
 930                           goto error_return;
 931
 932                         *again = TRUE;
 933                         break;
 934                       }
 935                   }
 936
 937                 if (code == 0x5e)
 938                   /* This is jsr24  */
 939                   bfd_put_8 (abfd, 0x55, contents + irel->r_offset - 1);        /* bsr8. */
 940                 else if (code == 0x5a)
 941                   /* This is jmp24  */
 942                   bfd_put_8 (abfd, 0x40, contents + irel->r_offset - 1);        /* bra8. */
 943                 else
 944                   abort ();
 945
 946                 /* Fix the relocation's type.  */
 947                 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
 948                                              R_H8_PCREL8);
 949
 950                 /* Delete two bytes of data.  */
 951                 if (!elf32_h8_relax_delete_bytes (abfd, sec,
 952                                                   irel->r_offset + 1, 2))
 953                   goto error_return;
 954
 955                 /* That will change things, so, we should relax again.
 956                    Note that this is not required, and it may be slow.  */
 957                 *again = TRUE;
 958               }
 959             break;
 960           }
 961
 962           /* Try to turn a 16-bit pc-relative branch into a 8-bit pc-relative
 963              branch.  */
 964         case R_H8_PCREL16:
 965           {
 966             bfd_vma value = symval + irel->r_addend;
 967             bfd_vma dot;
 968             bfd_vma gap;
 969
 970             /* Get the address of this instruction.  */
 971             dot = (sec->output_section->vma
 972                    + sec->output_offset
 973                    + irel->r_offset - 2);
 974
 975             gap = value - dot;
 976
 977             /* If the distance is within -126..+130 inclusive, then we can
 978                relax this jump.  +130 is valid since the target will move
 979                two bytes closer if we do relax this branch.  */
 980             if ((int) gap >= -126 && (int) gap <= 130)
 981               {
 982                 unsigned char code;
 983
 984                 /* Note that we've changed the relocs, section contents,
 985                    etc.  */
 986                 elf_section_data (sec)->relocs = internal_relocs;
 987                 elf_section_data (sec)->this_hdr.contents = contents;
 988                 symtab_hdr->contents = (unsigned char *) isymbuf;
 989
 990                 /* Get the opcode.  */
 991                 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
 992
 993                 if (code == 0x58)
 994                   {
 995                     /* bCC:16 -> bCC:8 */
 996                     /* Get the second byte of the original insn, which
 997                        contains the condition code.  */
 998                     code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
 999
1000                     /* Compute the first byte of the relaxed
1001                        instruction.  The original sequence 0x58 0xX0
1002                        is relaxed to 0x4X, where X represents the
1003                        condition code.  */
1004                     code &= 0xf0;
1005                     code >>= 4;
1006                     code |= 0x40;
1007                     bfd_put_8 (abfd, code, contents + irel->r_offset - 2); /* bCC:8.  */
1008                   }
1009                 else if (code == 0x5c)  /* bsr16.  */
1010                   /* This is bsr.  */
1011                   bfd_put_8 (abfd, 0x55, contents + irel->r_offset - 2);  /* bsr8.  */
1012                 else
1013                   /* Might be MOVSD.  */
1014                   break;
1015
1016                 /* Fix the relocation's type.  */
1017                 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1018                                              R_H8_PCREL8);
1019                 irel->r_offset--;
1020
1021                 /* Delete two bytes of data.  */
1022                 if (!elf32_h8_relax_delete_bytes (abfd, sec,
1023                                                   irel->r_offset + 1, 2))
1024                   goto error_return;
1025
1026                 /* That will change things, so, we should relax again.
1027                    Note that this is not required, and it may be slow.  */
1028                 *again = TRUE;
1029               }
1030             break;
1031           }
1032
1033           /* This is a 16-bit absolute address in one of the following
1034              instructions:
1035
1036              "band", "bclr", "biand", "bild", "bior", "bist", "bixor",
1037              "bld", "bnot", "bor", "bset", "bst", "btst", "bxor", and
1038              "mov.b"
1039
1040              We may relax this into an 8-bit absolute address if it's in
1041              the right range.  */
1042         case R_H8_DIR16A8:
1043           {
1044             bfd_vma value;
1045
1046             value = bfd_h8300_pad_address (abfd, symval + irel->r_addend);
1047             if (value >= 0xffffff00u)
1048               {
1049                 unsigned char code;
1050                 unsigned char temp_code;
1051
1052                 /* Note that we've changed the relocs, section contents,
1053                    etc.  */
1054                 elf_section_data (sec)->relocs = internal_relocs;
1055                 elf_section_data (sec)->this_hdr.contents = contents;
1056                 symtab_hdr->contents = (unsigned char *) isymbuf;
1057
1058                 /* Get the opcode.  */
1059                 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
1060
1061                 /* All instructions with R_H8_DIR16A8 start with
1062                    0x6a.  */
1063                 if (code != 0x6a)
1064                   abort ();
1065
1066                 temp_code = code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1067                 /* If this is a mov.b instruction, clear the lower
1068                    nibble, which contains the source/destination
1069                    register number.  */
1070                 if ((temp_code & 0x10) != 0x10)
1071                   temp_code &= 0xf0;
1072
1073                 switch (temp_code)
1074                   {
1075                   case 0x00:
1076                     /* This is mov.b @aa:16,Rd.  */
1077                     bfd_put_8 (abfd, (code & 0xf) | 0x20,
1078                                contents + irel->r_offset - 2);
1079                     break;
1080                   case 0x80:
1081                     /* This is mov.b Rs,@aa:16.  */
1082                     bfd_put_8 (abfd, (code & 0xf) | 0x30,
1083                                contents + irel->r_offset - 2);
1084                     break;
1085                   case 0x18:
1086                     /* This is a bit-maniputation instruction that
1087                        stores one bit into memory, one of "bclr",
1088                        "bist", "bnot", "bset", and "bst".  */
1089                     bfd_put_8 (abfd, 0x7f, contents + irel->r_offset - 2);
1090                     break;
1091                   case 0x10:
1092                     /* This is a bit-maniputation instruction that
1093                        loads one bit from memory, one of "band",
1094                        "biand", "bild", "bior", "bixor", "bld", "bor",
1095                        "btst", and "bxor".  */
1096                     bfd_put_8 (abfd, 0x7e, contents + irel->r_offset - 2);
1097                     break;
1098                   default:
1099                     abort ();
1100                   }
1101
1102                 /* Fix the relocation's type.  */
1103                 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1104                                              R_H8_DIR8);
1105
1106                 /* Move the relocation.  */
1107                 irel->r_offset--;
1108
1109                 /* Delete two bytes of data.  */
1110                 if (!elf32_h8_relax_delete_bytes (abfd, sec,
1111                                                   irel->r_offset + 1, 2))
1112                   goto error_return;
1113
1114                 /* That will change things, so, we should relax again.
1115                    Note that this is not required, and it may be slow.  */
1116                 *again = TRUE;
1117               }
1118             break;
1119           }
1120
1121           /* This is a 24-bit absolute address in one of the following
1122              instructions:
1123
1124              "band", "bclr", "biand", "bild", "bior", "bist", "bixor",
1125              "bld", "bnot", "bor", "bset", "bst", "btst", "bxor", and
1126              "mov.b"
1127
1128              We may relax this into an 8-bit absolute address if it's in
1129              the right range.  */
1130         case R_H8_DIR24A8:
1131           {
1132             bfd_vma value;
1133
1134             value = bfd_h8300_pad_address (abfd, symval + irel->r_addend);
1135             if (value >= 0xffffff00u)
1136               {
1137                 unsigned char code;
1138                 unsigned char temp_code;
1139
1140                 /* Note that we've changed the relocs, section contents,
1141                    etc.  */
1142                 elf_section_data (sec)->relocs = internal_relocs;
1143                 elf_section_data (sec)->this_hdr.contents = contents;
1144                 symtab_hdr->contents = (unsigned char *) isymbuf;
1145
1146                 /* Get the opcode.  */
1147                 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
1148
1149                 /* All instructions with R_H8_DIR24A8 start with
1150                    0x6a.  */
1151                 if (code != 0x6a)
1152                   abort ();
1153
1154                 temp_code = code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1155
1156                 /* If this is a mov.b instruction, clear the lower
1157                    nibble, which contains the source/destination
1158                    register number.  */
1159                 if ((temp_code & 0x30) != 0x30)
1160                   temp_code &= 0xf0;
1161
1162                 switch (temp_code)
1163                   {
1164                   case 0x20:
1165                     /* This is mov.b @aa:24/32,Rd.  */
1166                     bfd_put_8 (abfd, (code & 0xf) | 0x20,
1167                                contents + irel->r_offset - 2);
1168                     break;
1169                   case 0xa0:
1170                     /* This is mov.b Rs,@aa:24/32.  */
1171                     bfd_put_8 (abfd, (code & 0xf) | 0x30,
1172                                contents + irel->r_offset - 2);
1173                     break;
1174                   case 0x38:
1175                     /* This is a bit-maniputation instruction that
1176                        stores one bit into memory, one of "bclr",
1177                        "bist", "bnot", "bset", and "bst".  */
1178                     bfd_put_8 (abfd, 0x7f, contents + irel->r_offset - 2);
1179                     break;
1180                   case 0x30:
1181                     /* This is a bit-maniputation instruction that
1182                        loads one bit from memory, one of "band",
1183                        "biand", "bild", "bior", "bixor", "bld", "bor",
1184                        "btst", and "bxor".  */
1185                     bfd_put_8 (abfd, 0x7e, contents + irel->r_offset - 2);
1186                     break;
1187                   default:
1188                     abort();
1189                   }
1190
1191                 /* Fix the relocation's type.  */
1192                 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1193                                              R_H8_DIR8);
1194                 irel->r_offset--;
1195
1196                 /* Delete four bytes of data.  */
1197                 if (!elf32_h8_relax_delete_bytes (abfd, sec,
1198                                                   irel->r_offset + 1, 4))
1199                   goto error_return;
1200
1201                 /* That will change things, so, we should relax again.
1202                    Note that this is not required, and it may be slow.  */
1203                 *again = TRUE;
1204                 break;
1205               }
1206           }
1207
1208           /* Fall through.  */
1209
1210           /* This is a 24-/32-bit absolute address in one of the
1211              following instructions:
1212
1213              "band", "bclr", "biand", "bild", "bior", "bist",
1214              "bixor", "bld", "bnot", "bor", "bset", "bst", "btst",
1215              "bxor", "ldc.w", "stc.w" and "mov.[bwl]"
1216
1217              We may relax this into an 16-bit absolute address if it's
1218              in the right range.  */
1219         case R_H8_DIR32A16:
1220           {
1221             bfd_vma value;
1222
1223             value = bfd_h8300_pad_address (abfd, symval + irel->r_addend);
1224             if (value <= 0x7fff || value >= 0xffff8000u)
1225               {
1226                 unsigned char code;
1227                 unsigned char op0, op1, op2, op3;
1228                 unsigned char *op_ptr;
1229
1230                 /* Note that we've changed the relocs, section contents,
1231                    etc.  */
1232                 elf_section_data (sec)->relocs = internal_relocs;
1233                 elf_section_data (sec)->this_hdr.contents = contents;
1234                 symtab_hdr->contents = (unsigned char *) isymbuf;
1235
1236                 if (irel->r_offset >= 4)
1237                   {
1238                     /* Check for 4-byte MOVA relaxation (SH-specific).  */
1239                     int second_reloc = 0;
1240
1241                     op_ptr = contents + irel->r_offset - 4;
1242
1243                     if (last_reloc)
1244                       {
1245                         arelent bfd_reloc;
1246                         reloc_howto_type *h;
1247                         bfd_vma last_reloc_size;
1248
1249                         elf32_h8_info_to_howto (abfd, &bfd_reloc, last_reloc);
1250                         h = bfd_reloc.howto;
1251                         last_reloc_size = 1 << h->size;
1252                         if (last_reloc->r_offset + last_reloc_size
1253                             == irel->r_offset)
1254                           {
1255                             op_ptr -= last_reloc_size;
1256                             second_reloc = 1;
1257                           }
1258                       }
1259
1260                     if (irel + 1 < irelend)
1261                       {
1262                         Elf_Internal_Rela *next_reloc = irel + 1;
1263                         arelent bfd_reloc;
1264                         reloc_howto_type *h;
1265                         bfd_vma next_reloc_size;
1266
1267                         elf32_h8_info_to_howto (abfd, &bfd_reloc, next_reloc);
1268                         h = bfd_reloc.howto;
1269                         next_reloc_size = 1 << h->size;
1270                         if (next_reloc->r_offset + next_reloc_size
1271                             == irel->r_offset)
1272                           {
1273                             op_ptr -= next_reloc_size;
1274                             second_reloc = 1;
1275                           }
1276                       }
1277
1278                     op0 = bfd_get_8 (abfd, op_ptr + 0);
1279                     op1 = bfd_get_8 (abfd, op_ptr + 1);
1280                     op2 = bfd_get_8 (abfd, op_ptr + 2);
1281                     op3 = bfd_get_8 (abfd, op_ptr + 3);
1282
1283                     if (op0 == 0x01
1284                         && (op1 & 0xdf) == 0x5f
1285                         && (op2 & 0x40) == 0x40
1286                         && (op3 & 0x80) == 0x80)
1287                       {
1288                         if ((op2 & 0x08) == 0)
1289                           second_reloc = 1;
1290
1291                         if (second_reloc)
1292                           {
1293                             op3 &= ~0x08;
1294                             bfd_put_8 (abfd, op3, op_ptr + 3);
1295                           }
1296                         else
1297                           {
1298                             op2 &= ~0x08;
1299                             bfd_put_8 (abfd, op2, op_ptr + 2);
1300                           }
1301                         goto r_h8_dir32a16_common;
1302                       }
1303                   }
1304
1305                 /* Now check for short version of MOVA.  (SH-specific) */
1306                 op_ptr = contents + irel->r_offset - 2;
1307                 op0 = bfd_get_8 (abfd, op_ptr + 0);
1308                 op1 = bfd_get_8 (abfd, op_ptr + 1);
1309
1310                 if (op0 == 0x7a
1311                     && (op1 & 0x88) == 0x80)
1312                   {
1313                     op1 |= 0x08;
1314                     bfd_put_8 (abfd, op1, op_ptr + 1);
1315                     goto r_h8_dir32a16_common;
1316                   }
1317
1318                 /* Get the opcode.  */
1319                 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1320
1321                 /* Fix the opcode.  For all the instructions that
1322                    belong to this relaxation, we simply need to turn
1323                    off bit 0x20 in the previous byte.  */
1324                 code &= ~0x20;
1325
1326                 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
1327
1328               r_h8_dir32a16_common:
1329                 /* Fix the relocation's type.  */
1330                 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1331                                              R_H8_DIR16);
1332
1333                 /* Delete two bytes of data.  */
1334                 if (!elf32_h8_relax_delete_bytes (abfd, sec,
1335                                                   irel->r_offset + 1, 2))
1336                   goto error_return;
1337
1338                 /* That will change things, so, we should relax again.
1339                    Note that this is not required, and it may be slow.  */
1340                 *again = TRUE;
1341               }
1342             break;      /* case R_H8_DIR32A16 */
1343           }
1344
1345         case R_H8_DISP32A16:
1346           /* mov.[bwl] @(displ:24/32+ERx) -> mov.[bwl] @(displ:16+ERx)  4 bytes
1347              It is assured that instruction uses at least 4 bytes opcode before
1348              reloc entry addressing mode "register indirect with displacement"
1349              relaxing options (all saving 4 bytes):
1350              0x78 0sss0000 0x6A 0010dddd disp:32  mov.b @(d:32,ERs),Rd  ->
1351              0x6E 0sssdddd disp:16  mov.b @(d:16,ERs),Rd
1352              0x78 0sss0000 0x6B 0010dddd disp:32  mov.w @(d:32,ERs),Rd  ->
1353              0x6F 0sssdddd disp:16  mov.w @(d:16,ERs),Rd
1354              0x01 0x00 0x78 0sss0000 0x6B 00100ddd disp:32  mov.l @(d:32,ERs),ERd ->
1355              0x01 0x00 0x6F 0sss0ddd disp:16  mov.l @(d:16,ERs),ERd
1356
1357              0x78 0ddd0000 0x6A 1010ssss disp:32  mov.b Rs,@(d:32,ERd)  ->
1358              0x6E 1dddssss disp:16  mov.b Rs,@(d:16,ERd)
1359              0x78 0ddd0000 0x6B 1010ssss disp:32  mov.w Rs,@(d:32,ERd)  ->
1360              0x6F 1dddssss disp:16  mov.w Rs,@(d:16,ERd)
1361              0x01 0x00 0x78 xddd0000 0x6B 10100sss disp:32  mov.l ERs,@(d:32,ERd) ->
1362              0x01 0x00 0x6F 1ddd0sss disp:16  mov.l ERs,@(d:16,ERd)
1363              mov.l prefix 0x01 0x00 can be left as is and mov.l handled same
1364              as mov.w/  */
1365           {
1366             bfd_vma value;
1367
1368             value = bfd_h8300_pad_address (abfd, symval + irel->r_addend);
1369             if (value <= 0x7fff || value >= 0xffff8000u)
1370               {
1371                 unsigned char op0, op1, op2, op3, op0n, op1n;
1372                 int relax = 0;
1373
1374                 /* Note that we've changed the relocs, section contents,
1375                    etc.  */
1376                 elf_section_data (sec)->relocs = internal_relocs;
1377                 elf_section_data (sec)->this_hdr.contents = contents;
1378                 symtab_hdr->contents = (unsigned char *) isymbuf;
1379
1380                 if (irel->r_offset >= 4)
1381                   {
1382                     op0 = bfd_get_8 (abfd, contents + irel->r_offset - 4);
1383                     op1 = bfd_get_8 (abfd, contents + irel->r_offset - 3);
1384                     op2 = bfd_get_8 (abfd, contents + irel->r_offset - 2);
1385                     op3 = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1386
1387                     if (op0 == 0x78)
1388                       {
1389                         switch(op2)
1390                           {
1391                           case 0x6A:
1392                             if ((op1 & 0x8F) == 0x00 && (op3 & 0x70) == 0x20)
1393                               {
1394                                 /* mov.b.  */
1395                                 op0n = 0x6E;
1396                                 relax = 1;
1397                               }
1398                             break;
1399                           case 0x6B:
1400                             if ((op1 & 0x0F) == 0x00 && (op3 & 0x70) == 0x20)
1401                               {
1402                                 /* mov.w/l.  */
1403                                 op0n = 0x6F;
1404                                 relax = 1;
1405                               }
1406                             break;
1407                           default:
1408                             break;
1409                           }
1410                       }
1411                   }
1412
1413                 if (relax)
1414                   {
1415                     op1n = (op3 & 0x8F) | (op1 & 0x70);
1416                     bfd_put_8 (abfd, op0n, contents + irel->r_offset - 4);
1417                     bfd_put_8 (abfd, op1n, contents + irel->r_offset - 3);
1418
1419                     /* Fix the relocation's type.  */
1420                     irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_H8_DIR16);
1421                     irel->r_offset -= 2;
1422
1423                     /* Delete four bytes of data.  */
1424                     if (!elf32_h8_relax_delete_bytes (abfd, sec, irel->r_offset + 2, 4))
1425                       goto error_return;
1426
1427                     /* That will change things, so, we should relax again.
1428                        Note that this is not required, and it may be slow.  */
1429                     *again = TRUE;
1430                   }
1431               }
1432           }
1433           break;
1434
1435         default:
1436           break;
1437         }
1438     }
1439
1440   if (isymbuf != NULL
1441       && symtab_hdr->contents != (unsigned char *) isymbuf)
1442     {
1443       if (! link_info->keep_memory)
1444         free (isymbuf);
1445       else
1446         symtab_hdr->contents = (unsigned char *) isymbuf;
1447     }
1448
1449   if (contents != NULL
1450       && elf_section_data (sec)->this_hdr.contents != contents)
1451     {
1452       if (! link_info->keep_memory)
1453         free (contents);
1454       else
1455         {
1456           /* Cache the section contents for elf_link_input_bfd.  */
1457           elf_section_data (sec)->this_hdr.contents = contents;
1458         }
1459     }
1460
1461   if (internal_relocs != NULL
1462       && elf_section_data (sec)->relocs != internal_relocs)
1463     free (internal_relocs);
1464
1465   return TRUE;
1466
1467  error_return:
1468   if (isymbuf != NULL
1469       && symtab_hdr->contents != (unsigned char *) isymbuf)
1470     free (isymbuf);
1471   if (contents != NULL
1472       && elf_section_data (sec)->this_hdr.contents != contents)
1473     free (contents);
1474   if (internal_relocs != NULL
1475       && elf_section_data (sec)->relocs != internal_relocs)
1476     free (internal_relocs);
1477   return FALSE;
1478 }
1479
1480 /* Delete some bytes from a section while relaxing.  */
1481
1482 static bfd_boolean
1483 elf32_h8_relax_delete_bytes (bfd *abfd, asection *sec, bfd_vma addr, int count)
1484 {
1485   Elf_Internal_Shdr *symtab_hdr;
1486   unsigned int sec_shndx;
1487   bfd_byte *contents;
1488   Elf_Internal_Rela *irel, *irelend;
1489   Elf_Internal_Sym *isym;
1490   Elf_Internal_Sym *isymend;
1491   bfd_vma toaddr;
1492   struct elf_link_hash_entry **sym_hashes;
1493   struct elf_link_hash_entry **end_hashes;
1494   unsigned int symcount;
1495
1496   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1497
1498   contents = elf_section_data (sec)->this_hdr.contents;
1499
1500   toaddr = sec->size;
1501
1502   irel = elf_section_data (sec)->relocs;
1503   irelend = irel + sec->reloc_count;
1504
1505   /* Actually delete the bytes.  */
1506   memmove (contents + addr, contents + addr + count,
1507            (size_t) (toaddr - addr - count));
1508   sec->size -= count;
1509
1510   /* Adjust all the relocs.  */
1511   for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1512     {
1513       /* Get the new reloc address.  */
1514       if ((irel->r_offset > addr
1515            && irel->r_offset <= toaddr))
1516         irel->r_offset -= count;
1517     }
1518
1519   /* Adjust the local symbols defined in this section.  */
1520   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1521   isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1522   isymend = isym + symtab_hdr->sh_info;
1523   for (; isym < isymend; isym++)
1524     {
1525       if (isym->st_shndx == sec_shndx
1526           && isym->st_value > addr
1527           && isym->st_value <= toaddr)
1528         isym->st_value -= count;
1529     }
1530
1531   /* Now adjust the global symbols defined in this section.  */
1532   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1533               - symtab_hdr->sh_info);
1534   sym_hashes = elf_sym_hashes (abfd);
1535   end_hashes = sym_hashes + symcount;
1536   for (; sym_hashes < end_hashes; sym_hashes++)
1537     {
1538       struct elf_link_hash_entry *sym_hash = *sym_hashes;
1539
1540       if ((sym_hash->root.type == bfd_link_hash_defined
1541            || sym_hash->root.type == bfd_link_hash_defweak)
1542           && sym_hash->root.u.def.section == sec
1543           && sym_hash->root.u.def.value > addr
1544           && sym_hash->root.u.def.value <= toaddr)
1545         sym_hash->root.u.def.value -= count;
1546     }
1547
1548   return TRUE;
1549 }
1550
1551 /* Return TRUE if a symbol exists at the given address, else return
1552    FALSE.  */
1553 static bfd_boolean
1554 elf32_h8_symbol_address_p (bfd *abfd, asection *sec, bfd_vma addr)
1555 {
1556   Elf_Internal_Shdr *symtab_hdr;
1557   unsigned int sec_shndx;
1558   Elf_Internal_Sym *isym;
1559   Elf_Internal_Sym *isymend;
1560   struct elf_link_hash_entry **sym_hashes;
1561   struct elf_link_hash_entry **end_hashes;
1562   unsigned int symcount;
1563
1564   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1565
1566   /* Examine all the symbols.  */
1567   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1568   isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1569   isymend = isym + symtab_hdr->sh_info;
1570   for (; isym < isymend; isym++)
1571     {
1572       if (isym->st_shndx == sec_shndx
1573           && isym->st_value == addr)
1574         return TRUE;
1575     }
1576
1577   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1578               - symtab_hdr->sh_info);
1579   sym_hashes = elf_sym_hashes (abfd);
1580   end_hashes = sym_hashes + symcount;
1581   for (; sym_hashes < end_hashes; sym_hashes++)
1582     {
1583       struct elf_link_hash_entry *sym_hash = *sym_hashes;
1584       if ((sym_hash->root.type == bfd_link_hash_defined
1585            || sym_hash->root.type == bfd_link_hash_defweak)
1586           && sym_hash->root.u.def.section == sec
1587           && sym_hash->root.u.def.value == addr)
1588         return TRUE;
1589     }
1590
1591   return FALSE;
1592 }
1593
1594 /* This is a version of bfd_generic_get_relocated_section_contents
1595    which uses elf32_h8_relocate_section.  */
1596
1597 static bfd_byte *
1598 elf32_h8_get_relocated_section_contents (bfd *output_bfd,
1599                                          struct bfd_link_info *link_info,
1600                                          struct bfd_link_order *link_order,
1601                                          bfd_byte *data,
1602                                          bfd_boolean relocatable,
1603                                          asymbol **symbols)
1604 {
1605   Elf_Internal_Shdr *symtab_hdr;
1606   asection *input_section = link_order->u.indirect.section;
1607   bfd *input_bfd = input_section->owner;
1608   asection **sections = NULL;
1609   Elf_Internal_Rela *internal_relocs = NULL;
1610   Elf_Internal_Sym *isymbuf = NULL;
1611
1612   /* We only need to handle the case of relaxing, or of having a
1613      particular set of section contents, specially.  */
1614   if (relocatable
1615       || elf_section_data (input_section)->this_hdr.contents == NULL)
1616     return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
1617                                                        link_order, data,
1618                                                        relocatable,
1619                                                        symbols);
1620
1621   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1622
1623   memcpy (data, elf_section_data (input_section)->this_hdr.contents,
1624           (size_t) input_section->size);
1625
1626   if ((input_section->flags & SEC_RELOC) != 0
1627       && input_section->reloc_count > 0)
1628     {
1629       asection **secpp;
1630       Elf_Internal_Sym *isym, *isymend;
1631       bfd_size_type amt;
1632
1633       internal_relocs = (_bfd_elf_link_read_relocs
1634                          (input_bfd, input_section, NULL,
1635                           (Elf_Internal_Rela *) NULL, FALSE));
1636       if (internal_relocs == NULL)
1637         goto error_return;
1638
1639       if (symtab_hdr->sh_info != 0)
1640         {
1641           isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1642           if (isymbuf == NULL)
1643             isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
1644                                             symtab_hdr->sh_info, 0,
1645                                             NULL, NULL, NULL);
1646           if (isymbuf == NULL)
1647             goto error_return;
1648         }
1649
1650       amt = symtab_hdr->sh_info;
1651       amt *= sizeof (asection *);
1652       sections = (asection **) bfd_malloc (amt);
1653       if (sections == NULL && amt != 0)
1654         goto error_return;
1655
1656       isymend = isymbuf + symtab_hdr->sh_info;
1657       for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
1658         {
1659           asection *isec;
1660
1661           if (isym->st_shndx == SHN_UNDEF)
1662             isec = bfd_und_section_ptr;
1663           else if (isym->st_shndx == SHN_ABS)
1664             isec = bfd_abs_section_ptr;
1665           else if (isym->st_shndx == SHN_COMMON)
1666             isec = bfd_com_section_ptr;
1667           else
1668             isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
1669
1670           *secpp = isec;
1671         }
1672
1673       if (! elf32_h8_relocate_section (output_bfd, link_info, input_bfd,
1674                                        input_section, data, internal_relocs,
1675                                        isymbuf, sections))
1676         goto error_return;
1677
1678       if (sections != NULL)
1679         free (sections);
1680       if (isymbuf != NULL
1681           && symtab_hdr->contents != (unsigned char *) isymbuf)
1682         free (isymbuf);
1683       if (elf_section_data (input_section)->relocs != internal_relocs)
1684         free (internal_relocs);
1685     }
1686
1687   return data;
1688
1689  error_return:
1690   if (sections != NULL)
1691     free (sections);
1692   if (isymbuf != NULL
1693       && symtab_hdr->contents != (unsigned char *) isymbuf)
1694     free (isymbuf);
1695   if (internal_relocs != NULL
1696       && elf_section_data (input_section)->relocs != internal_relocs)
1697     free (internal_relocs);
1698   return NULL;
1699 }
1700
1701
1702 #define TARGET_BIG_SYM                  h8300_elf32_vec
1703 #define TARGET_BIG_NAME                 "elf32-h8300"
1704 #define ELF_ARCH                        bfd_arch_h8300
1705 #define ELF_MACHINE_CODE                EM_H8_300
1706 #define ELF_MAXPAGESIZE                 0x1
1707 #define bfd_elf32_bfd_reloc_type_lookup elf32_h8_reloc_type_lookup
1708 #define bfd_elf32_bfd_reloc_name_lookup elf32_h8_reloc_name_lookup
1709 #define elf_info_to_howto               elf32_h8_info_to_howto
1710 #define elf_info_to_howto_rel           elf32_h8_info_to_howto_rel
1711
1712 /* So we can set/examine bits in e_flags to get the specific
1713    H8 architecture in use.  */
1714 #define elf_backend_final_write_processing \
1715   elf32_h8_final_write_processing
1716 #define elf_backend_object_p \
1717   elf32_h8_object_p
1718 #define bfd_elf32_bfd_merge_private_bfd_data \
1719   elf32_h8_merge_private_bfd_data
1720
1721 /* ??? when elf_backend_relocate_section is not defined, elf32-target.h
1722    defaults to using _bfd_generic_link_hash_table_create, but
1723    bfd_elf_size_dynamic_sections uses
1724    dynobj = elf_hash_table (info)->dynobj;
1725    and thus requires an elf hash table.  */
1726 #define bfd_elf32_bfd_link_hash_table_create _bfd_elf_link_hash_table_create
1727
1728 /* Use an H8 specific linker, not the ELF generic linker.  */
1729 #define elf_backend_relocate_section elf32_h8_relocate_section
1730 #define elf_backend_rela_normal         1
1731 #define elf_backend_can_gc_sections     1
1732
1733 /* And relaxing stuff.  */
1734 #define bfd_elf32_bfd_relax_section     elf32_h8_relax_section
1735 #define bfd_elf32_bfd_get_relocated_section_contents \
1736                                 elf32_h8_get_relocated_section_contents
1737
1738 #define elf_symbol_leading_char '_'
1739
1740 #include "elf32-target.h"
1741
1742 #undef  TARGET_BIG_SYM
1743 #define TARGET_BIG_SYM                  h8300_elf32_linux_vec
1744 #undef  TARGET_BIG_NAME
1745 #define TARGET_BIG_NAME                 "elf32-h8300-linux"
1746 #undef  elf_symbol_leading_char
1747 #define elf32_bed                       elf32_h8300_linux_bed
1748
1749 #include "elf32-target.h"