bfd/elf32-xstormy16.c

   1 /* XSTORMY16-specific support for 32-bit ELF.
   2    Copyright 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
   3
   4 This file is part of BFD, the Binary File Descriptor library.
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  19
  20 #include "bfd.h"
  21 #include "sysdep.h"
  22 #include "libbfd.h"
  23 #include "elf-bfd.h"
  24 #include "elf/xstormy16.h"
  25 #include "libiberty.h"
  26
  27 /* Forward declarations.  */
  28 static reloc_howto_type * xstormy16_reloc_type_lookup
  29   PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
  30 static void xstormy16_info_to_howto_rela
  31   PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
  32 static bfd_reloc_status_type xstormy16_elf_24_reloc
  33   PARAMS ((bfd *abfd, arelent *reloc_entry, asymbol *symbol,
  34            PTR data, asection *input_section, bfd *output_bfd,
  35            char **error_message));
  36 static bfd_boolean xstormy16_elf_check_relocs
  37   PARAMS ((bfd *, struct bfd_link_info *, asection *,
  38            const Elf_Internal_Rela *));
  39 static bfd_boolean xstormy16_relax_plt_check
  40   PARAMS ((struct elf_link_hash_entry *, PTR));
  41 static bfd_boolean xstormy16_relax_plt_realloc
  42   PARAMS ((struct elf_link_hash_entry *, PTR));
  43 static bfd_boolean xstormy16_elf_relax_section
  44   PARAMS ((bfd *abfd, asection *sec, struct bfd_link_info *link_info,
  45            bfd_boolean *again));
  46 static bfd_boolean xstormy16_elf_always_size_sections
  47   PARAMS ((bfd *, struct bfd_link_info *));
  48 static bfd_boolean xstormy16_elf_relocate_section
  49   PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
  50            Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
  51 static bfd_boolean xstormy16_elf_finish_dynamic_sections
  52   PARAMS((bfd *, struct bfd_link_info *));
  53 static bfd_boolean xstormy16_elf_gc_sweep_hook
  54   PARAMS ((bfd *, struct bfd_link_info *, asection *,
  55            const Elf_Internal_Rela *));
  56 static asection * xstormy16_elf_gc_mark_hook
  57   PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *,
  58            struct elf_link_hash_entry *, Elf_Internal_Sym *));
  59
  60 static reloc_howto_type xstormy16_elf_howto_table [] =
  61 {
  62   /* This reloc does nothing.  */
  63   HOWTO (R_XSTORMY16_NONE,      /* type */
  64          0,                     /* rightshift */
  65          2,                     /* size (0 = byte, 1 = short, 2 = long) */
  66          32,                    /* bitsize */
  67          FALSE,                 /* pc_relative */
  68          0,                     /* bitpos */
  69          complain_overflow_bitfield, /* complain_on_overflow */
  70          bfd_elf_generic_reloc, /* special_function */
  71          "R_XSTORMY16_NONE",    /* name */
  72          FALSE,                 /* partial_inplace */
  73          0,                     /* src_mask */
  74          0,                     /* dst_mask */
  75          FALSE),                /* pcrel_offset */
  76
  77   /* A 32 bit absolute relocation.  */
  78   HOWTO (R_XSTORMY16_32,        /* type */
  79          0,                     /* rightshift */
  80          2,                     /* size (0 = byte, 1 = short, 2 = long) */
  81          32,                    /* bitsize */
  82          FALSE,                 /* pc_relative */
  83          0,                     /* bitpos */
  84          complain_overflow_dont, /* complain_on_overflow */
  85          bfd_elf_generic_reloc, /* special_function */
  86          "R_XSTORMY16_32",      /* name */
  87          FALSE,                 /* partial_inplace */
  88          0,                     /* src_mask */
  89          0xffffffff,            /* dst_mask */
  90          FALSE),                /* pcrel_offset */
  91
  92   /* A 16 bit absolute relocation.  */
  93   HOWTO (R_XSTORMY16_16,        /* type */
  94          0,                     /* rightshift */
  95          1,                     /* size (0 = byte, 1 = short, 2 = long) */
  96          16,                    /* bitsize */
  97          FALSE,                 /* pc_relative */
  98          0,                     /* bitpos */
  99          complain_overflow_bitfield, /* complain_on_overflow */
 100          bfd_elf_generic_reloc, /* special_function */
 101          "R_XSTORMY16_16",      /* name */
 102          FALSE,                 /* partial_inplace */
 103          0,                     /* src_mask */
 104          0xffff,                /* dst_mask */
 105          FALSE),                /* pcrel_offset */
 106
 107   /* An 8 bit absolute relocation.  */
 108   HOWTO (R_XSTORMY16_8,         /* type */
 109          0,                     /* rightshift */
 110          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 111          8,                     /* bitsize */
 112          FALSE,                 /* pc_relative */
 113          0,                     /* bitpos */
 114          complain_overflow_unsigned, /* complain_on_overflow */
 115          bfd_elf_generic_reloc, /* special_function */
 116          "R_XSTORMY16_8",       /* name */
 117          FALSE,                 /* partial_inplace */
 118          0,                     /* src_mask */
 119          0xff,                  /* dst_mask */
 120          FALSE),                /* pcrel_offset */
 121
 122   /* A 32 bit pc-relative relocation.  */
 123   HOWTO (R_XSTORMY16_PC32,      /* type */
 124          0,                     /* rightshift */
 125          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 126          32,                    /* bitsize */
 127          TRUE,                  /* pc_relative */
 128          0,                     /* bitpos */
 129          complain_overflow_dont, /* complain_on_overflow */
 130          bfd_elf_generic_reloc, /* special_function */
 131          "R_XSTORMY16_PC32",    /* name */
 132          FALSE,                 /* partial_inplace */
 133          0,                     /* src_mask */
 134          0xffffffff,            /* dst_mask */
 135          TRUE),                 /* pcrel_offset */
 136
 137   /* A 16 bit pc-relative relocation.  */
 138   HOWTO (R_XSTORMY16_PC16,      /* type */
 139          0,                     /* rightshift */
 140          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 141          16,                    /* bitsize */
 142          TRUE,                  /* pc_relative */
 143          0,                     /* bitpos */
 144          complain_overflow_signed, /* complain_on_overflow */
 145          bfd_elf_generic_reloc, /* special_function */
 146          "R_XSTORMY16_PC16",    /* name */
 147          FALSE,                 /* partial_inplace */
 148          0,                     /* src_mask */
 149          0xffffffff,            /* dst_mask */
 150          TRUE),                 /* pcrel_offset */
 151
 152   /* An 8 bit pc-relative relocation.  */
 153   HOWTO (R_XSTORMY16_PC8,       /* type */
 154          0,                     /* rightshift */
 155          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 156          8,                     /* bitsize */
 157          TRUE,                  /* pc_relative */
 158          0,                     /* bitpos */
 159          complain_overflow_signed, /* complain_on_overflow */
 160          bfd_elf_generic_reloc, /* special_function */
 161          "R_XSTORMY16_PC8",     /* name */
 162          FALSE,                 /* partial_inplace */
 163          0,                     /* src_mask */
 164          0xffffffff,            /* dst_mask */
 165          TRUE),                 /* pcrel_offset */
 166
 167   /* A 12-bit pc-relative relocation suitable for the branch instructions.  */
 168   HOWTO (R_XSTORMY16_REL_12,    /* type */
 169          1,                     /* rightshift */
 170          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 171          11,                    /* bitsize */
 172          TRUE,                  /* pc_relative */
 173          1,                     /* bitpos */
 174          complain_overflow_signed, /* complain_on_overflow */
 175          bfd_elf_generic_reloc, /* special_function */
 176          "R_XSTORMY16_REL_12",  /* name */
 177          FALSE,                 /* partial_inplace */
 178          0,                     /* src_mask */
 179          0x0ffe,                /* dst_mask */
 180          TRUE),                 /* pcrel_offset */
 181
 182   /* A 24-bit absolute relocation suitable for the jump instructions.  */
 183   HOWTO (R_XSTORMY16_24,        /* type */
 184          0,                     /* rightshift */
 185          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 186          24,                    /* bitsize */
 187          FALSE,                 /* pc_relative */
 188          0,                     /* bitpos */
 189          complain_overflow_unsigned, /* complain_on_overflow */
 190          xstormy16_elf_24_reloc,        /* special_function */
 191          "R_XSTORMY16_24",      /* name */
 192          TRUE,                  /* partial_inplace */
 193          0,                     /* src_mask */
 194          0xffff00ff,            /* dst_mask */
 195          TRUE),                 /* pcrel_offset */
 196
 197   /* A 16 bit absolute relocation to a function pointer.  */
 198   HOWTO (R_XSTORMY16_FPTR16,    /* type */
 199          0,                     /* rightshift */
 200          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 201          16,                    /* bitsize */
 202          FALSE,                 /* pc_relative */
 203          0,                     /* bitpos */
 204          complain_overflow_bitfield, /* complain_on_overflow */
 205          bfd_elf_generic_reloc, /* special_function */
 206          "R_XSTORMY16_FPTR16",  /* name */
 207          FALSE,                 /* partial_inplace */
 208          0,                     /* src_mask */
 209          0xffffffff,            /* dst_mask */
 210          FALSE),                /* pcrel_offset */
 211
 212   /* Low order 16 bit value of a high memory address.  */
 213   HOWTO (R_XSTORMY16_LO16,      /* type */
 214          0,                     /* rightshift */
 215          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 216          16,                    /* bitsize */
 217          FALSE,                 /* pc_relative */
 218          0,                     /* bitpos */
 219          complain_overflow_dont, /* complain_on_overflow */
 220          bfd_elf_generic_reloc, /* special_function */
 221          "R_XSTORMY16_LO16",    /* name */
 222          FALSE,                 /* partial_inplace */
 223          0,                     /* src_mask */
 224          0xffff,                /* dst_mask */
 225          FALSE),                /* pcrel_offset */
 226
 227   /* High order 16 bit value of a high memory address.  */
 228   HOWTO (R_XSTORMY16_HI16,      /* type */
 229          16,                    /* rightshift */
 230          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 231          16,                    /* bitsize */
 232          FALSE,                 /* pc_relative */
 233          0,                     /* bitpos */
 234          complain_overflow_dont, /* complain_on_overflow */
 235          bfd_elf_generic_reloc, /* special_function */
 236          "R_XSTORMY16_HI16",    /* name */
 237          FALSE,                 /* partial_inplace */
 238          0,                     /* src_mask */
 239          0xffff,                /* dst_mask */
 240          FALSE),                /* pcrel_offset */
 241
 242   /* A 12 bit absolute relocation.  */
 243   HOWTO (R_XSTORMY16_12,        /* type */
 244          0,                     /* rightshift */
 245          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 246          12,                    /* bitsize */
 247          FALSE,                 /* pc_relative */
 248          0,                     /* bitpos */
 249          complain_overflow_signed, /* complain_on_overflow */
 250          bfd_elf_generic_reloc, /* special_function */
 251          "R_XSTORMY16_12",      /* name */
 252          FALSE,                 /* partial_inplace */
 253          0x0000,                /* src_mask */
 254          0x0fff,                /* dst_mask */
 255          FALSE),                /* pcrel_offset */
 256 };
 257
 258 static reloc_howto_type xstormy16_elf_howto_table2 [] =
 259 {
 260   /* GNU extension to record C++ vtable hierarchy */
 261   HOWTO (R_XSTORMY16_GNU_VTINHERIT, /* type */
 262          0,                     /* rightshift */
 263          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 264          0,                     /* bitsize */
 265          FALSE,                 /* pc_relative */
 266          0,                     /* bitpos */
 267          complain_overflow_dont, /* complain_on_overflow */
 268          NULL,                  /* special_function */
 269          "R_XSTORMY16_GNU_VTINHERIT", /* name */
 270          FALSE,                 /* partial_inplace */
 271          0,                     /* src_mask */
 272          0,                     /* dst_mask */
 273          FALSE),                /* pcrel_offset */
 274
 275   /* GNU extension to record C++ vtable member usage */
 276   HOWTO (R_XSTORMY16_GNU_VTENTRY,     /* type */
 277          0,                     /* rightshift */
 278          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 279          0,                     /* bitsize */
 280          FALSE,                 /* pc_relative */
 281          0,                     /* bitpos */
 282          complain_overflow_dont, /* complain_on_overflow */
 283          _bfd_elf_rel_vtable_reloc_fn,  /* special_function */
 284          "R_XSTORMY16_GNU_VTENTRY",   /* name */
 285          FALSE,                 /* partial_inplace */
 286          0,                     /* src_mask */
 287          0,                     /* dst_mask */
 288          FALSE),                /* pcrel_offset */
 289
 290 };
 291 \f
 292 /* Map BFD reloc types to XSTORMY16 ELF reloc types.  */
 293
 294 typedef struct xstormy16_reloc_map
 295 {
 296   bfd_reloc_code_real_type  bfd_reloc_val;
 297   unsigned int              xstormy16_reloc_val;
 298   reloc_howto_type *        table;
 299 } reloc_map;
 300
 301 static const reloc_map xstormy16_reloc_map [] =
 302 {
 303   { BFD_RELOC_NONE,                 R_XSTORMY16_NONE,          xstormy16_elf_howto_table },
 304   { BFD_RELOC_32,                   R_XSTORMY16_32,            xstormy16_elf_howto_table },
 305   { BFD_RELOC_16,                   R_XSTORMY16_16,            xstormy16_elf_howto_table },
 306   { BFD_RELOC_8,                    R_XSTORMY16_8,             xstormy16_elf_howto_table },
 307   { BFD_RELOC_32_PCREL,             R_XSTORMY16_PC32,          xstormy16_elf_howto_table },
 308   { BFD_RELOC_16_PCREL,             R_XSTORMY16_PC16,          xstormy16_elf_howto_table },
 309   { BFD_RELOC_8_PCREL,              R_XSTORMY16_PC8,           xstormy16_elf_howto_table },
 310   { BFD_RELOC_XSTORMY16_REL_12,     R_XSTORMY16_REL_12,        xstormy16_elf_howto_table },
 311   { BFD_RELOC_XSTORMY16_24,         R_XSTORMY16_24,            xstormy16_elf_howto_table },
 312   { BFD_RELOC_XSTORMY16_FPTR16,     R_XSTORMY16_FPTR16,        xstormy16_elf_howto_table },
 313   { BFD_RELOC_LO16,                 R_XSTORMY16_LO16,          xstormy16_elf_howto_table },
 314   { BFD_RELOC_HI16,                 R_XSTORMY16_HI16,          xstormy16_elf_howto_table },
 315   { BFD_RELOC_XSTORMY16_12,         R_XSTORMY16_12,            xstormy16_elf_howto_table },
 316   { BFD_RELOC_VTABLE_INHERIT,       R_XSTORMY16_GNU_VTINHERIT, xstormy16_elf_howto_table2 },
 317   { BFD_RELOC_VTABLE_ENTRY,         R_XSTORMY16_GNU_VTENTRY,   xstormy16_elf_howto_table2 },
 318 };
 319
 320 static reloc_howto_type *
 321 xstormy16_reloc_type_lookup (abfd, code)
 322      bfd * abfd ATTRIBUTE_UNUSED;
 323      bfd_reloc_code_real_type code;
 324 {
 325   unsigned int i;
 326
 327   for (i = ARRAY_SIZE (xstormy16_reloc_map); --i;)
 328     {
 329       const reloc_map * entry;
 330
 331       entry = xstormy16_reloc_map + i;
 332
 333       if (entry->bfd_reloc_val == code)
 334         return entry->table + (entry->xstormy16_reloc_val
 335                                - entry->table[0].type);
 336     }
 337
 338   return NULL;
 339 }
 340
 341 /* Set the howto pointer for an XSTORMY16 ELF reloc.  */
 342
 343 static void
 344 xstormy16_info_to_howto_rela (abfd, cache_ptr, dst)
 345      bfd * abfd ATTRIBUTE_UNUSED;
 346      arelent * cache_ptr;
 347      Elf_Internal_Rela * dst;
 348 {
 349   unsigned int r_type = ELF32_R_TYPE (dst->r_info);
 350
 351   if (r_type <= (unsigned int) R_XSTORMY16_12)
 352     cache_ptr->howto = &xstormy16_elf_howto_table [r_type];
 353   else if (r_type - R_XSTORMY16_GNU_VTINHERIT
 354            <= (unsigned int) R_XSTORMY16_GNU_VTENTRY)
 355     cache_ptr->howto
 356       = &xstormy16_elf_howto_table2 [r_type - R_XSTORMY16_GNU_VTINHERIT];
 357   else
 358     abort ();
 359 }
 360
 361 /* Handle the R_XSTORMY16_24 reloc, which has an odd bit arrangement.  */
 362
 363 static bfd_reloc_status_type
 364 xstormy16_elf_24_reloc (abfd, reloc_entry, symbol, data, input_section,
 365                          output_bfd, error_message)
 366      bfd *abfd;
 367      arelent *reloc_entry;
 368      asymbol *symbol;
 369      PTR data;
 370      asection *input_section;
 371      bfd *output_bfd;
 372      char **error_message ATTRIBUTE_UNUSED;
 373 {
 374   bfd_vma relocation, x;
 375   bfd_size_type sz;
 376
 377   if (output_bfd != NULL)
 378     {
 379       reloc_entry->address += input_section->output_offset;
 380       return bfd_reloc_ok;
 381     }
 382
 383   sz = input_section->rawsize ? input_section->rawsize : input_section->size;
 384   if (reloc_entry->address > sz)
 385     return bfd_reloc_outofrange;
 386
 387   if (bfd_is_com_section (symbol->section))
 388     relocation = 0;
 389   else
 390     relocation = symbol->value;
 391
 392   relocation += symbol->section->output_section->vma;
 393   relocation += symbol->section->output_offset;
 394   relocation += reloc_entry->addend;
 395
 396   x = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
 397   x &= 0x0000ff00;
 398   x |= relocation & 0xff;
 399   x |= (relocation << 8) & 0xffff0000;
 400   bfd_put_32 (abfd, x, (bfd_byte *) data + reloc_entry->address);
 401
 402   if (relocation & ~ (bfd_vma) 0xffffff)
 403     return bfd_reloc_overflow;
 404
 405   return bfd_reloc_ok;
 406 }
 407 \f
 408 /* We support 16-bit pointers to code above 64k by generating a thunk
 409    below 64k containing a JMPF instruction to the final address.  We
 410    cannot, unfortunately, minimize the number of thunks unless the
 411    -relax switch is given, as otherwise we have no idea where the
 412    sections will fall in the address space.  */
 413
 414 static bfd_boolean
 415 xstormy16_elf_check_relocs (abfd, info, sec, relocs)
 416      bfd *abfd;
 417      struct bfd_link_info *info;
 418      asection *sec;
 419      const Elf_Internal_Rela *relocs;
 420 {
 421   const Elf_Internal_Rela *rel, *relend;
 422   struct elf_link_hash_entry **sym_hashes;
 423   Elf_Internal_Shdr *symtab_hdr;
 424   bfd_vma *local_plt_offsets;
 425   asection *splt;
 426   bfd *dynobj;
 427
 428   if (info->relocatable)
 429     return TRUE;
 430
 431   symtab_hdr = &elf_tdata(abfd)->symtab_hdr;
 432   sym_hashes = elf_sym_hashes (abfd);
 433   local_plt_offsets = elf_local_got_offsets (abfd);
 434   splt = NULL;
 435   dynobj = elf_hash_table(info)->dynobj;
 436
 437   relend = relocs + sec->reloc_count;
 438   for (rel = relocs; rel < relend; ++rel)
 439     {
 440       unsigned long r_symndx;
 441       struct elf_link_hash_entry *h;
 442       bfd_vma *offset;
 443
 444       r_symndx = ELF32_R_SYM (rel->r_info);
 445       if (r_symndx < symtab_hdr->sh_info)
 446         h = NULL;
 447       else
 448         {
 449           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 450           while (h->root.type == bfd_link_hash_indirect
 451                  || h->root.type == bfd_link_hash_warning)
 452             h = (struct elf_link_hash_entry *) h->root.u.i.link;
 453         }
 454
 455       switch (ELF32_R_TYPE (rel->r_info))
 456         {
 457           /* This relocation describes a 16-bit pointer to a function.
 458              We may need to allocate a thunk in low memory; reserve memory
 459              for it now.  */
 460         case R_XSTORMY16_FPTR16:
 461           if (rel->r_addend != 0)
 462             {
 463               (*info->callbacks->warning)
 464                 (info, _("non-zero addend in @fptr reloc"), 0,
 465                  abfd, 0, 0);
 466             }
 467
 468           if (dynobj == NULL)
 469             elf_hash_table (info)->dynobj = dynobj = abfd;
 470           if (splt == NULL)
 471             {
 472               splt = bfd_get_section_by_name (dynobj, ".plt");
 473               if (splt == NULL)
 474                 {
 475                   splt = bfd_make_section (dynobj, ".plt");
 476                   if (splt == NULL
 477                       || ! bfd_set_section_flags (dynobj, splt,
 478                                                   (SEC_ALLOC
 479                                                    | SEC_LOAD
 480                                                    | SEC_HAS_CONTENTS
 481                                                    | SEC_IN_MEMORY
 482                                                    | SEC_LINKER_CREATED
 483                                                    | SEC_READONLY
 484                                                    | SEC_CODE))
 485                       || ! bfd_set_section_alignment (dynobj, splt, 1))
 486                     return FALSE;
 487                 }
 488             }
 489
 490           if (h != NULL)
 491             offset = &h->plt.offset;
 492           else
 493             {
 494               if (local_plt_offsets == NULL)
 495                 {
 496                   size_t size;
 497                   unsigned int i;
 498
 499                   size = symtab_hdr->sh_info * sizeof (bfd_vma);
 500                   local_plt_offsets = (bfd_vma *) bfd_alloc (abfd, size);
 501                   if (local_plt_offsets == NULL)
 502                     return FALSE;
 503                   elf_local_got_offsets (abfd) = local_plt_offsets;
 504
 505                   for (i = 0; i < symtab_hdr->sh_info; i++)
 506                     local_plt_offsets[i] = (bfd_vma) -1;
 507                 }
 508               offset = &local_plt_offsets[r_symndx];
 509             }
 510
 511           if (*offset == (bfd_vma) -1)
 512             {
 513               *offset = splt->size;
 514               splt->size += 4;
 515             }
 516           break;
 517
 518           /* This relocation describes the C++ object vtable hierarchy.
 519              Reconstruct it for later use during GC.  */
 520         case R_XSTORMY16_GNU_VTINHERIT:
 521           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
 522             return FALSE;
 523           break;
 524
 525           /* This relocation describes which C++ vtable entries are actually
 526              used.  Record for later use during GC.  */
 527         case R_XSTORMY16_GNU_VTENTRY:
 528           if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
 529             return FALSE;
 530           break;
 531         }
 532     }
 533
 534   return TRUE;
 535 }
 536
 537 /* A subroutine of xstormy16_elf_relax_section.  If the global symbol H
 538    is within the low 64k, remove any entry for it in the plt.  */
 539
 540 struct relax_plt_data
 541 {
 542   asection *splt;
 543   bfd_boolean *again;
 544 };
 545
 546 static bfd_boolean
 547 xstormy16_relax_plt_check (h, xdata)
 548      struct elf_link_hash_entry *h;
 549      PTR xdata;
 550 {
 551   struct relax_plt_data *data = (struct relax_plt_data *) xdata;
 552
 553   if (h->root.type == bfd_link_hash_warning)
 554     h = (struct elf_link_hash_entry *) h->root.u.i.link;
 555
 556   if (h->plt.offset != (bfd_vma) -1)
 557     {
 558       bfd_vma address;
 559
 560       if (h->root.type == bfd_link_hash_undefined
 561           || h->root.type == bfd_link_hash_undefweak)
 562         address = 0;
 563       else
 564         address = (h->root.u.def.section->output_section->vma
 565                    + h->root.u.def.section->output_offset
 566                    + h->root.u.def.value);
 567
 568       if (address <= 0xffff)
 569         {
 570           h->plt.offset = -1;
 571           data->splt->size -= 4;
 572           *data->again = TRUE;
 573         }
 574     }
 575
 576   return TRUE;
 577 }
 578
 579 /* A subroutine of xstormy16_elf_relax_section.  If the global symbol H
 580    previously had a plt entry, give it a new entry offset.  */
 581
 582 static bfd_boolean
 583 xstormy16_relax_plt_realloc (h, xdata)
 584      struct elf_link_hash_entry *h;
 585      PTR xdata;
 586 {
 587   bfd_vma *entry = (bfd_vma *) xdata;
 588
 589   if (h->root.type == bfd_link_hash_warning)
 590     h = (struct elf_link_hash_entry *) h->root.u.i.link;
 591
 592   if (h->plt.offset != (bfd_vma) -1)
 593     {
 594       h->plt.offset = *entry;
 595       *entry += 4;
 596     }
 597
 598   return TRUE;
 599 }
 600
 601 static bfd_boolean
 602 xstormy16_elf_relax_section (dynobj, splt, info, again)
 603      bfd *dynobj;
 604      asection *splt;
 605      struct bfd_link_info *info;
 606      bfd_boolean *again;
 607 {
 608   struct relax_plt_data relax_plt_data;
 609   bfd *ibfd;
 610
 611   /* Assume nothing changes.  */
 612   *again = FALSE;
 613
 614   if (info->relocatable)
 615     return TRUE;
 616
 617   /* We only relax the .plt section at the moment.  */
 618   if (dynobj != elf_hash_table (info)->dynobj
 619       || strcmp (splt->name, ".plt") != 0)
 620     return TRUE;
 621
 622   /* Quick check for an empty plt.  */
 623   if (splt->size == 0)
 624     return TRUE;
 625
 626   /* Map across all global symbols; see which ones happen to
 627      fall in the low 64k.  */
 628   relax_plt_data.splt = splt;
 629   relax_plt_data.again = again;
 630   elf_link_hash_traverse (elf_hash_table (info), xstormy16_relax_plt_check,
 631                           &relax_plt_data);
 632
 633   /* Likewise for local symbols, though that's somewhat less convenient
 634      as we have to walk the list of input bfds and swap in symbol data.  */
 635   for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link_next)
 636     {
 637       bfd_vma *local_plt_offsets = elf_local_got_offsets (ibfd);
 638       Elf_Internal_Shdr *symtab_hdr;
 639       Elf_Internal_Sym *isymbuf = NULL;
 640       unsigned int idx;
 641
 642       if (! local_plt_offsets)
 643         continue;
 644
 645       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
 646       if (symtab_hdr->sh_info != 0)
 647         {
 648           isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
 649           if (isymbuf == NULL)
 650             isymbuf = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
 651                                             symtab_hdr->sh_info, 0,
 652                                             NULL, NULL, NULL);
 653           if (isymbuf == NULL)
 654             return FALSE;
 655         }
 656
 657       for (idx = 0; idx < symtab_hdr->sh_info; ++idx)
 658         {
 659           Elf_Internal_Sym *isym;
 660           asection *tsec;
 661           bfd_vma address;
 662
 663           if (local_plt_offsets[idx] == (bfd_vma) -1)
 664             continue;
 665
 666           isym = &isymbuf[idx];
 667           if (isym->st_shndx == SHN_UNDEF)
 668             continue;
 669           else if (isym->st_shndx == SHN_ABS)
 670             tsec = bfd_abs_section_ptr;
 671           else if (isym->st_shndx == SHN_COMMON)
 672             tsec = bfd_com_section_ptr;
 673           else
 674             tsec = bfd_section_from_elf_index (ibfd, isym->st_shndx);
 675
 676           address = (tsec->output_section->vma
 677                      + tsec->output_offset
 678                      + isym->st_value);
 679           if (address <= 0xffff)
 680             {
 681               local_plt_offsets[idx] = -1;
 682               splt->size -= 4;
 683               *again = TRUE;
 684             }
 685         }
 686
 687       if (isymbuf != NULL
 688           && symtab_hdr->contents != (unsigned char *) isymbuf)
 689         {
 690           if (! info->keep_memory)
 691             free (isymbuf);
 692           else
 693             {
 694               /* Cache the symbols for elf_link_input_bfd.  */
 695               symtab_hdr->contents = (unsigned char *) isymbuf;
 696             }
 697         }
 698     }
 699
 700   /* If we changed anything, walk the symbols again to reallocate
 701      .plt entry addresses.  */
 702   if (*again && splt->size > 0)
 703     {
 704       bfd_vma entry = 0;
 705
 706       elf_link_hash_traverse (elf_hash_table (info),
 707                               xstormy16_relax_plt_realloc, &entry);
 708
 709       for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link_next)
 710         {
 711           bfd_vma *local_plt_offsets = elf_local_got_offsets (ibfd);
 712           unsigned int nlocals = elf_tdata (ibfd)->symtab_hdr.sh_info;
 713           unsigned int idx;
 714
 715           if (! local_plt_offsets)
 716             continue;
 717
 718           for (idx = 0; idx < nlocals; ++idx)
 719             if (local_plt_offsets[idx] != (bfd_vma) -1)
 720               {
 721                 local_plt_offsets[idx] = entry;
 722                 entry += 4;
 723               }
 724         }
 725     }
 726
 727   return TRUE;
 728 }
 729
 730 static bfd_boolean
 731 xstormy16_elf_always_size_sections (output_bfd, info)
 732      bfd *output_bfd ATTRIBUTE_UNUSED;
 733      struct bfd_link_info *info;
 734 {
 735   bfd *dynobj;
 736   asection *splt;
 737
 738   if (info->relocatable)
 739     return TRUE;
 740
 741   dynobj = elf_hash_table (info)->dynobj;
 742   if (dynobj == NULL)
 743     return TRUE;
 744
 745   splt = bfd_get_section_by_name (dynobj, ".plt");
 746   BFD_ASSERT (splt != NULL);
 747
 748   splt->contents = (bfd_byte *) bfd_zalloc (dynobj, splt->size);
 749   if (splt->contents == NULL)
 750     return FALSE;
 751
 752   return TRUE;
 753 }
 754 \f
 755 /* Relocate an XSTORMY16 ELF section.
 756
 757    The RELOCATE_SECTION function is called by the new ELF backend linker
 758    to handle the relocations for a section.
 759
 760    The relocs are always passed as Rela structures; if the section
 761    actually uses Rel structures, the r_addend field will always be
 762    zero.
 763
 764    This function is responsible for adjusting the section contents as
 765    necessary, and (if using Rela relocs and generating a relocatable
 766    output file) adjusting the reloc addend as necessary.
 767
 768    This function does not have to worry about setting the reloc
 769    address or the reloc symbol index.
 770
 771    LOCAL_SYMS is a pointer to the swapped in local symbols.
 772
 773    LOCAL_SECTIONS is an array giving the section in the input file
 774    corresponding to the st_shndx field of each local symbol.
 775
 776    The global hash table entry for the global symbols can be found
 777    via elf_sym_hashes (input_bfd).
 778
 779    When generating relocatable output, this function must handle
 780    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
 781    going to be the section symbol corresponding to the output
 782    section, which means that the addend must be adjusted
 783    accordingly.  */
 784
 785 static bfd_boolean
 786 xstormy16_elf_relocate_section (output_bfd, info, input_bfd, input_section,
 787                            contents, relocs, local_syms, local_sections)
 788      bfd *                   output_bfd ATTRIBUTE_UNUSED;
 789      struct bfd_link_info *  info;
 790      bfd *                   input_bfd;
 791      asection *              input_section;
 792      bfd_byte *              contents;
 793      Elf_Internal_Rela *     relocs;
 794      Elf_Internal_Sym *      local_syms;
 795      asection **             local_sections;
 796 {
 797   Elf_Internal_Shdr *           symtab_hdr;
 798   struct elf_link_hash_entry ** sym_hashes;
 799   Elf_Internal_Rela *           rel;
 800   Elf_Internal_Rela *           relend;
 801   bfd *dynobj;
 802   asection *splt;
 803
 804   if (info->relocatable)
 805     return TRUE;
 806
 807   symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
 808   sym_hashes = elf_sym_hashes (input_bfd);
 809   relend     = relocs + input_section->reloc_count;
 810
 811   dynobj = elf_hash_table (info)->dynobj;
 812   splt = NULL;
 813   if (dynobj != NULL)
 814     splt = bfd_get_section_by_name (dynobj, ".plt");
 815
 816   for (rel = relocs; rel < relend; rel ++)
 817     {
 818       reloc_howto_type *           howto;
 819       unsigned long                r_symndx;
 820       Elf_Internal_Sym *           sym;
 821       asection *                   sec;
 822       struct elf_link_hash_entry * h;
 823       bfd_vma                      relocation;
 824       bfd_reloc_status_type        r;
 825       const char *                 name = NULL;
 826       int                          r_type;
 827
 828       r_type = ELF32_R_TYPE (rel->r_info);
 829
 830       if (   r_type == R_XSTORMY16_GNU_VTINHERIT
 831           || r_type == R_XSTORMY16_GNU_VTENTRY)
 832         continue;
 833
 834       r_symndx = ELF32_R_SYM (rel->r_info);
 835       howto  = xstormy16_elf_howto_table + ELF32_R_TYPE (rel->r_info);
 836       h      = NULL;
 837       sym    = NULL;
 838       sec    = NULL;
 839
 840       if (r_symndx < symtab_hdr->sh_info)
 841         {
 842           sym = local_syms + r_symndx;
 843           sec = local_sections [r_symndx];
 844           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
 845
 846           name = bfd_elf_string_from_elf_section
 847             (input_bfd, symtab_hdr->sh_link, sym->st_name);
 848           name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
 849         }
 850       else
 851         {
 852           bfd_boolean unresolved_reloc, warned;
 853
 854           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
 855                                    r_symndx, symtab_hdr, sym_hashes,
 856                                    h, sec, relocation,
 857                                    unresolved_reloc, warned);
 858         }
 859
 860       switch (ELF32_R_TYPE (rel->r_info))
 861         {
 862         case R_XSTORMY16_24:
 863           {
 864             bfd_vma reloc = relocation + rel->r_addend;
 865             unsigned int x;
 866
 867             x = bfd_get_32 (input_bfd, contents + rel->r_offset);
 868             x &= 0x0000ff00;
 869             x |= reloc & 0xff;
 870             x |= (reloc << 8) & 0xffff0000;
 871             bfd_put_32 (input_bfd, x, contents + rel->r_offset);
 872
 873             if (reloc & ~0xffffff)
 874               r = bfd_reloc_overflow;
 875             else
 876               r = bfd_reloc_ok;
 877             break;
 878           }
 879
 880         case R_XSTORMY16_FPTR16:
 881           {
 882             bfd_vma *plt_offset;
 883
 884             if (h != NULL)
 885               plt_offset = &h->plt.offset;
 886             else
 887               plt_offset = elf_local_got_offsets (input_bfd) + r_symndx;
 888
 889             if (relocation <= 0xffff)
 890               {
 891                 /* If the symbol is in range for a 16-bit address, we should
 892                    have deallocated the plt entry in relax_section.  */
 893                 BFD_ASSERT (*plt_offset == (bfd_vma) -1);
 894               }
 895             else
 896               {
 897                 /* If the symbol is out of range for a 16-bit address,
 898                    we must have allocated a plt entry.  */
 899                 BFD_ASSERT (*plt_offset != (bfd_vma) -1);
 900
 901                 /* If this is the first time we've processed this symbol,
 902                    fill in the plt entry with the correct symbol address.  */
 903                 if ((*plt_offset & 1) == 0)
 904                   {
 905                     unsigned int x;
 906
 907                     x = 0x00000200;  /* jmpf */
 908                     x |= relocation & 0xff;
 909                     x |= (relocation << 8) & 0xffff0000;
 910                     bfd_put_32 (input_bfd, x, splt->contents + *plt_offset);
 911                     *plt_offset |= 1;
 912                   }
 913
 914                 relocation = (splt->output_section->vma
 915                               + splt->output_offset
 916                               + (*plt_offset & -2));
 917               }
 918             r = _bfd_final_link_relocate (howto, input_bfd, input_section,
 919                                           contents, rel->r_offset,
 920                                           relocation, 0);
 921             break;
 922           }
 923
 924         default:
 925           r = _bfd_final_link_relocate (howto, input_bfd, input_section,
 926                                         contents, rel->r_offset,
 927                                         relocation, rel->r_addend);
 928           break;
 929         }
 930
 931       if (r != bfd_reloc_ok)
 932         {
 933           const char * msg = (const char *) NULL;
 934
 935           switch (r)
 936             {
 937             case bfd_reloc_overflow:
 938               r = info->callbacks->reloc_overflow
 939                 (info, name, howto->name, (bfd_vma) 0,
 940                  input_bfd, input_section, rel->r_offset);
 941               break;
 942
 943             case bfd_reloc_undefined:
 944               r = info->callbacks->undefined_symbol
 945                 (info, name, input_bfd, input_section, rel->r_offset,
 946                  TRUE);
 947               break;
 948
 949             case bfd_reloc_outofrange:
 950               msg = _("internal error: out of range error");
 951               break;
 952
 953             case bfd_reloc_notsupported:
 954               msg = _("internal error: unsupported relocation error");
 955               break;
 956
 957             case bfd_reloc_dangerous:
 958               msg = _("internal error: dangerous relocation");
 959               break;
 960
 961             default:
 962               msg = _("internal error: unknown error");
 963               break;
 964             }
 965
 966           if (msg)
 967             r = info->callbacks->warning
 968               (info, msg, name, input_bfd, input_section, rel->r_offset);
 969
 970           if (! r)
 971             return FALSE;
 972         }
 973     }
 974
 975   return TRUE;
 976 }
 977
 978 /* This must exist if dynobj is ever set.  */
 979
 980 static bfd_boolean
 981 xstormy16_elf_finish_dynamic_sections (abfd, info)
 982      bfd *abfd ATTRIBUTE_UNUSED;
 983      struct bfd_link_info *info;
 984 {
 985   bfd *dynobj;
 986   asection *splt;
 987
 988   /* As an extra sanity check, verify that all plt entries have
 989      been filled in.  */
 990
 991   if ((dynobj = elf_hash_table (info)->dynobj) != NULL
 992       && (splt = bfd_get_section_by_name (dynobj, ".plt")) != NULL)
 993     {
 994       bfd_byte *contents = splt->contents;
 995       unsigned int i, size = splt->size;
 996       for (i = 0; i < size; i += 4)
 997         {
 998           unsigned int x = bfd_get_32 (dynobj, contents + i);
 999           BFD_ASSERT (x != 0);
1000         }
1001     }
1002
1003   return TRUE;
1004 }
1005 \f
1006 /* Return the section that should be marked against GC for a given
1007    relocation.  */
1008
1009 static asection *
1010 xstormy16_elf_gc_mark_hook (sec, info, rel, h, sym)
1011      asection *                   sec;
1012      struct bfd_link_info *       info ATTRIBUTE_UNUSED;
1013      Elf_Internal_Rela *          rel;
1014      struct elf_link_hash_entry * h;
1015      Elf_Internal_Sym *           sym;
1016 {
1017   if (h != NULL)
1018     {
1019       switch (ELF32_R_TYPE (rel->r_info))
1020         {
1021         case R_XSTORMY16_GNU_VTINHERIT:
1022         case R_XSTORMY16_GNU_VTENTRY:
1023           break;
1024
1025         default:
1026           switch (h->root.type)
1027             {
1028             case bfd_link_hash_defined:
1029             case bfd_link_hash_defweak:
1030               return h->root.u.def.section;
1031
1032             case bfd_link_hash_common:
1033               return h->root.u.c.p->section;
1034
1035             default:
1036               break;
1037             }
1038         }
1039     }
1040   else
1041     return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
1042
1043   return NULL;
1044 }
1045
1046 /* Update the got entry reference counts for the section being removed.  */
1047
1048 static bfd_boolean
1049 xstormy16_elf_gc_sweep_hook (abfd, info, sec, relocs)
1050      bfd *                     abfd ATTRIBUTE_UNUSED;
1051      struct bfd_link_info *    info ATTRIBUTE_UNUSED;
1052      asection *                sec ATTRIBUTE_UNUSED;
1053      const Elf_Internal_Rela * relocs ATTRIBUTE_UNUSED;
1054 {
1055   return TRUE;
1056 }
1057 \f
1058 #define ELF_ARCH                bfd_arch_xstormy16
1059 #define ELF_MACHINE_CODE        EM_XSTORMY16
1060 #define ELF_MAXPAGESIZE         0x100
1061
1062 #define TARGET_LITTLE_SYM       bfd_elf32_xstormy16_vec
1063 #define TARGET_LITTLE_NAME      "elf32-xstormy16"
1064
1065 #define elf_info_to_howto_rel                   NULL
1066 #define elf_info_to_howto                       xstormy16_info_to_howto_rela
1067 #define elf_backend_relocate_section            xstormy16_elf_relocate_section
1068 #define elf_backend_gc_mark_hook                xstormy16_elf_gc_mark_hook
1069 #define elf_backend_gc_sweep_hook               xstormy16_elf_gc_sweep_hook
1070 #define elf_backend_check_relocs                xstormy16_elf_check_relocs
1071 #define elf_backend_always_size_sections \
1072   xstormy16_elf_always_size_sections
1073 #define elf_backend_finish_dynamic_sections \
1074   xstormy16_elf_finish_dynamic_sections
1075
1076 #define elf_backend_can_gc_sections             1
1077 #define elf_backend_rela_normal                 1
1078
1079 #define bfd_elf32_bfd_reloc_type_lookup         xstormy16_reloc_type_lookup
1080 #define bfd_elf32_bfd_relax_section             xstormy16_elf_relax_section
1081
1082 #include "elf32-target.h"