bfd/elf32-rl78.c

   1 /* Renesas RL78 specific support for 32-bit ELF.
   2    Copyright (C) 2011
   3    Free Software Foundation, Inc.
   4
   5    This file is part of BFD, the Binary File Descriptor library.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 #include "sysdep.h"
  22 #include "bfd.h"
  23 #include "bfd_stdint.h"
  24 #include "libbfd.h"
  25 #include "elf-bfd.h"
  26 #include "elf/rl78.h"
  27 #include "libiberty.h"
  28
  29 #define valid_16bit_address(v) ((v) <= 0x0ffff || (v) >= 0xf0000)
  30
  31 #define RL78REL(n,sz,bit,shift,complain,pcrel)                               \
  32   HOWTO (R_RL78_##n, shift, sz, bit, pcrel, 0, complain_overflow_ ## complain, \
  33          bfd_elf_generic_reloc, "R_RL78_" #n, FALSE, 0, ~0, FALSE)
  34
  35 /* Note that the relocations around 0x7f are internal to this file;
  36    feel free to move them as needed to avoid conflicts with published
  37    relocation numbers.  */
  38
  39 static reloc_howto_type rl78_elf_howto_table [] =
  40 {
  41   RL78REL (NONE,         0,  0, 0, dont,     FALSE),
  42   RL78REL (DIR32,        2, 32, 0, signed,   FALSE),
  43   RL78REL (DIR24S,       2, 24, 0, signed,   FALSE),
  44   RL78REL (DIR16,        1, 16, 0, dont,     FALSE),
  45   RL78REL (DIR16U,       1, 16, 0, unsigned, FALSE),
  46   RL78REL (DIR16S,       1, 16, 0, signed,   FALSE),
  47   RL78REL (DIR8,         0,  8, 0, dont,     FALSE),
  48   RL78REL (DIR8U,        0,  8, 0, unsigned, FALSE),
  49   RL78REL (DIR8S,        0,  8, 0, signed,   FALSE),
  50   RL78REL (DIR24S_PCREL, 2, 24, 0, signed,   TRUE),
  51   RL78REL (DIR16S_PCREL, 1, 16, 0, signed,   TRUE),
  52   RL78REL (DIR8S_PCREL,  0,  8, 0, signed,   TRUE),
  53   RL78REL (DIR16UL,      1, 16, 2, unsigned, FALSE),
  54   RL78REL (DIR16UW,      1, 16, 1, unsigned, FALSE),
  55   RL78REL (DIR8UL,       0,  8, 2, unsigned, FALSE),
  56   RL78REL (DIR8UW,       0,  8, 1, unsigned, FALSE),
  57   RL78REL (DIR32_REV,    1, 16, 0, dont,     FALSE),
  58   RL78REL (DIR16_REV,    1, 16, 0, dont,     FALSE),
  59   RL78REL (DIR3U_PCREL,  0,  3, 0, dont,     TRUE),
  60
  61   EMPTY_HOWTO (0x13),
  62   EMPTY_HOWTO (0x14),
  63   EMPTY_HOWTO (0x15),
  64   EMPTY_HOWTO (0x16),
  65   EMPTY_HOWTO (0x17),
  66   EMPTY_HOWTO (0x18),
  67   EMPTY_HOWTO (0x19),
  68   EMPTY_HOWTO (0x1a),
  69   EMPTY_HOWTO (0x1b),
  70   EMPTY_HOWTO (0x1c),
  71   EMPTY_HOWTO (0x1d),
  72   EMPTY_HOWTO (0x1e),
  73   EMPTY_HOWTO (0x1f),
  74
  75   EMPTY_HOWTO (0x20),
  76   EMPTY_HOWTO (0x21),
  77   EMPTY_HOWTO (0x22),
  78   EMPTY_HOWTO (0x23),
  79   EMPTY_HOWTO (0x24),
  80   EMPTY_HOWTO (0x25),
  81   EMPTY_HOWTO (0x26),
  82   EMPTY_HOWTO (0x27),
  83   EMPTY_HOWTO (0x28),
  84   EMPTY_HOWTO (0x29),
  85   EMPTY_HOWTO (0x2a),
  86   EMPTY_HOWTO (0x2b),
  87   EMPTY_HOWTO (0x2c),
  88   EMPTY_HOWTO (0x2d),
  89
  90   EMPTY_HOWTO (0x2e),
  91   EMPTY_HOWTO (0x2f),
  92   EMPTY_HOWTO (0x30),
  93   EMPTY_HOWTO (0x31),
  94   EMPTY_HOWTO (0x32),
  95   EMPTY_HOWTO (0x33),
  96   EMPTY_HOWTO (0x34),
  97   EMPTY_HOWTO (0x35),
  98   EMPTY_HOWTO (0x36),
  99   EMPTY_HOWTO (0x37),
 100   EMPTY_HOWTO (0x38),
 101   EMPTY_HOWTO (0x39),
 102   EMPTY_HOWTO (0x3a),
 103   EMPTY_HOWTO (0x3b),
 104   EMPTY_HOWTO (0x3c),
 105   EMPTY_HOWTO (0x3d),
 106   EMPTY_HOWTO (0x3e),
 107   EMPTY_HOWTO (0x3f),
 108   EMPTY_HOWTO (0x40),
 109
 110   RL78REL (ABS32,        2, 32, 0, dont,     FALSE),
 111   RL78REL (ABS24S,       2, 24, 0, signed,   FALSE),
 112   RL78REL (ABS16,        1, 16, 0, dont,     FALSE),
 113   RL78REL (ABS16U,       1, 16, 0, unsigned, FALSE),
 114   RL78REL (ABS16S,       1, 16, 0, signed,   FALSE),
 115   RL78REL (ABS8,         0,  8, 0, dont,     FALSE),
 116   RL78REL (ABS8U,        0,  8, 0, unsigned, FALSE),
 117   RL78REL (ABS8S,        0,  8, 0, signed,   FALSE),
 118   RL78REL (ABS24S_PCREL, 2, 24, 0, signed,   TRUE),
 119   RL78REL (ABS16S_PCREL, 1, 16, 0, signed,   TRUE),
 120   RL78REL (ABS8S_PCREL,  0,  8, 0, signed,   TRUE),
 121   RL78REL (ABS16UL,      1, 16, 0, unsigned, FALSE),
 122   RL78REL (ABS16UW,      1, 16, 0, unsigned, FALSE),
 123   RL78REL (ABS8UL,       0,  8, 0, unsigned, FALSE),
 124   RL78REL (ABS8UW,       0,  8, 0, unsigned, FALSE),
 125   RL78REL (ABS32_REV,    2, 32, 0, dont,     FALSE),
 126   RL78REL (ABS16_REV,    1, 16, 0, dont,     FALSE),
 127
 128 #define STACK_REL_P(x) ((x) <= R_RL78_ABS16_REV && (x) >= R_RL78_ABS32)
 129
 130   EMPTY_HOWTO (0x52),
 131   EMPTY_HOWTO (0x53),
 132   EMPTY_HOWTO (0x54),
 133   EMPTY_HOWTO (0x55),
 134   EMPTY_HOWTO (0x56),
 135   EMPTY_HOWTO (0x57),
 136   EMPTY_HOWTO (0x58),
 137   EMPTY_HOWTO (0x59),
 138   EMPTY_HOWTO (0x5a),
 139   EMPTY_HOWTO (0x5b),
 140   EMPTY_HOWTO (0x5c),
 141   EMPTY_HOWTO (0x5d),
 142   EMPTY_HOWTO (0x5e),
 143   EMPTY_HOWTO (0x5f),
 144   EMPTY_HOWTO (0x60),
 145   EMPTY_HOWTO (0x61),
 146   EMPTY_HOWTO (0x62),
 147   EMPTY_HOWTO (0x63),
 148   EMPTY_HOWTO (0x64),
 149   EMPTY_HOWTO (0x65),
 150   EMPTY_HOWTO (0x66),
 151   EMPTY_HOWTO (0x67),
 152   EMPTY_HOWTO (0x68),
 153   EMPTY_HOWTO (0x69),
 154   EMPTY_HOWTO (0x6a),
 155   EMPTY_HOWTO (0x6b),
 156   EMPTY_HOWTO (0x6c),
 157   EMPTY_HOWTO (0x6d),
 158   EMPTY_HOWTO (0x6e),
 159   EMPTY_HOWTO (0x6f),
 160   EMPTY_HOWTO (0x70),
 161   EMPTY_HOWTO (0x71),
 162   EMPTY_HOWTO (0x72),
 163   EMPTY_HOWTO (0x73),
 164   EMPTY_HOWTO (0x74),
 165   EMPTY_HOWTO (0x75),
 166   EMPTY_HOWTO (0x76),
 167   EMPTY_HOWTO (0x77),
 168
 169   EMPTY_HOWTO (0x78),
 170   EMPTY_HOWTO (0x79),
 171   EMPTY_HOWTO (0x7a),
 172   EMPTY_HOWTO (0x7b),
 173   EMPTY_HOWTO (0x7c),
 174   EMPTY_HOWTO (0x7d),
 175   EMPTY_HOWTO (0x7e),
 176   EMPTY_HOWTO (0x7f),
 177
 178   RL78REL (SYM,       2, 32, 0, dont, FALSE),
 179   RL78REL (OPneg,     2, 32, 0, dont, FALSE),
 180   RL78REL (OPadd,     2, 32, 0, dont, FALSE),
 181   RL78REL (OPsub,     2, 32, 0, dont, FALSE),
 182   RL78REL (OPmul,     2, 32, 0, dont, FALSE),
 183   RL78REL (OPdiv,     2, 32, 0, dont, FALSE),
 184   RL78REL (OPshla,    2, 32, 0, dont, FALSE),
 185   RL78REL (OPshra,    2, 32, 0, dont, FALSE),
 186   RL78REL (OPsctsize, 2, 32, 0, dont, FALSE),
 187   EMPTY_HOWTO (0x89),
 188   EMPTY_HOWTO (0x8a),
 189   EMPTY_HOWTO (0x8b),
 190   EMPTY_HOWTO (0x8c),
 191   RL78REL (OPscttop,  2, 32, 0, dont, FALSE),
 192   EMPTY_HOWTO (0x8e),
 193   EMPTY_HOWTO (0x8f),
 194   RL78REL (OPand,     2, 32, 0, dont, FALSE),
 195   RL78REL (OPor,      2, 32, 0, dont, FALSE),
 196   RL78REL (OPxor,     2, 32, 0, dont, FALSE),
 197   RL78REL (OPnot,     2, 32, 0, dont, FALSE),
 198   RL78REL (OPmod,     2, 32, 0, dont, FALSE),
 199   RL78REL (OPromtop,  2, 32, 0, dont, FALSE),
 200   RL78REL (OPramtop,  2, 32, 0, dont, FALSE)
 201 };
 202 \f
 203 /* Map BFD reloc types to RL78 ELF reloc types.  */
 204
 205 struct rl78_reloc_map
 206 {
 207   bfd_reloc_code_real_type  bfd_reloc_val;
 208   unsigned int              rl78_reloc_val;
 209 };
 210
 211 static const struct rl78_reloc_map rl78_reloc_map [] =
 212 {
 213   { BFD_RELOC_NONE,             R_RL78_NONE },
 214   { BFD_RELOC_8,                R_RL78_DIR8S },
 215   { BFD_RELOC_16,               R_RL78_DIR16S },
 216   { BFD_RELOC_24,               R_RL78_DIR24S },
 217   { BFD_RELOC_32,               R_RL78_DIR32 },
 218   { BFD_RELOC_RL78_16_OP,       R_RL78_DIR16 },
 219   { BFD_RELOC_RL78_DIR3U_PCREL, R_RL78_DIR3U_PCREL },
 220   { BFD_RELOC_8_PCREL,          R_RL78_DIR8S_PCREL },
 221   { BFD_RELOC_16_PCREL,         R_RL78_DIR16S_PCREL },
 222   { BFD_RELOC_24_PCREL,         R_RL78_DIR24S_PCREL },
 223   { BFD_RELOC_RL78_8U,          R_RL78_DIR8U },
 224   { BFD_RELOC_RL78_16U,         R_RL78_DIR16U },
 225   { BFD_RELOC_RL78_SYM,         R_RL78_SYM },
 226   { BFD_RELOC_RL78_OP_SUBTRACT, R_RL78_OPsub },
 227   { BFD_RELOC_RL78_OP_NEG,      R_RL78_OPneg },
 228   { BFD_RELOC_RL78_OP_AND,      R_RL78_OPand },
 229   { BFD_RELOC_RL78_OP_SHRA,     R_RL78_OPshra },
 230   { BFD_RELOC_RL78_ABS8,        R_RL78_ABS8 },
 231   { BFD_RELOC_RL78_ABS16,       R_RL78_ABS16 },
 232   { BFD_RELOC_RL78_ABS16_REV,   R_RL78_ABS16_REV },
 233   { BFD_RELOC_RL78_ABS32,       R_RL78_ABS32 },
 234   { BFD_RELOC_RL78_ABS32_REV,   R_RL78_ABS32_REV },
 235   { BFD_RELOC_RL78_ABS16UL,     R_RL78_ABS16UL },
 236   { BFD_RELOC_RL78_ABS16UW,     R_RL78_ABS16UW },
 237   { BFD_RELOC_RL78_ABS16U,      R_RL78_ABS16U }
 238 };
 239
 240 static reloc_howto_type *
 241 rl78_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
 242                         bfd_reloc_code_real_type code)
 243 {
 244   unsigned int i;
 245
 246   if (code == BFD_RELOC_RL78_32_OP)
 247     return rl78_elf_howto_table + R_RL78_DIR32;
 248
 249   for (i = ARRAY_SIZE (rl78_reloc_map); --i;)
 250     if (rl78_reloc_map [i].bfd_reloc_val == code)
 251       return rl78_elf_howto_table + rl78_reloc_map[i].rl78_reloc_val;
 252
 253   return NULL;
 254 }
 255
 256 static reloc_howto_type *
 257 rl78_reloc_name_lookup (bfd * abfd ATTRIBUTE_UNUSED, const char * r_name)
 258 {
 259   unsigned int i;
 260
 261   for (i = 0; i < ARRAY_SIZE (rl78_elf_howto_table); i++)
 262     if (rl78_elf_howto_table[i].name != NULL
 263         && strcasecmp (rl78_elf_howto_table[i].name, r_name) == 0)
 264       return rl78_elf_howto_table + i;
 265
 266   return NULL;
 267 }
 268
 269 /* Set the howto pointer for an RL78 ELF reloc.  */
 270
 271 static void
 272 rl78_info_to_howto_rela (bfd *               abfd ATTRIBUTE_UNUSED,
 273                          arelent *           cache_ptr,
 274                          Elf_Internal_Rela * dst)
 275 {
 276   unsigned int r_type;
 277
 278   r_type = ELF32_R_TYPE (dst->r_info);
 279   BFD_ASSERT (r_type < (unsigned int) R_RL78_max);
 280   cache_ptr->howto = rl78_elf_howto_table + r_type;
 281 }
 282 \f
 283 static bfd_vma
 284 get_symbol_value (const char *            name,
 285                   bfd_reloc_status_type * status,
 286                   struct bfd_link_info *  info,
 287                   bfd *                   input_bfd,
 288                   asection *              input_section,
 289                   int                     offset)
 290 {
 291   bfd_vma value = 0;
 292   struct bfd_link_hash_entry * h;
 293
 294   h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
 295
 296   if (h == NULL
 297       || (h->type != bfd_link_hash_defined
 298           && h->type != bfd_link_hash_defweak))
 299     * status = info->callbacks->undefined_symbol
 300       (info, name, input_bfd, input_section, offset, TRUE);
 301   else
 302     value = (h->u.def.value
 303              + h->u.def.section->output_section->vma
 304              + h->u.def.section->output_offset);
 305
 306   return value;
 307 }
 308
 309 static bfd_vma
 310 get_romstart (bfd_reloc_status_type * status,
 311               struct bfd_link_info *  info,
 312               bfd *                   abfd,
 313               asection *              sec,
 314               int                     offset)
 315 {
 316   static bfd_boolean cached = FALSE;
 317   static bfd_vma     cached_value = 0;
 318
 319   if (!cached)
 320     {
 321       cached_value = get_symbol_value ("_start", status, info, abfd, sec, offset);
 322       cached = TRUE;
 323     }
 324   return cached_value;
 325 }
 326
 327 static bfd_vma
 328 get_ramstart (bfd_reloc_status_type * status,
 329               struct bfd_link_info *  info,
 330               bfd *                   abfd,
 331               asection *              sec,
 332               int                     offset)
 333 {
 334   static bfd_boolean cached = FALSE;
 335   static bfd_vma     cached_value = 0;
 336
 337   if (!cached)
 338     {
 339       cached_value = get_symbol_value ("__datastart", status, info, abfd, sec, offset);
 340       cached = TRUE;
 341     }
 342   return cached_value;
 343 }
 344
 345 #define NUM_STACK_ENTRIES 16
 346 static int32_t rl78_stack [ NUM_STACK_ENTRIES ];
 347 static unsigned int rl78_stack_top;
 348
 349 #define RL78_STACK_PUSH(val)                    \
 350   do                                            \
 351     {                                           \
 352       if (rl78_stack_top < NUM_STACK_ENTRIES)   \
 353         rl78_stack [rl78_stack_top ++] = (val); \
 354       else                                      \
 355         r = bfd_reloc_dangerous;                \
 356     }                                           \
 357   while (0)
 358
 359 #define RL78_STACK_POP(dest)                    \
 360   do                                            \
 361     {                                           \
 362       if (rl78_stack_top > 0)                   \
 363         (dest) = rl78_stack [-- rl78_stack_top];        \
 364       else                                      \
 365         (dest) = 0, r = bfd_reloc_dangerous;    \
 366     }                                           \
 367   while (0)
 368
 369 /* Relocate an RL78 ELF section.
 370    There is some attempt to make this function usable for many architectures,
 371    both USE_REL and USE_RELA ['twould be nice if such a critter existed],
 372    if only to serve as a learning tool.
 373
 374    The RELOCATE_SECTION function is called by the new ELF backend linker
 375    to handle the relocations for a section.
 376
 377    The relocs are always passed as Rela structures; if the section
 378    actually uses Rel structures, the r_addend field will always be
 379    zero.
 380
 381    This function is responsible for adjusting the section contents as
 382    necessary, and (if using Rela relocs and generating a relocatable
 383    output file) adjusting the reloc addend as necessary.
 384
 385    This function does not have to worry about setting the reloc
 386    address or the reloc symbol index.
 387
 388    LOCAL_SYMS is a pointer to the swapped in local symbols.
 389
 390    LOCAL_SECTIONS is an array giving the section in the input file
 391    corresponding to the st_shndx field of each local symbol.
 392
 393    The global hash table entry for the global symbols can be found
 394    via elf_sym_hashes (input_bfd).
 395
 396    When generating relocatable output, this function must handle
 397    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
 398    going to be the section symbol corresponding to the output
 399    section, which means that the addend must be adjusted
 400    accordingly.  */
 401
 402 static bfd_boolean
 403 rl78_elf_relocate_section
 404     (bfd *                   output_bfd,
 405      struct bfd_link_info *  info,
 406      bfd *                   input_bfd,
 407      asection *              input_section,
 408      bfd_byte *              contents,
 409      Elf_Internal_Rela *     relocs,
 410      Elf_Internal_Sym *      local_syms,
 411      asection **             local_sections)
 412 {
 413   Elf_Internal_Shdr *           symtab_hdr;
 414   struct elf_link_hash_entry ** sym_hashes;
 415   Elf_Internal_Rela *           rel;
 416   Elf_Internal_Rela *           relend;
 417   bfd *dynobj;
 418   asection *splt;
 419
 420   symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
 421   sym_hashes = elf_sym_hashes (input_bfd);
 422   relend     = relocs + input_section->reloc_count;
 423
 424   dynobj = elf_hash_table (info)->dynobj;
 425   splt = NULL;
 426   if (dynobj != NULL)
 427     splt = bfd_get_section_by_name (dynobj, ".plt");
 428
 429   for (rel = relocs; rel < relend; rel ++)
 430     {
 431       reloc_howto_type *           howto;
 432       unsigned long                r_symndx;
 433       Elf_Internal_Sym *           sym;
 434       asection *                   sec;
 435       struct elf_link_hash_entry * h;
 436       bfd_vma                      relocation;
 437       bfd_reloc_status_type        r;
 438       const char *                 name = NULL;
 439       bfd_boolean                  unresolved_reloc = TRUE;
 440       int                          r_type;
 441
 442       r_type = ELF32_R_TYPE (rel->r_info);
 443       r_symndx = ELF32_R_SYM (rel->r_info);
 444
 445       howto  = rl78_elf_howto_table + ELF32_R_TYPE (rel->r_info);
 446       h      = NULL;
 447       sym    = NULL;
 448       sec    = NULL;
 449       relocation = 0;
 450
 451       if (r_symndx < symtab_hdr->sh_info)
 452         {
 453           sym = local_syms + r_symndx;
 454           sec = local_sections [r_symndx];
 455           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, & sec, rel);
 456
 457           name = bfd_elf_string_from_elf_section
 458             (input_bfd, symtab_hdr->sh_link, sym->st_name);
 459           name = (sym->st_name == 0) ? bfd_section_name (input_bfd, sec) : name;
 460         }
 461       else
 462         {
 463           bfd_boolean warned;
 464
 465           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
 466                                    r_symndx, symtab_hdr, sym_hashes, h,
 467                                    sec, relocation, unresolved_reloc,
 468                                    warned);
 469
 470           name = h->root.root.string;
 471         }
 472
 473       if (sec != NULL && elf_discarded_section (sec))
 474         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
 475                                          rel, relend, howto, contents);
 476
 477       if (info->relocatable)
 478         {
 479           /* This is a relocatable link.  We don't have to change
 480              anything, unless the reloc is against a section symbol,
 481              in which case we have to adjust according to where the
 482              section symbol winds up in the output section.  */
 483           if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
 484             rel->r_addend += sec->output_offset;
 485           continue;
 486         }
 487
 488       switch (ELF32_R_TYPE (rel->r_info))
 489         {
 490         case R_RL78_DIR16S:
 491           {
 492             bfd_vma *plt_offset;
 493
 494             if (h != NULL)
 495               plt_offset = &h->plt.offset;
 496             else
 497               plt_offset = elf_local_got_offsets (input_bfd) + r_symndx;
 498
 499             /*      printf("%s: rel %x plt %d\n", h ? h->root.root.string : "(none)",
 500                     relocation, *plt_offset);*/
 501             if (valid_16bit_address (relocation))
 502               {
 503                 /* If the symbol is in range for a 16-bit address, we should
 504                    have deallocated the plt entry in relax_section.  */
 505                 BFD_ASSERT (*plt_offset == (bfd_vma) -1);
 506               }
 507             else
 508               {
 509                 /* If the symbol is out of range for a 16-bit address,
 510                    we must have allocated a plt entry.  */
 511                 BFD_ASSERT (*plt_offset != (bfd_vma) -1);
 512
 513                 /* If this is the first time we've processed this symbol,
 514                    fill in the plt entry with the correct symbol address.  */
 515                 if ((*plt_offset & 1) == 0)
 516                   {
 517                     unsigned int x;
 518
 519                     x = 0x000000ec;  /* br !!abs24 */
 520                     x |= (relocation << 8) & 0xffffff00;
 521                     bfd_put_32 (input_bfd, x, splt->contents + *plt_offset);
 522                     *plt_offset |= 1;
 523                   }
 524
 525                 relocation = (splt->output_section->vma
 526                               + splt->output_offset
 527                               + (*plt_offset & -2));
 528                 if (name)
 529                 {
 530                   char *newname = bfd_malloc (strlen(name)+5);
 531                   strcpy (newname, name);
 532                   strcat(newname, ".plt");
 533                   _bfd_generic_link_add_one_symbol (info,
 534                                                     input_bfd,
 535                                                     newname,
 536                                                     BSF_FUNCTION | BSF_WEAK,
 537                                                     splt,
 538                                                     (*plt_offset & -2),
 539                                                     0,
 540                                                     1,
 541                                                     0,
 542                                                     0);
 543                 }
 544               }
 545           }
 546           break;
 547         }
 548
 549       if (h != NULL && h->root.type == bfd_link_hash_undefweak)
 550         /* If the symbol is undefined and weak
 551            then the relocation resolves to zero.  */
 552         relocation = 0;
 553       else
 554         {
 555           if (howto->pc_relative)
 556             {
 557               relocation -= (input_section->output_section->vma
 558                              + input_section->output_offset
 559                              + rel->r_offset);
 560               relocation -= bfd_get_reloc_size (howto);
 561             }
 562
 563           relocation += rel->r_addend;
 564         }
 565
 566       r = bfd_reloc_ok;
 567
 568 #define RANGE(a,b) if (a > (long) relocation || (long) relocation > b) r = bfd_reloc_overflow
 569 #define ALIGN(m)   if (relocation & m) r = bfd_reloc_other;
 570 #define OP(i)      (contents[rel->r_offset + (i)])
 571
 572       /* Opcode relocs are always big endian.  Data relocs are bi-endian.  */
 573       switch (r_type)
 574         {
 575         case R_RL78_NONE:
 576           break;
 577
 578         case R_RL78_DIR8S_PCREL:
 579           RANGE (-128, 127);
 580           OP (0) = relocation;
 581           break;
 582
 583         case R_RL78_DIR8S:
 584           RANGE (-128, 255);
 585           OP (0) = relocation;
 586           break;
 587
 588         case R_RL78_DIR8U:
 589           RANGE (0, 255);
 590           OP (0) = relocation;
 591           break;
 592
 593         case R_RL78_DIR16S_PCREL:
 594           RANGE (-32768, 32767);
 595           OP (0) = relocation;
 596           OP (1) = relocation >> 8;
 597           break;
 598
 599         case R_RL78_DIR16S:
 600           if ((relocation & 0xf0000) == 0xf0000)
 601             relocation &= 0xffff;
 602           RANGE (-32768, 65535);
 603           OP (0) = relocation;
 604           OP (1) = relocation >> 8;
 605           break;
 606
 607         case R_RL78_DIR16U:
 608           RANGE (0, 65536);
 609           OP (0) = relocation;
 610           OP (1) = relocation >> 8;
 611           break;
 612
 613         case R_RL78_DIR16:
 614           RANGE (-32768, 65536);
 615           OP (0) = relocation;
 616           OP (1) = relocation >> 8;
 617           break;
 618
 619         case R_RL78_DIR16_REV:
 620           RANGE (-32768, 65536);
 621           OP (1) = relocation;
 622           OP (0) = relocation >> 8;
 623           break;
 624
 625         case R_RL78_DIR3U_PCREL:
 626           RANGE (3, 10);
 627           OP (0) &= 0xf8;
 628           OP (0) |= relocation & 0x07;
 629           break;
 630
 631         case R_RL78_DIR24S_PCREL:
 632           RANGE (-0x800000, 0x7fffff);
 633           OP (0) = relocation;
 634           OP (1) = relocation >> 8;
 635           OP (2) = relocation >> 16;
 636           break;
 637
 638         case R_RL78_DIR24S:
 639           RANGE (-0x800000, 0x7fffff);
 640           OP (0) = relocation;
 641           OP (1) = relocation >> 8;
 642           OP (2) = relocation >> 16;
 643           break;
 644
 645         case R_RL78_DIR32:
 646           OP (0) = relocation;
 647           OP (1) = relocation >> 8;
 648           OP (2) = relocation >> 16;
 649           OP (3) = relocation >> 24;
 650           break;
 651
 652         case R_RL78_DIR32_REV:
 653           OP (3) = relocation;
 654           OP (2) = relocation >> 8;
 655           OP (1) = relocation >> 16;
 656           OP (0) = relocation >> 24;
 657           break;
 658
 659           /* Complex reloc handling:  */
 660
 661         case R_RL78_ABS32:
 662           RL78_STACK_POP (relocation);
 663           OP (0) = relocation;
 664           OP (1) = relocation >> 8;
 665           OP (2) = relocation >> 16;
 666           OP (3) = relocation >> 24;
 667           break;
 668
 669         case R_RL78_ABS32_REV:
 670           RL78_STACK_POP (relocation);
 671           OP (3) = relocation;
 672           OP (2) = relocation >> 8;
 673           OP (1) = relocation >> 16;
 674           OP (0) = relocation >> 24;
 675           break;
 676
 677         case R_RL78_ABS24S_PCREL:
 678         case R_RL78_ABS24S:
 679           RL78_STACK_POP (relocation);
 680           RANGE (-0x800000, 0x7fffff);
 681           OP (0) = relocation;
 682           OP (1) = relocation >> 8;
 683           OP (2) = relocation >> 16;
 684           break;
 685
 686         case R_RL78_ABS16:
 687           RL78_STACK_POP (relocation);
 688           RANGE (-32768, 65535);
 689           OP (0) = relocation;
 690           OP (1) = relocation >> 8;
 691           break;
 692
 693         case R_RL78_ABS16_REV:
 694           RL78_STACK_POP (relocation);
 695           RANGE (-32768, 65535);
 696           OP (1) = relocation;
 697           OP (0) = relocation >> 8;
 698           break;
 699
 700         case R_RL78_ABS16S_PCREL:
 701         case R_RL78_ABS16S:
 702           RL78_STACK_POP (relocation);
 703           RANGE (-32768, 32767);
 704           OP (0) = relocation;
 705           OP (1) = relocation >> 8;
 706           break;
 707
 708         case R_RL78_ABS16U:
 709           RL78_STACK_POP (relocation);
 710           RANGE (0, 65536);
 711           OP (0) = relocation;
 712           OP (1) = relocation >> 8;
 713           break;
 714
 715         case R_RL78_ABS16UL:
 716           RL78_STACK_POP (relocation);
 717           relocation >>= 2;
 718           RANGE (0, 65536);
 719           OP (0) = relocation;
 720           OP (1) = relocation >> 8;
 721           break;
 722
 723         case R_RL78_ABS16UW:
 724           RL78_STACK_POP (relocation);
 725           relocation >>= 1;
 726           RANGE (0, 65536);
 727           OP (0) = relocation;
 728           OP (1) = relocation >> 8;
 729           break;
 730
 731         case R_RL78_ABS8:
 732           RL78_STACK_POP (relocation);
 733           RANGE (-128, 255);
 734           OP (0) = relocation;
 735           break;
 736
 737         case R_RL78_ABS8U:
 738           RL78_STACK_POP (relocation);
 739           RANGE (0, 255);
 740           OP (0) = relocation;
 741           break;
 742
 743         case R_RL78_ABS8UL:
 744           RL78_STACK_POP (relocation);
 745           relocation >>= 2;
 746           RANGE (0, 255);
 747           OP (0) = relocation;
 748           break;
 749
 750         case R_RL78_ABS8UW:
 751           RL78_STACK_POP (relocation);
 752           relocation >>= 1;
 753           RANGE (0, 255);
 754           OP (0) = relocation;
 755           break;
 756
 757         case R_RL78_ABS8S_PCREL:
 758         case R_RL78_ABS8S:
 759           RL78_STACK_POP (relocation);
 760           RANGE (-128, 127);
 761           OP (0) = relocation;
 762           break;
 763
 764         case R_RL78_SYM:
 765           if (r_symndx < symtab_hdr->sh_info)
 766             RL78_STACK_PUSH (sec->output_section->vma
 767                            + sec->output_offset
 768                            + sym->st_value
 769                            + rel->r_addend);
 770           else
 771             {
 772               if (h != NULL
 773                   && (h->root.type == bfd_link_hash_defined
 774                       || h->root.type == bfd_link_hash_defweak))
 775                 RL78_STACK_PUSH (h->root.u.def.value
 776                                + sec->output_section->vma
 777                                + sec->output_offset
 778                                + rel->r_addend);
 779               else
 780                 _bfd_error_handler (_("Warning: RL78_SYM reloc with an unknown symbol"));
 781             }
 782           break;
 783
 784         case R_RL78_OPneg:
 785           {
 786             int32_t tmp;
 787
 788             RL78_STACK_POP (tmp);
 789             tmp = - tmp;
 790             RL78_STACK_PUSH (tmp);
 791           }
 792           break;
 793
 794         case R_RL78_OPadd:
 795           {
 796             int32_t tmp1, tmp2;
 797
 798             RL78_STACK_POP (tmp2);
 799             RL78_STACK_POP (tmp1);
 800             tmp1 += tmp2;
 801             RL78_STACK_PUSH (tmp1);
 802           }
 803           break;
 804
 805         case R_RL78_OPsub:
 806           {
 807             int32_t tmp1, tmp2;
 808
 809             RL78_STACK_POP (tmp2);
 810             RL78_STACK_POP (tmp1);
 811             tmp2 -= tmp1;
 812             RL78_STACK_PUSH (tmp2);
 813           }
 814           break;
 815
 816         case R_RL78_OPmul:
 817           {
 818             int32_t tmp1, tmp2;
 819
 820             RL78_STACK_POP (tmp2);
 821             RL78_STACK_POP (tmp1);
 822             tmp1 *= tmp2;
 823             RL78_STACK_PUSH (tmp1);
 824           }
 825           break;
 826
 827         case R_RL78_OPdiv:
 828           {
 829             int32_t tmp1, tmp2;
 830
 831             RL78_STACK_POP (tmp2);
 832             RL78_STACK_POP (tmp1);
 833             tmp1 /= tmp2;
 834             RL78_STACK_PUSH (tmp1);
 835           }
 836           break;
 837
 838         case R_RL78_OPshla:
 839           {
 840             int32_t tmp1, tmp2;
 841
 842             RL78_STACK_POP (tmp2);
 843             RL78_STACK_POP (tmp1);
 844             tmp1 <<= tmp2;
 845             RL78_STACK_PUSH (tmp1);
 846           }
 847           break;
 848
 849         case R_RL78_OPshra:
 850           {
 851             int32_t tmp1, tmp2;
 852
 853             RL78_STACK_POP (tmp2);
 854             RL78_STACK_POP (tmp1);
 855             tmp1 >>= tmp2;
 856             RL78_STACK_PUSH (tmp1);
 857           }
 858           break;
 859
 860         case R_RL78_OPsctsize:
 861           RL78_STACK_PUSH (input_section->size);
 862           break;
 863
 864         case R_RL78_OPscttop:
 865           RL78_STACK_PUSH (input_section->output_section->vma);
 866           break;
 867
 868         case R_RL78_OPand:
 869           {
 870             int32_t tmp1, tmp2;
 871
 872             RL78_STACK_POP (tmp2);
 873             RL78_STACK_POP (tmp1);
 874             tmp1 &= tmp2;
 875             RL78_STACK_PUSH (tmp1);
 876           }
 877           break;
 878
 879         case R_RL78_OPor:
 880           {
 881             int32_t tmp1, tmp2;
 882
 883             RL78_STACK_POP (tmp2);
 884             RL78_STACK_POP (tmp1);
 885             tmp1 |= tmp2;
 886             RL78_STACK_PUSH (tmp1);
 887           }
 888           break;
 889
 890         case R_RL78_OPxor:
 891           {
 892             int32_t tmp1, tmp2;
 893
 894             RL78_STACK_POP (tmp2);
 895             RL78_STACK_POP (tmp1);
 896             tmp1 ^= tmp2;
 897             RL78_STACK_PUSH (tmp1);
 898           }
 899           break;
 900
 901         case R_RL78_OPnot:
 902           {
 903             int32_t tmp;
 904
 905             RL78_STACK_POP (tmp);
 906             tmp = ~ tmp;
 907             RL78_STACK_PUSH (tmp);
 908           }
 909           break;
 910
 911         case R_RL78_OPmod:
 912           {
 913             int32_t tmp1, tmp2;
 914
 915             RL78_STACK_POP (tmp2);
 916             RL78_STACK_POP (tmp1);
 917             tmp1 %= tmp2;
 918             RL78_STACK_PUSH (tmp1);
 919           }
 920           break;
 921
 922         case R_RL78_OPromtop:
 923           RL78_STACK_PUSH (get_romstart (&r, info, input_bfd, input_section, rel->r_offset));
 924           break;
 925
 926         case R_RL78_OPramtop:
 927           RL78_STACK_PUSH (get_ramstart (&r, info, input_bfd, input_section, rel->r_offset));
 928           break;
 929
 930         default:
 931           r = bfd_reloc_notsupported;
 932           break;
 933         }
 934
 935       if (r != bfd_reloc_ok)
 936         {
 937           const char * msg = NULL;
 938
 939           switch (r)
 940             {
 941             case bfd_reloc_overflow:
 942               /* Catch the case of a missing function declaration
 943                  and emit a more helpful error message.  */
 944               if (r_type == R_RL78_DIR24S_PCREL)
 945                 msg = _("%B(%A): error: call to undefined function '%s'");
 946               else
 947                 r = info->callbacks->reloc_overflow
 948                   (info, (h ? &h->root : NULL), name, howto->name, (bfd_vma) 0,
 949                    input_bfd, input_section, rel->r_offset);
 950               break;
 951
 952             case bfd_reloc_undefined:
 953               r = info->callbacks->undefined_symbol
 954                 (info, name, input_bfd, input_section, rel->r_offset,
 955                  TRUE);
 956               break;
 957
 958             case bfd_reloc_other:
 959               msg = _("%B(%A): warning: unaligned access to symbol '%s' in the small data area");
 960               break;
 961
 962             case bfd_reloc_outofrange:
 963               msg = _("%B(%A): internal error: out of range error");
 964               break;
 965
 966             case bfd_reloc_notsupported:
 967               msg = _("%B(%A): internal error: unsupported relocation error");
 968               break;
 969
 970             case bfd_reloc_dangerous:
 971               msg = _("%B(%A): internal error: dangerous relocation");
 972               break;
 973
 974             default:
 975               msg = _("%B(%A): internal error: unknown error");
 976               break;
 977             }
 978
 979           if (msg)
 980             _bfd_error_handler (msg, input_bfd, input_section, name);
 981
 982           if (! r)
 983             return FALSE;
 984         }
 985     }
 986
 987   return TRUE;
 988 }
 989 \f
 990 /* Function to set the ELF flag bits.  */
 991
 992 static bfd_boolean
 993 rl78_elf_set_private_flags (bfd * abfd, flagword flags)
 994 {
 995   elf_elfheader (abfd)->e_flags = flags;
 996   elf_flags_init (abfd) = TRUE;
 997   return TRUE;
 998 }
 999
