bfd/elf32-h8300.c

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