bfd/elf32-h8300.c

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