bfd/elf32-h8300.c

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