bfd/coff-h8300.c

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