bfd/elf32-h8300.c

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