1000 static bfd_boolean no_warn_mismatch = FALSE;
1001
1002 void bfd_elf32_rl78_set_target_flags (bfd_boolean);
1003
1004 void
1005 bfd_elf32_rl78_set_target_flags (bfd_boolean user_no_warn_mismatch)
1006 {
1007   no_warn_mismatch = user_no_warn_mismatch;
1008 }
1009
1010 /* Merge backend specific data from an object file to the output
1011    object file when linking.  */
1012
1013 static bfd_boolean
1014 rl78_elf_merge_private_bfd_data (bfd * ibfd, bfd * obfd)
1015 {
1016   flagword new_flags;
1017   bfd_boolean error = FALSE;
1018
1019   new_flags = elf_elfheader (ibfd)->e_flags;
1020
1021   if (!elf_flags_init (obfd))
1022     {
1023       /* First call, no flags set.  */
1024       elf_flags_init (obfd) = TRUE;
1025       elf_elfheader (obfd)->e_flags = new_flags;
1026     }
1027
1028   return !error;
1029 }
1030 \f
1031 static bfd_boolean
1032 rl78_elf_print_private_bfd_data (bfd * abfd, void * ptr)
1033 {
1034   FILE * file = (FILE *) ptr;
1035   flagword flags;
1036
1037   BFD_ASSERT (abfd != NULL && ptr != NULL);
1038
1039   /* Print normal ELF private data.  */
1040   _bfd_elf_print_private_bfd_data (abfd, ptr);
1041
1042   flags = elf_elfheader (abfd)->e_flags;
1043   fprintf (file, _("private flags = 0x%lx:"), (long) flags);
1044
1045   fputc ('\n', file);
1046   return TRUE;
1047 }
1048
1049 /* Return the MACH for an e_flags value.  */
1050
1051 static int
1052 elf32_rl78_machine (bfd * abfd)
1053 {
1054   if ((elf_elfheader (abfd)->e_flags & EF_RL78_CPU_MASK) == EF_RL78_CPU_RL78)
1055     return bfd_mach_rl78;
1056
1057   return 0;
1058 }
1059
1060 static bfd_boolean
1061 rl78_elf_object_p (bfd * abfd)
1062 {
1063   bfd_default_set_arch_mach (abfd, bfd_arch_rl78,
1064                              elf32_rl78_machine (abfd));
1065   return TRUE;
1066 }
1067  \f
1068 #ifdef DEBUG
1069 void
1070 rl78_dump_symtab (bfd * abfd, void * internal_syms, void * external_syms)
1071 {
1072   size_t locsymcount;
1073   Elf_Internal_Sym * isymbuf;
1074   Elf_Internal_Sym * isymend;
1075   Elf_Internal_Sym * isym;
1076   Elf_Internal_Shdr * symtab_hdr;
1077   bfd_boolean free_internal = FALSE, free_external = FALSE;
1078   char * st_info_str;
1079   char * st_info_stb_str;
1080   char * st_other_str;
1081   char * st_shndx_str;
1082
1083   if (! internal_syms)
1084     {
1085       internal_syms = bfd_malloc (1000);
1086       free_internal = 1;
1087     }
1088   if (! external_syms)
1089     {
1090       external_syms = bfd_malloc (1000);
1091       free_external = 1;
1092     }
1093
1094   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1095   locsymcount = symtab_hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
1096   if (free_internal)
1097     isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1098                                     symtab_hdr->sh_info, 0,
1099                                     internal_syms, external_syms, NULL);
1100   else
1101     isymbuf = internal_syms;
1102   isymend = isymbuf + locsymcount;
1103
1104   for (isym = isymbuf ; isym < isymend ; isym++)
1105     {
1106       switch (ELF_ST_TYPE (isym->st_info))
1107         {
1108         case STT_FUNC: st_info_str = "STT_FUNC";
1109         case STT_SECTION: st_info_str = "STT_SECTION";
1110         case STT_FILE: st_info_str = "STT_FILE";
1111         case STT_OBJECT: st_info_str = "STT_OBJECT";
1112         case STT_TLS: st_info_str = "STT_TLS";
1113         default: st_info_str = "";
1114         }
1115       switch (ELF_ST_BIND (isym->st_info))
1116         {
1117         case STB_LOCAL: st_info_stb_str = "STB_LOCAL";
1118         case STB_GLOBAL: st_info_stb_str = "STB_GLOBAL";
1119         default: st_info_stb_str = "";
1120         }
1121       switch (ELF_ST_VISIBILITY (isym->st_other))
1122         {
1123         case STV_DEFAULT: st_other_str = "STV_DEFAULT";
1124         case STV_INTERNAL: st_other_str = "STV_INTERNAL";
1125         case STV_PROTECTED: st_other_str = "STV_PROTECTED";
1126         default: st_other_str = "";
1127         }
1128       switch (isym->st_shndx)
1129         {
1130         case SHN_ABS: st_shndx_str = "SHN_ABS";
1131         case SHN_COMMON: st_shndx_str = "SHN_COMMON";
1132         case SHN_UNDEF: st_shndx_str = "SHN_UNDEF";
1133         default: st_shndx_str = "";
1134         }
1135
1136       printf ("isym = %p st_value = %lx st_size = %lx st_name = (%lu) %s "
1137               "st_info = (%d) %s %s st_other = (%d) %s st_shndx = (%d) %s\n",
1138               isym,
1139               (unsigned long) isym->st_value,
1140               (unsigned long) isym->st_size,
1141               isym->st_name,
1142               bfd_elf_string_from_elf_section (abfd, symtab_hdr->sh_link,
1143                                                isym->st_name),
1144               isym->st_info, st_info_str, st_info_stb_str,
1145               isym->st_other, st_other_str,
1146               isym->st_shndx, st_shndx_str);
1147     }
1148   if (free_internal)
1149     free (internal_syms);
1150   if (free_external)
1151     free (external_syms);
1152 }
1153
1154 char *
1155 rl78_get_reloc (long reloc)
1156 {
1157   if (0 <= reloc && reloc < R_RL78_max)
1158     return rl78_elf_howto_table[reloc].name;
1159   return "";
1160 }
1161 #endif /* DEBUG */
1162
1163 \f
1164 /* support PLT for 16-bit references to 24-bit functions.  */
1165
1166 /* We support 16-bit pointers to code above 64k by generating a thunk
1167    below 64k containing a JMP instruction to the final address.  */
1168
1169 static bfd_boolean
1170 rl78_elf_check_relocs
1171     (bfd *                     abfd,
1172      struct bfd_link_info *    info,
1173      asection *                sec,
1174      const Elf_Internal_Rela * relocs)
1175 {
1176   Elf_Internal_Shdr *           symtab_hdr;
1177   struct elf_link_hash_entry ** sym_hashes;
1178   const Elf_Internal_Rela *     rel;
1179   const Elf_Internal_Rela *     rel_end;
1180   bfd_vma *local_plt_offsets;
1181   asection *splt;
1182   bfd *dynobj;
1183
1184   if (info->relocatable)
1185     return TRUE;
1186
1187   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1188   sym_hashes = elf_sym_hashes (abfd);
1189   local_plt_offsets = elf_local_got_offsets (abfd);
1190   splt = NULL;
1191   dynobj = elf_hash_table(info)->dynobj;
1192
1193   rel_end = relocs + sec->reloc_count;
1194   for (rel = relocs; rel < rel_end; rel++)
1195     {
1196       struct elf_link_hash_entry *h;
1197       unsigned long r_symndx;
1198       bfd_vma *offset;
1199
1200       r_symndx = ELF32_R_SYM (rel->r_info);
1201       if (r_symndx < symtab_hdr->sh_info)
1202         h = NULL;
1203       else
1204         {
1205           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1206           while (h->root.type == bfd_link_hash_indirect
1207                  || h->root.type == bfd_link_hash_warning)
1208             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1209         }
1210
1211       switch (ELF32_R_TYPE (rel->r_info))
1212         {
1213           /* This relocation describes a 16-bit pointer to a function.
1214              We may need to allocate a thunk in low memory; reserve memory
1215              for it now.  */
1216         case R_RL78_DIR16S:
1217           if (dynobj == NULL)
1218             elf_hash_table (info)->dynobj = dynobj = abfd;
1219           if (splt == NULL)
1220             {
1221               splt = bfd_get_section_by_name (dynobj, ".plt");
1222               if (splt == NULL)
1223                 {
1224                   flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
1225                                     | SEC_IN_MEMORY | SEC_LINKER_CREATED
1226                                     | SEC_READONLY | SEC_CODE);
1227                   splt = bfd_make_section_with_flags (dynobj, ".plt", flags);
1228                   if (splt == NULL
1229                       || ! bfd_set_section_alignment (dynobj, splt, 1))
1230                     return FALSE;
1231                 }
1232             }
1233
1234           if (h != NULL)
1235             offset = &h->plt.offset;
1236           else
1237             {
1238               if (local_plt_offsets == NULL)
1239                 {
1240                   size_t size;
1241                   unsigned int i;
1242
1243                   size = symtab_hdr->sh_info * sizeof (bfd_vma);
1244                   local_plt_offsets = (bfd_vma *) bfd_alloc (abfd, size);
1245                   if (local_plt_offsets == NULL)
1246                     return FALSE;
1247                   elf_local_got_offsets (abfd) = local_plt_offsets;
1248
1249                   for (i = 0; i < symtab_hdr->sh_info; i++)
1250                     local_plt_offsets[i] = (bfd_vma) -1;
1251                 }
1252               offset = &local_plt_offsets[r_symndx];
1253             }
1254
1255           if (*offset == (bfd_vma) -1)
1256             {
1257               *offset = splt->size;
1258               splt->size += 4;
1259             }
1260           break;
1261         }
1262     }
1263
1264   return TRUE;
1265 }
1266
1267 /* This must exist if dynobj is ever set.  */
1268
1269 static bfd_boolean
1270 rl78_elf_finish_dynamic_sections (bfd *abfd ATTRIBUTE_UNUSED,
1271                                   struct bfd_link_info *info)
1272 {
1273   bfd *dynobj;
1274   asection *splt;
1275
1276   /* As an extra sanity check, verify that all plt entries have
1277      been filled in.  */
1278
1279   if ((dynobj = elf_hash_table (info)->dynobj) != NULL
1280       && (splt = bfd_get_section_by_name (dynobj, ".plt")) != NULL)
1281     {
1282       bfd_byte *contents = splt->contents;
1283       unsigned int i, size = splt->size;
1284       for (i = 0; i < size; i += 4)
1285         {
1286           unsigned int x = bfd_get_32 (dynobj, contents + i);
1287           BFD_ASSERT (x != 0);
1288         }
1289     }
1290
1291   return TRUE;
1292 }
1293
1294 static bfd_boolean
1295 rl78_elf_always_size_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
1296                                struct bfd_link_info *info)
1297 {
1298   bfd *dynobj;
1299   asection *splt;
1300
1301   if (info->relocatable)
1302     return TRUE;
1303
1304   dynobj = elf_hash_table (info)->dynobj;
1305   if (dynobj == NULL)
1306     return TRUE;
1307
1308   splt = bfd_get_section_by_name (dynobj, ".plt");
1309   BFD_ASSERT (splt != NULL);
1310
1311   splt->contents = (bfd_byte *) bfd_zalloc (dynobj, splt->size);
1312   if (splt->contents == NULL)
1313     return FALSE;
1314
1315   return TRUE;
1316 }
1317
1318 \f
1319
1320 /* Handle relaxing.  */
1321
1322 /* A subroutine of rl78_elf_relax_section.  If the global symbol H
1323    is within the low 64k, remove any entry for it in the plt.  */
1324
1325 struct relax_plt_data
1326 {
1327   asection *splt;
1328   bfd_boolean *again;
1329 };
1330
1331 static bfd_boolean
1332 rl78_relax_plt_check (struct elf_link_hash_entry *h,
1333                       PTR xdata)
1334 {
1335   struct relax_plt_data *data = (struct relax_plt_data *) xdata;
1336
1337   if (h->plt.offset != (bfd_vma) -1)
1338     {
1339       bfd_vma address;
1340
1341       if (h->root.type == bfd_link_hash_undefined
1342           || h->root.type == bfd_link_hash_undefweak)
1343         address = 0;
1344       else
1345         address = (h->root.u.def.section->output_section->vma
1346                    + h->root.u.def.section->output_offset
1347                    + h->root.u.def.value);
1348
1349       if (valid_16bit_address (address))
1350         {
1351           h->plt.offset = -1;
1352           data->splt->size -= 4;
1353           *data->again = TRUE;
1354         }
1355     }
1356
1357   return TRUE;
1358 }
1359
1360 /* A subroutine of rl78_elf_relax_section.  If the global symbol H
1361    previously had a plt entry, give it a new entry offset.  */
1362
1363 static bfd_boolean
1364 rl78_relax_plt_realloc (struct elf_link_hash_entry *h,
1365                         PTR xdata)
1366 {
1367   bfd_vma *entry = (bfd_vma *) xdata;
1368
1369   if (h->plt.offset != (bfd_vma) -1)
1370     {
1371       h->plt.offset = *entry;
1372       *entry += 4;
1373     }
1374
1375   return TRUE;
1376 }
1377
1378 static bfd_boolean
1379 rl78_elf_relax_plt_section (bfd *dynobj,
1380                             asection *splt,
1381                             struct bfd_link_info *info,
1382                             bfd_boolean *again)
1383 {
1384   struct relax_plt_data relax_plt_data;
1385   bfd *ibfd;
1386
1387   /* Assume nothing changes.  */
1388   *again = FALSE;
1389
1390   if (info->relocatable)
1391     return TRUE;
1392
1393   /* We only relax the .plt section at the moment.  */
1394   if (dynobj != elf_hash_table (info)->dynobj
1395       || strcmp (splt->name, ".plt") != 0)
1396     return TRUE;
1397
1398   /* Quick check for an empty plt.  */
1399   if (splt->size == 0)
1400     return TRUE;
1401
1402   /* Map across all global symbols; see which ones happen to
1403      fall in the low 64k.  */
1404   relax_plt_data.splt = splt;
1405   relax_plt_data.again = again;
1406   elf_link_hash_traverse (elf_hash_table (info), rl78_relax_plt_check,
1407                           &relax_plt_data);
1408
1409   /* Likewise for local symbols, though that's somewhat less convenient
1410      as we have to walk the list of input bfds and swap in symbol data.  */
1411   for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link_next)
1412     {
1413       bfd_vma *local_plt_offsets = elf_local_got_offsets (ibfd);
1414       Elf_Internal_Shdr *symtab_hdr;
1415       Elf_Internal_Sym *isymbuf = NULL;
1416       unsigned int idx;
1417
1418       if (! local_plt_offsets)
1419         continue;
1420
1421       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
1422       if (symtab_hdr->sh_info != 0)
1423         {
1424           isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1425           if (isymbuf == NULL)
1426             isymbuf = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
1427                                             symtab_hdr->sh_info, 0,
1428                                             NULL, NULL, NULL);
1429           if (isymbuf == NULL)
1430             return FALSE;
1431         }
1432
1433       for (idx = 0; idx < symtab_hdr->sh_info; ++idx)
1434         {
1435           Elf_Internal_Sym *isym;
1436           asection *tsec;
1437           bfd_vma address;
1438
1439           if (local_plt_offsets[idx] == (bfd_vma) -1)
1440             continue;
1441
1442           isym = &isymbuf[idx];
1443           if (isym->st_shndx == SHN_UNDEF)
1444             continue;
1445           else if (isym->st_shndx == SHN_ABS)
1446             tsec = bfd_abs_section_ptr;
1447           else if (isym->st_shndx == SHN_COMMON)
1448             tsec = bfd_com_section_ptr;
1449           else
1450             tsec = bfd_section_from_elf_index (ibfd, isym->st_shndx);
1451
1452           address = (tsec->output_section->vma
1453                      + tsec->output_offset
1454                      + isym->st_value);
1455           if (valid_16bit_address (address))
1456             {
1457               local_plt_offsets[idx] = -1;
1458               splt->size -= 4;
1459               *again = TRUE;
1460             }
1461         }
1462
1463       if (isymbuf != NULL
1464           && symtab_hdr->contents != (unsigned char *) isymbuf)
1465         {
1466           if (! info->keep_memory)
1467             free (isymbuf);
1468           else
1469             {
1470               /* Cache the symbols for elf_link_input_bfd.  */
1471               symtab_hdr->contents = (unsigned char *) isymbuf;
1472             }
1473         }
1474     }
1475
1476   /* If we changed anything, walk the symbols again to reallocate
1477      .plt entry addresses.  */
1478   if (*again && splt->size > 0)
1479     {
1480       bfd_vma entry = 0;
1481
1482       elf_link_hash_traverse (elf_hash_table (info),
1483                               rl78_relax_plt_realloc, &entry);
1484
1485       for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link_next)
1486         {
1487           bfd_vma *local_plt_offsets = elf_local_got_offsets (ibfd);
1488           unsigned int nlocals = elf_tdata (ibfd)->symtab_hdr.sh_info;
1489           unsigned int idx;
1490
1491           if (! local_plt_offsets)
1492             continue;
1493
1494           for (idx = 0; idx < nlocals; ++idx)
1495             if (local_plt_offsets[idx] != (bfd_vma) -1)
1496               {
1497                 local_plt_offsets[idx] = entry;
1498                 entry += 4;
1499               }
1500         }
1501     }
1502
1503   return TRUE;
1504 }
1505
1506 static bfd_boolean
1507 rl78_elf_relax_section
1508     (bfd *                  abfd,
1509      asection *             sec,
1510      struct bfd_link_info * link_info,
1511      bfd_boolean *          again)
1512 {
1513   if (abfd == elf_hash_table (link_info)->dynobj
1514       && strcmp (sec->name, ".plt") == 0)
1515     return rl78_elf_relax_plt_section (abfd, sec, link_info, again);
1516
1517   /* Assume nothing changes.  */
1518   *again = FALSE;
1519   return TRUE;
1520 }
1521
1522 \f
1523
1524 #define ELF_ARCH                bfd_arch_rl78
1525 #define ELF_MACHINE_CODE        EM_RL78
1526 #define ELF_MAXPAGESIZE         0x1000
1527
1528 #define TARGET_LITTLE_SYM       bfd_elf32_rl78_vec
1529 #define TARGET_LITTLE_NAME      "elf32-rl78"
1530
1531 #define elf_info_to_howto_rel                   NULL
1532 #define elf_info_to_howto                       rl78_info_to_howto_rela
1533 #define elf_backend_object_p                    rl78_elf_object_p
1534 #define elf_backend_relocate_section            rl78_elf_relocate_section
1535 #define elf_symbol_leading_char                 ('_')
1536 #define elf_backend_can_gc_sections             1
1537
1538 #define bfd_elf32_bfd_reloc_type_lookup         rl78_reloc_type_lookup
1539 #define bfd_elf32_bfd_reloc_name_lookup         rl78_reloc_name_lookup
1540 #define bfd_elf32_bfd_set_private_flags         rl78_elf_set_private_flags
1541 #define bfd_elf32_bfd_merge_private_bfd_data    rl78_elf_merge_private_bfd_data
1542 #define bfd_elf32_bfd_print_private_bfd_data    rl78_elf_print_private_bfd_data
1543
1544 #define bfd_elf32_bfd_relax_section             rl78_elf_relax_section
1545 #define elf_backend_check_relocs                rl78_elf_check_relocs
1546 #define elf_backend_always_size_sections \
1547   rl78_elf_always_size_sections
1548 #define elf_backend_finish_dynamic_sections \
1549   rl78_elf_finish_dynamic_sections
1550
1551 #include "elf32-target.h"