bfd/coff-h8300.c

   1 /* BFD back-end for Renesas H8/300 COFF binaries.
   2    Copyright (C) 1990-2015 Free Software Foundation, Inc.
   3    Written by Steve Chamberlain, <sac@cygnus.com>.
   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 3 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,
  20    MA 02110-1301, USA.  */
  21
  22 #include "sysdep.h"
  23 #include "bfd.h"
  24 #include "libbfd.h"
  25 #include "bfdlink.h"
  26 #include "genlink.h"
  27 #include "coff/h8300.h"
  28 #include "coff/internal.h"
  29 #include "libcoff.h"
  30 #include "libiberty.h"
  31
  32 #define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (1)
  33
  34 /* We derive a hash table from the basic BFD hash table to
  35    hold entries in the function vector.  Aside from the
  36    info stored by the basic hash table, we need the offset
  37    of a particular entry within the hash table as well as
  38    the offset where we'll add the next entry.  */
  39
  40 struct funcvec_hash_entry
  41   {
  42     /* The basic hash table entry.  */
  43     struct bfd_hash_entry root;
  44
  45     /* The offset within the vectors section where
  46        this entry lives.  */
  47     bfd_vma offset;
  48   };
  49
  50 struct funcvec_hash_table
  51   {
  52     /* The basic hash table.  */
  53     struct bfd_hash_table root;
  54
  55     bfd *abfd;
  56
  57     /* Offset at which we'll add the next entry.  */
  58     unsigned int offset;
  59   };
  60
  61
  62 /* To lookup a value in the function vector hash table.  */
  63 #define funcvec_hash_lookup(table, string, create, copy) \
  64   ((struct funcvec_hash_entry *) \
  65    bfd_hash_lookup (&(table)->root, (string), (create), (copy)))
  66
  67 /* The derived h8300 COFF linker table.  Note it's derived from
  68    the generic linker hash table, not the COFF backend linker hash
  69    table!  We use this to attach additional data structures we
  70    need while linking on the h8300.  */
  71 struct h8300_coff_link_hash_table {
  72   /* The main hash table.  */
  73   struct generic_link_hash_table root;
  74
  75   /* Section for the vectors table.  This gets attached to a
  76      random input bfd, we keep it here for easy access.  */
  77   asection *vectors_sec;
  78
  79   /* Hash table of the functions we need to enter into the function
  80      vector.  */
  81   struct funcvec_hash_table *funcvec_hash_table;
  82 };
  83
  84 static struct bfd_link_hash_table *h8300_coff_link_hash_table_create (bfd *);
  85
  86 /* Get the H8/300 COFF linker hash table from a link_info structure.  */
  87
  88 #define h8300_coff_hash_table(p) \
  89   ((struct h8300_coff_link_hash_table *) ((coff_hash_table (p))))
  90
  91 /* Initialize fields within a funcvec hash table entry.  Called whenever
  92    a new entry is added to the funcvec hash table.  */
  93
  94 static struct bfd_hash_entry *
  95 funcvec_hash_newfunc (struct bfd_hash_entry *entry,
  96                       struct bfd_hash_table *gen_table,
  97                       const char *string)
  98 {
  99   struct funcvec_hash_entry *ret;
 100   struct funcvec_hash_table *table;
 101
 102   ret = (struct funcvec_hash_entry *) entry;
 103   table = (struct funcvec_hash_table *) gen_table;
 104
 105   /* Allocate the structure if it has not already been allocated by a
 106      subclass.  */
 107   if (ret == NULL)
 108     ret = ((struct funcvec_hash_entry *)
 109            bfd_hash_allocate (gen_table,
 110                               sizeof (struct funcvec_hash_entry)));
 111   if (ret == NULL)
 112     return NULL;
 113
 114   /* Call the allocation method of the superclass.  */
 115   ret = ((struct funcvec_hash_entry *)
 116          bfd_hash_newfunc ((struct bfd_hash_entry *) ret, gen_table, string));
 117
 118   if (ret == NULL)
 119     return NULL;
 120
 121   /* Note where this entry will reside in the function vector table.  */
 122   ret->offset = table->offset;
 123
 124   /* Bump the offset at which we store entries in the function
 125      vector.  We'd like to bump up the size of the vectors section,
 126      but it's not easily available here.  */
 127  switch (bfd_get_mach (table->abfd))
 128    {
 129    case bfd_mach_h8300:
 130    case bfd_mach_h8300hn:
 131    case bfd_mach_h8300sn:
 132      table->offset += 2;
 133      break;
 134    case bfd_mach_h8300h:
 135    case bfd_mach_h8300s:
 136      table->offset += 4;
 137      break;
 138    default:
 139      return NULL;
 140    }
 141
 142   /* Everything went OK.  */
 143   return (struct bfd_hash_entry *) ret;
 144 }
 145
 146 /* Initialize the function vector hash table.  */
 147
 148 static bfd_boolean
 149 funcvec_hash_table_init (struct funcvec_hash_table *table,
 150                          bfd *abfd,
 151                          struct bfd_hash_entry *(*newfunc)
 152                            (struct bfd_hash_entry *,
 153                             struct bfd_hash_table *,
 154                             const char *),
 155                          unsigned int entsize)
 156 {
 157   /* Initialize our local fields, then call the generic initialization
 158      routine.  */
 159   table->offset = 0;
 160   table->abfd = abfd;
 161   return (bfd_hash_table_init (&table->root, newfunc, entsize));
 162 }
 163
 164 /* Create the derived linker hash table.  We use a derived hash table
 165    basically to hold "static" information during an H8/300 coff link
 166    without using static variables.  */
 167
 168 static struct bfd_link_hash_table *
 169 h8300_coff_link_hash_table_create (bfd *abfd)
 170 {
 171   struct h8300_coff_link_hash_table *ret;
 172   bfd_size_type amt = sizeof (struct h8300_coff_link_hash_table);
 173
 174   ret = (struct h8300_coff_link_hash_table *) bfd_zmalloc (amt);
 175   if (ret == NULL)
 176     return NULL;
 177   if (!_bfd_link_hash_table_init (&ret->root.root, abfd,
 178                                   _bfd_generic_link_hash_newfunc,
 179                                   sizeof (struct generic_link_hash_entry)))
 180     {
 181       free (ret);
 182       return NULL;
 183     }
 184
 185   return &ret->root.root;
 186 }
 187
 188 /* Special handling for H8/300 relocs.
 189    We only come here for pcrel stuff and return normally if not an -r link.
 190    When doing -r, we can't do any arithmetic for the pcrel stuff, because
 191    the code in reloc.c assumes that we can manipulate the targets of
 192    the pcrel branches.  This isn't so, since the H8/300 can do relaxing,
 193    which means that the gap after the instruction may not be enough to
 194    contain the offset required for the branch, so we have to use only
 195    the addend until the final link.  */
 196
 197 static bfd_reloc_status_type
 198 special (bfd *      abfd ATTRIBUTE_UNUSED,
 199          arelent *  reloc_entry ATTRIBUTE_UNUSED,
 200          asymbol *  symbol ATTRIBUTE_UNUSED,
 201          void *     data ATTRIBUTE_UNUSED,
 202          asection * input_section ATTRIBUTE_UNUSED,
 203          bfd *      output_bfd,
 204          char **    error_message ATTRIBUTE_UNUSED)
 205 {
 206   if (output_bfd == (bfd *) NULL)
 207     return bfd_reloc_continue;
 208
 209   /* Adjust the reloc address to that in the output section.  */
 210   reloc_entry->address += input_section->output_offset;
 211   return bfd_reloc_ok;
 212 }
 213
 214 static reloc_howto_type howto_table[] =
 215 {
 216   HOWTO (R_RELBYTE, 0, 0, 8, FALSE, 0, complain_overflow_bitfield, special, "8", FALSE, 0x000000ff, 0x000000ff, FALSE),
 217   HOWTO (R_RELWORD, 0, 1, 16, FALSE, 0, complain_overflow_bitfield, special, "16", FALSE, 0x0000ffff, 0x0000ffff, FALSE),
 218   HOWTO (R_RELLONG, 0, 2, 32, FALSE, 0, complain_overflow_bitfield, special, "32", FALSE, 0xffffffff, 0xffffffff, FALSE),
 219   HOWTO (R_PCRBYTE, 0, 0, 8, TRUE, 0, complain_overflow_signed, special, "DISP8", FALSE, 0x000000ff, 0x000000ff, TRUE),
 220   HOWTO (R_PCRWORD, 0, 1, 16, TRUE, 0, complain_overflow_signed, special, "DISP16", FALSE, 0x0000ffff, 0x0000ffff, TRUE),
 221   HOWTO (R_PCRLONG, 0, 2, 32, TRUE, 0, complain_overflow_signed, special, "DISP32", FALSE, 0xffffffff, 0xffffffff, TRUE),
 222   HOWTO (R_MOV16B1, 0, 1, 16, FALSE, 0, complain_overflow_bitfield, special, "relaxable mov.b:16", FALSE, 0x0000ffff, 0x0000ffff, FALSE),
 223   HOWTO (R_MOV16B2, 0, 1, 8, FALSE, 0, complain_overflow_bitfield, special, "relaxed mov.b:16", FALSE, 0x000000ff, 0x000000ff, FALSE),
 224   HOWTO (R_JMP1, 0, 1, 16, FALSE, 0, complain_overflow_bitfield, special, "16/pcrel", FALSE, 0x0000ffff, 0x0000ffff, FALSE),
 225   HOWTO (R_JMP2, 0, 0, 8, FALSE, 0, complain_overflow_bitfield, special, "pcrecl/16", FALSE, 0x000000ff, 0x000000ff, FALSE),
 226   HOWTO (R_JMPL1, 0, 2, 32, FALSE, 0, complain_overflow_bitfield, special, "24/pcrell", FALSE, 0x00ffffff, 0x00ffffff, FALSE),
 227   HOWTO (R_JMPL2, 0, 0, 8, FALSE, 0, complain_overflow_bitfield, special, "pc8/24", FALSE, 0x000000ff, 0x000000ff, FALSE),
 228   HOWTO (R_MOV24B1, 0, 1, 32, FALSE, 0, complain_overflow_bitfield, special, "relaxable mov.b:24", FALSE, 0xffffffff, 0xffffffff, FALSE),
 229   HOWTO (R_MOV24B2, 0, 1, 8, FALSE, 0, complain_overflow_bitfield, special, "relaxed mov.b:24", FALSE, 0x0000ffff, 0x0000ffff, FALSE),
 230
 231   /* An indirect reference to a function.  This causes the function's address
 232      to be added to the function vector in lo-mem and puts the address of
 233      the function vector's entry in the jsr instruction.  */
 234   HOWTO (R_MEM_INDIRECT, 0, 0, 8, FALSE, 0, complain_overflow_bitfield, special, "8/indirect", FALSE, 0x000000ff, 0x000000ff, FALSE),
 235
 236   /* Internal reloc for relaxing.  This is created when a 16-bit pc-relative
 237      branch is turned into an 8-bit pc-relative branch.  */
 238   HOWTO (R_PCRWORD_B, 0, 0, 8, TRUE, 0, complain_overflow_bitfield, special, "relaxed bCC:16", FALSE, 0x000000ff, 0x000000ff, FALSE),
 239
 240   HOWTO (R_MOVL1, 0, 2, 32, FALSE, 0, complain_overflow_bitfield,special, "32/24 relaxable move", FALSE, 0xffffffff, 0xffffffff, FALSE),
 241
 242   HOWTO (R_MOVL2, 0, 1, 16, FALSE, 0, complain_overflow_bitfield, special, "32/24 relaxed move", FALSE, 0x0000ffff, 0x0000ffff, FALSE),
 243
 244   HOWTO (R_BCC_INV, 0, 0, 8, TRUE, 0, complain_overflow_signed, special, "DISP8 inverted", FALSE, 0x000000ff, 0x000000ff, TRUE),
 245
 246   HOWTO (R_JMP_DEL, 0, 0, 8, TRUE, 0, complain_overflow_signed, special, "Deleted jump", FALSE, 0x000000ff, 0x000000ff, TRUE),
 247 };
 248
 249 /* Turn a howto into a reloc number.  */
 250
 251 #define SELECT_RELOC(x,howto) \
 252   { x.r_type = select_reloc (howto); }
 253
 254 #define BADMAG(x) (H8300BADMAG (x) && H8300HBADMAG (x) && H8300SBADMAG (x) \
 255                                    && H8300HNBADMAG(x) && H8300SNBADMAG(x))
 256 #define H8300 1                 /* Customize coffcode.h  */
 257 #define __A_MAGIC_SET__
 258
 259 /* Code to swap in the reloc.  */
 260 #define SWAP_IN_RELOC_OFFSET    H_GET_32
 261 #define SWAP_OUT_RELOC_OFFSET   H_PUT_32
 262 #define SWAP_OUT_RELOC_EXTRA(abfd, src, dst) \
 263   dst->r_stuff[0] = 'S'; \
 264   dst->r_stuff[1] = 'C';
 265
 266 static int
 267 select_reloc (reloc_howto_type *howto)
 268 {
 269   return howto->type;
 270 }
 271
 272 /* Code to turn a r_type into a howto ptr, uses the above howto table.  */
 273
 274 static void
 275 rtype2howto (arelent *internal, struct internal_reloc *dst)
 276 {
 277   switch (dst->r_type)
 278     {
 279     case R_RELBYTE:
 280       internal->howto = howto_table + 0;
 281       break;
 282     case R_RELWORD:
 283       internal->howto = howto_table + 1;
 284       break;
 285     case R_RELLONG:
 286       internal->howto = howto_table + 2;
 287       break;
 288     case R_PCRBYTE:
 289       internal->howto = howto_table + 3;
 290       break;
 291     case R_PCRWORD:
 292       internal->howto = howto_table + 4;
 293       break;
 294     case R_PCRLONG:
 295       internal->howto = howto_table + 5;
 296       break;
 297     case R_MOV16B1:
 298       internal->howto = howto_table + 6;
 299       break;
 300     case R_MOV16B2:
 301       internal->howto = howto_table + 7;
 302       break;
 303     case R_JMP1:
 304       internal->howto = howto_table + 8;
 305       break;
 306     case R_JMP2:
 307       internal->howto = howto_table + 9;
 308       break;
 309     case R_JMPL1:
 310       internal->howto = howto_table + 10;
 311       break;
 312     case R_JMPL2:
 313       internal->howto = howto_table + 11;
 314       break;
 315     case R_MOV24B1:
 316       internal->howto = howto_table + 12;
 317       break;
 318     case R_MOV24B2:
 319       internal->howto = howto_table + 13;
 320       break;
 321     case R_MEM_INDIRECT:
 322       internal->howto = howto_table + 14;
 323       break;
 324     case R_PCRWORD_B:
 325       internal->howto = howto_table + 15;
 326       break;
 327     case R_MOVL1:
 328       internal->howto = howto_table + 16;
 329       break;
 330     case R_MOVL2:
 331       internal->howto = howto_table + 17;
 332       break;
 333     case R_BCC_INV:
 334       internal->howto = howto_table + 18;
 335       break;
 336     case R_JMP_DEL:
 337       internal->howto = howto_table + 19;
 338       break;
 339     default:
 340       internal->howto = NULL;
 341       break;
 342     }
 343 }
 344
 345 #define RTYPE2HOWTO(internal, relocentry) rtype2howto (internal, relocentry)
 346
 347 /* Perform any necessary magic to the addend in a reloc entry.  */
 348
 349 #define CALC_ADDEND(abfd, symbol, ext_reloc, cache_ptr) \
 350  cache_ptr->addend = ext_reloc.r_offset;
 351
 352 #define RELOC_PROCESSING(relent,reloc,symbols,abfd,section) \
 353  reloc_processing (relent, reloc, symbols, abfd, section)
 354
 355 static void
 356 reloc_processing (arelent *relent, struct internal_reloc *reloc,
 357                   asymbol **symbols, bfd *abfd, asection *section)
 358 {
 359   relent->address = reloc->r_vaddr;
 360   rtype2howto (relent, reloc);
 361
 362   if (((int) reloc->r_symndx) > 0)
 363     relent->sym_ptr_ptr = symbols + obj_convert (abfd)[reloc->r_symndx];
 364   else
 365     relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;
 366
 367   relent->addend = reloc->r_offset;
 368   relent->address -= section->vma;
 369 }
 370
 371 static bfd_boolean
 372 h8300_symbol_address_p (bfd *abfd, asection *input_section, bfd_vma address)
 373 {
 374   asymbol **s;
 375
 376   s = _bfd_generic_link_get_symbols (abfd);
 377   BFD_ASSERT (s != (asymbol **) NULL);
 378
 379   /* Search all the symbols for one in INPUT_SECTION with
 380      address ADDRESS.  */
 381   while (*s)
 382     {
 383       asymbol *p = *s;
 384
 385       if (p->section == input_section
 386           && (input_section->output_section->vma
 387               + input_section->output_offset
 388               + p->value) == address)
 389         return TRUE;
 390       s++;
 391     }
 392   return FALSE;
 393 }
 394
 395 /* If RELOC represents a relaxable instruction/reloc, change it into
 396    the relaxed reloc, notify the linker that symbol addresses
 397    have changed (bfd_perform_slip) and return how much the current
 398    section has shrunk by.
 399
 400    FIXME: Much of this code has knowledge of the ordering of entries
 401    in the howto table.  This needs to be fixed.  */
 402
 403 static int
 404 h8300_reloc16_estimate (bfd *abfd, asection *input_section, arelent *reloc,
 405                         unsigned int shrink, struct bfd_link_info *link_info)
 406 {
 407   bfd_vma value;
 408   bfd_vma dot;
 409   bfd_vma gap;
 410   static asection *last_input_section = NULL;
 411   static arelent *last_reloc = NULL;
 412
 413   /* The address of the thing to be relocated will have moved back by
 414      the size of the shrink - but we don't change reloc->address here,
 415      since we need it to know where the relocation lives in the source
 416      uncooked section.  */
 417   bfd_vma address = reloc->address - shrink;
 418
 419   if (input_section != last_input_section)
 420     last_reloc = NULL;
 421
 422   /* Only examine the relocs which might be relaxable.  */
 423   switch (reloc->howto->type)
 424     {
 425       /* This is the 16-/24-bit absolute branch which could become an
 426          8-bit pc-relative branch.  */
 427     case R_JMP1:
 428     case R_JMPL1:
 429       /* Get the address of the target of this branch.  */
 430       value = bfd_coff_reloc16_get_value (reloc, link_info, input_section);
 431
 432       /* Get the address of the next instruction (not the reloc).  */
 433       dot = (input_section->output_section->vma
 434              + input_section->output_offset + address);
 435
 436       /* Adjust for R_JMP1 vs R_JMPL1.  */
 437       dot += (reloc->howto->type == R_JMP1 ? 1 : 2);
 438
 439       /* Compute the distance from this insn to the branch target.  */
 440       gap = value - dot;
 441
 442       /* If the distance is within -128..+128 inclusive, then we can relax
 443          this jump.  +128 is valid since the target will move two bytes
 444          closer if we do relax this branch.  */
 445       if ((int) gap >= -128 && (int) gap <= 128)
 446         {
 447           bfd_byte code;
 448
 449           if (!bfd_get_section_contents (abfd, input_section, & code,
 450                                          reloc->address, 1))
 451             break;
 452           code = bfd_get_8 (abfd, & code);
 453
 454           /* It's possible we may be able to eliminate this branch entirely;
 455              if the previous instruction is a branch around this instruction,
 456              and there's no label at this instruction, then we can reverse
 457              the condition on the previous branch and eliminate this jump.
 458
 459                original:                        new:
 460                  bCC lab1                       bCC' lab2
 461                  jmp lab2
 462                 lab1:                           lab1:
 463
 464              This saves 4 bytes instead of two, and should be relatively
 465              common.
 466
 467              Only perform this optimisation for jumps (code 0x5a) not
 468              subroutine calls, as otherwise it could transform:
 469
 470                              mov.w   r0,r0
 471                              beq     .L1
 472                              jsr     @_bar
 473                       .L1:   rts
 474                       _bar:  rts
 475              into:
 476                              mov.w   r0,r0
 477                              bne     _bar
 478                              rts
 479                       _bar:  rts
 480
 481              which changes the call (jsr) into a branch (bne).  */
 482           if (code == 0x5a
 483               && gap <= 126
 484               && last_reloc
 485               && last_reloc->howto->type == R_PCRBYTE)
 486             {
 487               bfd_vma last_value;
 488               last_value = bfd_coff_reloc16_get_value (last_reloc, link_info,
 489                                                        input_section) + 1;
 490
 491               if (last_value == dot + 2
 492                   && last_reloc->address + 1 == reloc->address
 493                   && !h8300_symbol_address_p (abfd, input_section, dot - 2))
 494                 {
 495                   reloc->howto = howto_table + 19;
 496                   last_reloc->howto = howto_table + 18;
 497                   last_reloc->sym_ptr_ptr = reloc->sym_ptr_ptr;
 498                   last_reloc->addend = reloc->addend;
 499                   shrink += 4;
 500                   bfd_perform_slip (abfd, 4, input_section, address);
 501                   break;
 502                 }
 503             }
 504
 505           /* Change the reloc type.  */
 506           reloc->howto = reloc->howto + 1;
 507
 508           /* This shrinks this section by two bytes.  */
 509           shrink += 2;
 510           bfd_perform_slip (abfd, 2, input_section, address);
 511         }
 512       break;
 513
 514     /* This is the 16-bit pc-relative branch which could become an 8-bit
 515        pc-relative branch.  */
 516     case R_PCRWORD:
 517       /* Get the address of the target of this branch, add one to the value
 518          because the addend field in PCrel jumps is off by -1.  */
 519       value = bfd_coff_reloc16_get_value (reloc, link_info, input_section) + 1;
 520
 521       /* Get the address of the next instruction if we were to relax.  */
 522       dot = input_section->output_section->vma +
 523         input_section->output_offset + address;
 524
 525       /* Compute the distance from this insn to the branch target.  */
 526       gap = value - dot;
 527
 528       /* If the distance is within -128..+128 inclusive, then we can relax
 529          this jump.  +128 is valid since the target will move two bytes
 530          closer if we do relax this branch.  */
 531       if ((int) gap >= -128 && (int) gap <= 128)
 532         {
 533           /* Change the reloc type.  */
 534           reloc->howto = howto_table + 15;
 535
 536           /* This shrinks this section by two bytes.  */
 537           shrink += 2;
 538           bfd_perform_slip (abfd, 2, input_section, address);
 539         }
 540       break;
 541
 542     /* This is a 16-bit absolute address in a mov.b insn, which can
 543        become an 8-bit absolute address if it's in the right range.  */
 544     case R_MOV16B1:
 545       /* Get the address of the data referenced by this mov.b insn.  */
 546       value = bfd_coff_reloc16_get_value (reloc, link_info, input_section);
 547       value = bfd_h8300_pad_address (abfd, value);
 548
 549       /* If the address is in the top 256 bytes of the address space
 550          then we can relax this instruction.  */
 551       if (value >= 0xffffff00u)
 552         {
 553           /* Change the reloc type.  */
 554           reloc->howto = reloc->howto + 1;
 555
 556           /* This shrinks this section by two bytes.  */
 557           shrink += 2;
 558           bfd_perform_slip (abfd, 2, input_section, address);
 559         }
 560       break;
 561
 562     /* Similarly for a 24-bit absolute address in a mov.b.  Note that
 563        if we can't relax this into an 8-bit absolute, we'll fall through
 564        and try to relax it into a 16-bit absolute.  */
 565     case R_MOV24B1:
 566       /* Get the address of the data referenced by this mov.b insn.  */
 567       value = bfd_coff_reloc16_get_value (reloc, link_info, input_section);
 568       value = bfd_h8300_pad_address (abfd, value);
 569
 570       if (value >= 0xffffff00u)
 571         {
 572           /* Change the reloc type.  */
 573           reloc->howto = reloc->howto + 1;
 574
 575           /* This shrinks this section by four bytes.  */
 576           shrink += 4;
 577           bfd_perform_slip (abfd, 4, input_section, address);
 578
 579           /* Done with this reloc.  */
 580           break;
 581         }
 582
 583       /* FALLTHROUGH and try to turn the 24-/32-bit reloc into a 16-bit
 584          reloc.  */
 585
 586     /* This is a 24-/32-bit absolute address in a mov insn, which can
 587        become an 16-bit absolute address if it's in the right range.  */
 588     case R_MOVL1:
 589       /* Get the address of the data referenced by this mov insn.  */
 590       value = bfd_coff_reloc16_get_value (reloc, link_info, input_section);
 591       value = bfd_h8300_pad_address (abfd, value);
 592
 593       /* If the address is a sign-extended 16-bit value then we can
 594          relax this instruction.  */
 595       if (value <= 0x7fff || value >= 0xffff8000u)
 596         {
 597           /* Change the reloc type.  */
 598           reloc->howto = howto_table + 17;
 599
 600           /* This shrinks this section by two bytes.  */
 601           shrink += 2;
 602           bfd_perform_slip (abfd, 2, input_section, address);
 603         }
 604       break;
 605
 606       /* No other reloc types represent relaxing opportunities.  */
 607     default:
 608       break;
 609     }
 610
 611   last_reloc = reloc;
 612   last_input_section = input_section;
 613   return shrink;
 614 }
 615
 616 /* Handle relocations for the H8/300, including relocs for relaxed
 617    instructions.
 618
 619    FIXME: Not all relocations check for overflow!  */
 620
 621 static void
 622 h8300_reloc16_extra_cases (bfd *abfd, struct bfd_link_info *link_info,
 623                            struct bfd_link_order *link_order, arelent *reloc,
 624                            bfd_byte *data, unsigned int *src_ptr,
 625                            unsigned int *dst_ptr)
 626 {
 627   unsigned int src_address = *src_ptr;
 628   unsigned int dst_address = *dst_ptr;
 629   asection *input_section = link_order->u.indirect.section;
 630   bfd_vma value;
 631   bfd_vma dot;
 632   int gap, tmp;
 633   unsigned char temp_code;
 634
 635   switch (reloc->howto->type)
 636     {
 637     /* Generic 8-bit pc-relative relocation.  */
 638     case R_PCRBYTE:
 639       /* Get the address of the target of this branch.  */
 640       value = bfd_coff_reloc16_get_value (reloc, link_info, input_section);
 641
 642       dot = (input_section->output_offset
 643              + dst_address
 644              + link_order->u.indirect.section->output_section->vma);
 645
 646       gap = value - dot;
 647
 648       /* Sanity check.  */
 649       if (gap < -128 || gap > 126)
 650         {
 651           if (! ((*link_info->callbacks->reloc_overflow)
 652                  (link_info, NULL,
 653                   bfd_asymbol_name (*reloc->sym_ptr_ptr),
 654                   reloc->howto->name, reloc->addend, input_section->owner,
 655                   input_section, reloc->address)))
 656             abort ();
 657         }
 658
 659       /* Everything looks OK.  Apply the relocation and update the
 660          src/dst address appropriately.  */
 661       bfd_put_8 (abfd, gap, data + dst_address);
 662       dst_address++;
 663       src_address++;
 664
 665       /* All done.  */
 666       break;
 667
 668     /* Generic 16-bit pc-relative relocation.  */
 669     case R_PCRWORD:
 670       /* Get the address of the target of this branch.  */
 671       value = bfd_coff_reloc16_get_value (reloc, link_info, input_section);
 672
 673       /* Get the address of the instruction (not the reloc).  */
 674       dot = (input_section->output_offset
 675              + dst_address
 676              + link_order->u.indirect.section->output_section->vma + 1);
 677
 678       gap = value - dot;
 679
 680       /* Sanity check.  */
 681       if (gap > 32766 || gap < -32768)
 682         {
 683           if (! ((*link_info->callbacks->reloc_overflow)
 684                  (link_info, NULL,
 685                   bfd_asymbol_name (*reloc->sym_ptr_ptr),
 686                   reloc->howto->name, reloc->addend, input_section->owner,
 687                   input_section, reloc->address)))
 688             abort ();
 689         }
 690
 691       /* Everything looks OK.  Apply the relocation and update the
 692          src/dst address appropriately.  */
 693       bfd_put_16 (abfd, (bfd_vma) gap, data + dst_address);
 694       dst_address += 2;
 695       src_address += 2;
 696
 697       /* All done.  */
 698       break;
 699
 700     /* Generic 8-bit absolute relocation.  */
 701     case R_RELBYTE:
 702       /* Get the address of the object referenced by this insn.  */
 703       value = bfd_coff_reloc16_get_value (reloc, link_info, input_section);
 704
 705       bfd_put_8 (abfd, value & 0xff, data + dst_address);
 706       dst_address += 1;
 707       src_address += 1;
 708
 709       /* All done.  */
 710       break;
 711
 712     /* Various simple 16-bit absolute relocations.  */
 713     case R_MOV16B1:
 714     case R_JMP1:
 715     case R_RELWORD:
 716       value = bfd_coff_reloc16_get_value (reloc, link_info, input_section);
 717       bfd_put_16 (abfd, value, data + dst_address);
 718       dst_address += 2;
 719       src_address += 2;
 720       break;
 721
 722     /* Various simple 24-/32-bit absolute relocations.  */
 723     case R_MOV24B1:
 724     case R_MOVL1:
 725     case R_RELLONG:
 726       /* Get the address of the target of this branch.  */
 727       value = bfd_coff_reloc16_get_value (reloc, link_info, input_section);
 728       bfd_put_32 (abfd, value, data + dst_address);
 729       dst_address += 4;
 730       src_address += 4;
 731       break;
 732
 733     /* Another 24-/32-bit absolute relocation.  */
 734     case R_JMPL1:
 735       /* Get the address of the target of this branch.  */
 736       value = bfd_coff_reloc16_get_value (reloc, link_info, input_section);
 737
 738       value = ((value & 0x00ffffff)
 739                | (bfd_get_32 (abfd, data + src_address) & 0xff000000));
 740       bfd_put_32 (abfd, value, data + dst_address);
 741       dst_address += 4;
 742       src_address += 4;
 743       break;
 744
 745       /* This is a 24-/32-bit absolute address in one of the following
 746          instructions:
 747
 748            "band", "bclr", "biand", "bild", "bior", "bist", "bixor",
 749            "bld", "bnot", "bor", "bset", "bst", "btst", "bxor", "ldc.w",
 750            "stc.w" and "mov.[bwl]"
 751
 752          We may relax this into an 16-bit absolute address if it's in
 753          the right range.  */
 754     case R_MOVL2:
 755       value = bfd_coff_reloc16_get_value (reloc, link_info, input_section);
 756       value = bfd_h8300_pad_address (abfd, value);
 757
 758       /* Sanity check.  */
 759       if (value <= 0x7fff || value >= 0xffff8000u)
 760         {
 761           /* Insert the 16-bit value into the proper location.  */
 762           bfd_put_16 (abfd, value, data + dst_address);
 763
 764           /* Fix the opcode.  For all the instructions that belong to
 765              this relaxation, we simply need to turn off bit 0x20 in
 766              the previous byte.  */
 767           data[dst_address - 1] &= ~0x20;
 768           dst_address += 2;
 769           src_address += 4;
 770         }
 771       else
 772         {
 773           if (! ((*link_info->callbacks->reloc_overflow)
 774                  (link_info, NULL,
 775                   bfd_asymbol_name (*reloc->sym_ptr_ptr),
 776                   reloc->howto->name, reloc->addend, input_section->owner,
 777                   input_section, reloc->address)))
 778             abort ();
 779         }
 780       break;
 781
 782     /* A 16-bit absolute branch that is now an 8-bit pc-relative branch.  */
 783     case R_JMP2:
 784       /* Get the address of the target of this branch.  */
 785       value = bfd_coff_reloc16_get_value (reloc, link_info, input_section);
 786
 787       /* Get the address of the next instruction.  */
 788       dot = (input_section->output_offset
 789              + dst_address
 790              + link_order->u.indirect.section->output_section->vma + 1);
 791
 792       gap = value - dot;
 793
 794       /* Sanity check.  */
 795       if (gap < -128 || gap > 126)
 796         {
 797           if (! ((*link_info->callbacks->reloc_overflow)
 798                  (link_info, NULL,
 799                   bfd_asymbol_name (*reloc->sym_ptr_ptr),
 800                   reloc->howto->name, reloc->addend, input_section->owner,
 801                   input_section, reloc->address)))
 802             abort ();
 803         }
 804
 805       /* Now fix the instruction itself.  */
 806       switch (data[dst_address - 1])
 807         {
 808         case 0x5e:
 809           /* jsr -> bsr */
 810           bfd_put_8 (abfd, 0x55, data + dst_address - 1);
 811           break;
 812         case 0x5a:
 813           /* jmp -> bra */
 814           bfd_put_8 (abfd, 0x40, data + dst_address - 1);
 815           break;
 816
 817         default:
 818           abort ();
 819         }
 820
 821       /* Write out the 8-bit value.  */
 822       bfd_put_8 (abfd, gap, data + dst_address);
 823
 824       dst_address += 1;
 825       src_address += 3;
 826
 827       break;
 828
 829     /* A 16-bit pc-relative branch that is now an 8-bit pc-relative branch.  */
 830     case R_PCRWORD_B:
 831       /* Get the address of the target of this branch.  */
 832       value = bfd_coff_reloc16_get_value (reloc, link_info, input_section);
 833
 834       /* Get the address of the instruction (not the reloc).  */
 835       dot = (input_section->output_offset
 836              + dst_address
 837              + link_order->u.indirect.section->output_section->vma - 1);
 838
 839       gap = value - dot;
 840
 841       /* Sanity check.  */
 842       if (gap < -128 || gap > 126)
 843         {
 844           if (! ((*link_info->callbacks->reloc_overflow)
 845                  (link_info, NULL,
 846                   bfd_asymbol_name (*reloc->sym_ptr_ptr),
 847                   reloc->howto->name, reloc->addend, input_section->owner,
 848                   input_section, reloc->address)))
 849             abort ();
 850         }
 851
 852       /* Now fix the instruction.  */
 853       switch (data[dst_address - 2])
 854         {
 855         case 0x58:
 856           /* bCC:16 -> bCC:8 */
 857           /* Get the second byte of the original insn, which contains
 858              the condition code.  */
 859           tmp = data[dst_address - 1];
 860
 861           /* Compute the fisrt byte of the relaxed instruction.  The
 862              original sequence 0x58 0xX0 is relaxed to 0x4X, where X
 863              represents the condition code.  */
 864           tmp &= 0xf0;
 865           tmp >>= 4;
 866           tmp |= 0x40;
 867
 868           /* Write it.  */
 869           bfd_put_8 (abfd, tmp, data + dst_address - 2);
 870           break;
 871
 872         case 0x5c:
 873           /* bsr:16 -> bsr:8 */
 874           bfd_put_8 (abfd, 0x55, data + dst_address - 2);
 875           break;
 876
 877         default:
 878           abort ();
 879         }
 880
 881       /* Output the target.  */
 882       bfd_put_8 (abfd, gap, data + dst_address - 1);
 883
 884       /* We don't advance dst_address -- the 8-bit reloc is applied at
 885          dst_address - 1, so the next insn should begin at dst_address.  */
 886       src_address += 2;
 887
 888       break;
 889
 890     /* Similarly for a 24-bit absolute that is now 8 bits.  */
 891     case R_JMPL2:
 892       /* Get the address of the target of this branch.  */
 893       value = bfd_coff_reloc16_get_value (reloc, link_info, input_section);
 894
 895       /* Get the address of the instruction (not the reloc).  */
 896       dot = (input_section->output_offset
 897              + dst_address
 898              + link_order->u.indirect.section->output_section->vma + 2);
 899
 900       gap = value - dot;
 901
 902       /* Fix the instruction.  */
 903       switch (data[src_address])
 904         {
 905         case 0x5e:
 906           /* jsr -> bsr */
 907           bfd_put_8 (abfd, 0x55, data + dst_address);
 908           break;
 909         case 0x5a:
 910           /* jmp ->bra */
 911           bfd_put_8 (abfd, 0x40, data + dst_address);
 912           break;
 913         default:
 914           abort ();
 915         }
 916
 917       bfd_put_8 (abfd, gap, data + dst_address + 1);
 918       dst_address += 2;
 919       src_address += 4;
 920
 921       break;
 922
 923       /* This is a 16-bit absolute address in one of the following
 924          instructions:
 925
 926            "band", "bclr", "biand", "bild", "bior", "bist", "bixor",
 927            "bld", "bnot", "bor", "bset", "bst", "btst", "bxor", and
 928            "mov.b"
 929
 930          We may relax this into an 8-bit absolute address if it's in
 931          the right range.  */
 932     case R_MOV16B2:
 933       value = bfd_coff_reloc16_get_value (reloc, link_info, input_section);
 934
 935       /* All instructions with R_H8_DIR16B2 start with 0x6a.  */
 936       if (data[dst_address - 2] != 0x6a)
 937         abort ();
 938
 939       temp_code = data[src_address - 1];
 940
 941       /* If this is a mov.b instruction, clear the lower nibble, which
 942          contains the source/destination register number.  */
 943       if ((temp_code & 0x10) != 0x10)
 944         temp_code &= 0xf0;
 945
 946       /* Fix up the opcode.  */
 947       switch (temp_code)
 948         {
 949         case 0x00:
 950           /* This is mov.b @aa:16,Rd.  */
 951           data[dst_address - 2] = (data[src_address - 1] & 0xf) | 0x20;
 952           break;
 953         case 0x80:
 954           /* This is mov.b Rs,@aa:16.  */
 955           data[dst_address - 2] = (data[src_address - 1] & 0xf) | 0x30;
 956           break;
 957         case 0x18:
 958           /* This is a bit-maniputation instruction that stores one
 959              bit into memory, one of "bclr", "bist", "bnot", "bset",
 960              and "bst".  */
 961           data[dst_address - 2] = 0x7f;
 962           break;
 963         case 0x10:
 964           /* This is a bit-maniputation instruction that loads one bit
 965              from memory, one of "band", "biand", "bild", "bior",
 966              "bixor", "bld", "bor", "btst", and "bxor".  */
 967           data[dst_address - 2] = 0x7e;
 968           break;
 969         default:
 970           abort ();
 971         }
 972
 973       bfd_put_8 (abfd, value & 0xff, data + dst_address - 1);
 974       src_address += 2;
 975       break;
 976
 977       /* This is a 24-bit absolute address in one of the following
 978          instructions:
 979
 980            "band", "bclr", "biand", "bild", "bior", "bist", "bixor",
 981            "bld", "bnot", "bor", "bset", "bst", "btst", "bxor", and
 982            "mov.b"
 983
 984          We may relax this into an 8-bit absolute address if it's in
 985          the right range.  */
 986     case R_MOV24B2:
 987       value = bfd_coff_reloc16_get_value (reloc, link_info, input_section);
 988
 989       /* All instructions with R_MOV24B2 start with 0x6a.  */
 990       if (data[dst_address - 2] != 0x6a)
 991         abort ();
 992
 993       temp_code = data[src_address - 1];
 994
 995       /* If this is a mov.b instruction, clear the lower nibble, which
 996          contains the source/destination register number.  */
 997       if ((temp_code & 0x30) != 0x30)
 998         temp_code &= 0xf0;
 999
1000       /* Fix up the opcode.  */
1001       switch (temp_code)
1002         {
1003         case 0x20:
1004           /* This is mov.b @aa:24/32,Rd.  */
1005           data[dst_address - 2] = (data[src_address - 1] & 0xf) | 0x20;
1006           break;
1007         case 0xa0:
1008           /* This is mov.b Rs,@aa:24/32.  */
1009           data[dst_address - 2] = (data[src_address - 1] & 0xf) | 0x30;
1010           break;
1011         case 0x38:
1012           /* This is a bit-maniputation instruction that stores one
1013              bit into memory, one of "bclr", "bist", "bnot", "bset",
1014              and "bst".  */
1015           data[dst_address - 2] = 0x7f;
1016           break;
1017         case 0x30:
1018           /* This is a bit-maniputation instruction that loads one bit
1019              from memory, one of "band", "biand", "bild", "bior",
1020              "bixor", "bld", "bor", "btst", and "bxor".  */
1021           data[dst_address - 2] = 0x7e;
1022           break;
1023         default:
1024           abort ();
1025         }
1026
1027       bfd_put_8 (abfd, value & 0xff, data + dst_address - 1);
1028       src_address += 4;
1029       break;
1030
1031     case R_BCC_INV:
1032       /* Get the address of the target of this branch.  */
1033       value = bfd_coff_reloc16_get_value (reloc, link_info, input_section);
1034
1035       dot = (input_section->output_offset
1036              + dst_address
1037              + link_order->u.indirect.section->output_section->vma) + 1;
1038
1039       gap = value - dot;
1040
1041       /* Sanity check.  */
1042       if (gap < -128 || gap > 126)
1043         {
1044           if (! ((*link_info->callbacks->reloc_overflow)
1045                  (link_info, NULL,
1046                   bfd_asymbol_name (*reloc->sym_ptr_ptr),
1047                   reloc->howto->name, reloc->addend, input_section->owner,
1048                   input_section, reloc->address)))
1049             abort ();
1050         }
1051
1052       /* Everything looks OK.  Fix the condition in the instruction, apply
1053          the relocation, and update the src/dst address appropriately.  */
1054
1055       bfd_put_8 (abfd, bfd_get_8 (abfd, data + dst_address - 1) ^ 1,
1056                  data + dst_address - 1);
1057       bfd_put_8 (abfd, gap, data + dst_address);
1058       dst_address++;
1059       src_address++;
1060
1061       /* All done.  */
1062       break;
1063
1064     case R_JMP_DEL:
1065       src_address += 4;
1066       break;
1067
1068     /* An 8-bit memory indirect instruction (jmp/jsr).
1069
1070        There's several things that need to be done to handle
1071        this relocation.
1072
1073        If this is a reloc against the absolute symbol, then
1074        we should handle it just R_RELBYTE.  Likewise if it's
1075        for a symbol with a value ge 0 and le 0xff.
1076
1077        Otherwise it's a jump/call through the function vector,
1078        and the linker is expected to set up the function vector
1079        and put the right value into the jump/call instruction.  */
1080     case R_MEM_INDIRECT:
1081       {
1082         /* We need to find the symbol so we can determine it's
1083            address in the function vector table.  */
1084         asymbol *symbol;
1085         const char *name;
1086         struct funcvec_hash_table *ftab;
1087         struct funcvec_hash_entry *h;
1088         struct h8300_coff_link_hash_table *htab;
1089         asection *vectors_sec;
1090
1091         if (link_info->output_bfd->xvec != abfd->xvec)
1092           {
1093             (*_bfd_error_handler)
1094               (_("cannot handle R_MEM_INDIRECT reloc when using %s output"),
1095                link_info->output_bfd->xvec->name);
1096
1097             /* What else can we do?  This function doesn't allow return
1098                of an error, and we don't want to call abort as that
1099                indicates an internal error.  */
1100 #ifndef EXIT_FAILURE
1101 #define EXIT_FAILURE 1
1102 #endif
1103             xexit (EXIT_FAILURE);
1104           }
1105         htab = h8300_coff_hash_table (link_info);
1106         vectors_sec = htab->vectors_sec;
1107
1108         /* First see if this is a reloc against the absolute symbol
1109            or against a symbol with a nonnegative value <= 0xff.  */
1110         symbol = *(reloc->sym_ptr_ptr);
1111         value = bfd_coff_reloc16_get_value (reloc, link_info, input_section);
1112         if (symbol == bfd_abs_section_ptr->symbol
1113             || value <= 0xff)
1114           {
1115             /* This should be handled in a manner very similar to
1116                R_RELBYTES.   If the value is in range, then just slam
1117                the value into the right location.  Else trigger a
1118                reloc overflow callback.  */
1119             if (value <= 0xff)
1120               {
1121                 bfd_put_8 (abfd, value, data + dst_address);
1122                 dst_address += 1;
1123                 src_address += 1;
1124               }
1125             else
1126               {
1127                 if (! ((*link_info->callbacks->reloc_overflow)
1128                        (link_info, NULL,
1129                         bfd_asymbol_name (*reloc->sym_ptr_ptr),
1130                         reloc->howto->name, reloc->addend, input_section->owner,
1131                         input_section, reloc->address)))
1132                   abort ();
1133               }
1134             break;
1135           }
1136
1137         /* This is a jump/call through a function vector, and we're
1138            expected to create the function vector ourselves.
1139
1140            First look up this symbol in the linker hash table -- we need
1141            the derived linker symbol which holds this symbol's index
1142            in the function vector.  */
1143         name = symbol->name;
1144         if (symbol->flags & BSF_LOCAL)
1145           {
1146             char *new_name = bfd_malloc ((bfd_size_type) strlen (name) + 10);
1147
1148             if (new_name == NULL)
1149               abort ();
1150
1151             sprintf (new_name, "%s_%08x", name, symbol->section->id);
1152             name = new_name;
1153           }
1154
1155         ftab = htab->funcvec_hash_table;
1156         h = funcvec_hash_lookup (ftab, name, FALSE, FALSE);
1157
1158         /* This shouldn't ever happen.  If it does that means we've got
1159            data corruption of some kind.  Aborting seems like a reasonable
1160            thing to do here.  */
1161         if (h == NULL || vectors_sec == NULL)
1162           abort ();
1163
1164         /* Place the address of the function vector entry into the
1165            reloc's address.  */
1166         bfd_put_8 (abfd,
1167                    vectors_sec->output_offset + h->offset,
1168                    data + dst_address);
1169
1170         dst_address++;
1171         src_address++;
1172
1173         /* Now create an entry in the function vector itself.  */
1174         switch (bfd_get_mach (input_section->owner))
1175           {
1176           case bfd_mach_h8300:
1177           case bfd_mach_h8300hn:
1178           case bfd_mach_h8300sn:
1179             bfd_put_16 (abfd,
1180                         bfd_coff_reloc16_get_value (reloc,
1181                                                     link_info,
1182                                                     input_section),
1183                         vectors_sec->contents + h->offset);
1184             break;
1185           case bfd_mach_h8300h:
1186           case bfd_mach_h8300s:
1187             bfd_put_32 (abfd,
1188                         bfd_coff_reloc16_get_value (reloc,
1189                                                     link_info,
1190                                                     input_section),
1191                         vectors_sec->contents + h->offset);
1192             break;
1193           default:
1194             abort ();
1195           }
1196
1197         /* Gross.  We've already written the contents of the vector section
1198            before we get here...  So we write it again with the new data.  */
1199         bfd_set_section_contents (vectors_sec->output_section->owner,
1200                                   vectors_sec->output_section,
1201                                   vectors_sec->contents,
1202                                   (file_ptr) vectors_sec->output_offset,
1203                                   vectors_sec->size);
1204         break;
1205       }
1206
1207     default:
1208       abort ();
1209       break;
1210
1211     }
1212
1213   *src_ptr = src_address;
1214   *dst_ptr = dst_address;
1215 }
1216
1217 /* Routine for the h8300 linker.
1218
1219    This routine is necessary to handle the special R_MEM_INDIRECT
1220    relocs on the h8300.  It's responsible for generating a vectors
1221    section and attaching it to an input bfd as well as sizing
1222    the vectors section.  It also creates our vectors hash table.
1223
1224    It uses the generic linker routines to actually add the symbols.
1225    from this BFD to the bfd linker hash table.  It may add a few
1226    selected static symbols to the bfd linker hash table.  */
1227
1228 static bfd_boolean
1229 h8300_bfd_link_add_symbols (bfd *abfd, struct bfd_link_info *info)
1230 {
1231   asection *sec;
1232   struct funcvec_hash_table *funcvec_hash_table;
1233   bfd_size_type amt;
1234   struct h8300_coff_link_hash_table *htab;
1235
1236   /* Add the symbols using the generic code.  */
1237   _bfd_generic_link_add_symbols (abfd, info);
1238
1239   if (info->output_bfd->xvec != abfd->xvec)
1240     return TRUE;
1241
1242   htab = h8300_coff_hash_table (info);
1243
1244   /* If we haven't created a vectors section, do so now.  */
1245   if (!htab->vectors_sec)
1246     {
1247       flagword flags;
1248
1249       /* Make sure the appropriate flags are set, including SEC_IN_MEMORY.  */
1250       flags = (SEC_ALLOC | SEC_LOAD
1251                | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_READONLY);
1252       htab->vectors_sec = bfd_make_section_with_flags (abfd, ".vectors",
1253                                                        flags);
1254
1255       /* If the section wasn't created, or we couldn't set the flags,
1256          quit quickly now, rather than dying a painful death later.  */
1257       if (!htab->vectors_sec)
1258         return FALSE;
1259
1260       /* Also create the vector hash table.  */
1261       amt = sizeof (struct funcvec_hash_table);
1262       funcvec_hash_table = (struct funcvec_hash_table *) bfd_alloc (abfd, amt);
1263
1264       if (!funcvec_hash_table)
1265         return FALSE;
1266
1267       /* And initialize the funcvec hash table.  */
1268       if (!funcvec_hash_table_init (funcvec_hash_table, abfd,
1269                                     funcvec_hash_newfunc,
1270                                     sizeof (struct funcvec_hash_entry)))
1271         {
1272           bfd_release (abfd, funcvec_hash_table);
1273           return FALSE;
1274         }
1275
1276       /* Store away a pointer to the funcvec hash table.  */
1277       htab->funcvec_hash_table = funcvec_hash_table;
1278     }
1279
1280   /* Load up the function vector hash table.  */
1281   funcvec_hash_table = htab->funcvec_hash_table;
1282
1283   /* Now scan the relocs for all the sections in this bfd; create
1284      additional space in the .vectors section as needed.  */
1285   for (sec = abfd->sections; sec; sec = sec->next)
1286     {
1287       long reloc_size, reloc_count, i;
1288       asymbol **symbols;
1289       arelent **relocs;
1290
1291       /* Suck in the relocs, symbols & canonicalize them.  */
1292       reloc_size = bfd_get_reloc_upper_bound (abfd, sec);
1293       if (reloc_size <= 0)
1294         continue;
1295
1296       relocs = (arelent **) bfd_malloc ((bfd_size_type) reloc_size);
1297       if (!relocs)
1298         return FALSE;
1299
1300       /* The symbols should have been read in by _bfd_generic link_add_symbols
1301          call abovec, so we can cheat and use the pointer to them that was
1302          saved in the above call.  */
1303       symbols = _bfd_generic_link_get_symbols(abfd);
1304       reloc_count = bfd_canonicalize_reloc (abfd, sec, relocs, symbols);
1305       if (reloc_count <= 0)
1306         {
1307           free (relocs);
1308           continue;
1309         }
1310
1311       /* Now walk through all the relocations in this section.  */
1312       for (i = 0; i < reloc_count; i++)
1313         {
1314           arelent *reloc = relocs[i];
1315           asymbol *symbol = *(reloc->sym_ptr_ptr);
1316           const char *name;
1317
1318           /* We've got an indirect reloc.  See if we need to add it
1319              to the function vector table.   At this point, we have
1320              to add a new entry for each unique symbol referenced
1321              by an R_MEM_INDIRECT relocation except for a reloc
1322              against the absolute section symbol.  */
1323           if (reloc->howto->type == R_MEM_INDIRECT
1324               && symbol != bfd_abs_section_ptr->symbol)
1325
1326             {
1327               struct funcvec_hash_table *ftab;
1328               struct funcvec_hash_entry *h;
1329
1330               name = symbol->name;
1331               if (symbol->flags & BSF_LOCAL)
1332                 {
1333                   char *new_name;
1334
1335                   new_name = bfd_malloc ((bfd_size_type) strlen (name) + 10);
1336                   if (new_name == NULL)
1337                     abort ();
1338
1339                   sprintf (new_name, "%s_%08x", name, symbol->section->id);
1340                   name = new_name;
1341                 }
1342
1343               /* Look this symbol up in the function vector hash table.  */
1344               ftab = htab->funcvec_hash_table;
1345               h = funcvec_hash_lookup (ftab, name, FALSE, FALSE);
1346
1347               /* If this symbol isn't already in the hash table, add
1348                  it and bump up the size of the hash table.  */
1349               if (h == NULL)
1350                 {
1351                   h = funcvec_hash_lookup (ftab, name, TRUE, TRUE);
1352                   if (h == NULL)
1353                     {
1354                       free (relocs);
1355                       return FALSE;
1356                     }
1357
1358                   /* Bump the size of the vectors section.  Each vector
1359                      takes 2 bytes on the h8300 and 4 bytes on the h8300h.  */
1360                   switch (bfd_get_mach (abfd))
1361                     {
1362                     case bfd_mach_h8300:
1363                     case bfd_mach_h8300hn:
1364                     case bfd_mach_h8300sn:
1365                       htab->vectors_sec->size += 2;
1366                       break;
1367                     case bfd_mach_h8300h:
1368                     case bfd_mach_h8300s:
1369                       htab->vectors_sec->size += 4;
1370                       break;
1371                     default:
1372                       abort ();
1373                     }
1374                 }
1375             }
1376         }
1377
1378       /* We're done with the relocations, release them.  */
1379       free (relocs);
1380     }
1381
1382   /* Now actually allocate some space for the function vector.  It's
1383      wasteful to do this more than once, but this is easier.  */
1384   sec = htab->vectors_sec;
1385   if (sec->size != 0)
1386     {
1387       /* Free the old contents.  */
1388       if (sec->contents)
1389         free (sec->contents);
1390
1391       /* Allocate new contents.  */
1392       sec->contents = bfd_malloc (sec->size);
1393     }
1394
1395   return TRUE;
1396 }
1397
1398 #define coff_reloc16_extra_cases h8300_reloc16_extra_cases
1399 #define coff_reloc16_estimate h8300_reloc16_estimate
1400 #define coff_bfd_link_add_symbols h8300_bfd_link_add_symbols
1401 #define coff_bfd_link_hash_table_create h8300_coff_link_hash_table_create
1402
1403 #define COFF_LONG_FILENAMES
1404
1405 #ifndef bfd_pe_print_pdata
1406 #define bfd_pe_print_pdata      NULL
1407 #endif
1408
1409 #include "coffcode.h"
1410
1411 #undef coff_bfd_get_relocated_section_contents
1412 #undef coff_bfd_relax_section
1413 #define coff_bfd_get_relocated_section_contents \
1414   bfd_coff_reloc16_get_relocated_section_contents
1415 #define coff_bfd_relax_section bfd_coff_reloc16_relax_section
1416
1417 CREATE_BIG_COFF_TARGET_VEC (h8300_coff_vec, "coff-h8300", BFD_IS_RELAXABLE, 0, '_', NULL, COFF_SWAP_TABLE)