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   RL78REL (RH_RELAX, 0,  0, 0, dont,     FALSE),
  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   { BFD_RELOC_RL78_RELAX,       R_RL78_RH_RELAX }
 239 };
 240
 241 static reloc_howto_type *
 242 rl78_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
 243                         bfd_reloc_code_real_type code)
 244 {
 245   unsigned int i;
 246
 247   if (code == BFD_RELOC_RL78_32_OP)
 248     return rl78_elf_howto_table + R_RL78_DIR32;
 249
 250   for (i = ARRAY_SIZE (rl78_reloc_map); --i;)
 251     if (rl78_reloc_map [i].bfd_reloc_val == code)
 252       return rl78_elf_howto_table + rl78_reloc_map[i].rl78_reloc_val;
 253
 254   return NULL;
 255 }
 256
 257 static reloc_howto_type *
 258 rl78_reloc_name_lookup (bfd * abfd ATTRIBUTE_UNUSED, const char * r_name)
 259 {
 260   unsigned int i;
 261
 262   for (i = 0; i < ARRAY_SIZE (rl78_elf_howto_table); i++)
 263     if (rl78_elf_howto_table[i].name != NULL
 264         && strcasecmp (rl78_elf_howto_table[i].name, r_name) == 0)
 265       return rl78_elf_howto_table + i;
 266
 267   return NULL;
 268 }
 269
 270 /* Set the howto pointer for an RL78 ELF reloc.  */
 271
 272 static void
 273 rl78_info_to_howto_rela (bfd *               abfd ATTRIBUTE_UNUSED,
 274                          arelent *           cache_ptr,
 275                          Elf_Internal_Rela * dst)
 276 {
 277   unsigned int r_type;
 278
 279   r_type = ELF32_R_TYPE (dst->r_info);
 280   BFD_ASSERT (r_type < (unsigned int) R_RL78_max);
 281   cache_ptr->howto = rl78_elf_howto_table + r_type;
 282 }
 283 \f
 284 static bfd_vma
 285 get_symbol_value (const char *            name,
 286                   bfd_reloc_status_type * status,
 287                   struct bfd_link_info *  info,
 288                   bfd *                   input_bfd,
 289                   asection *              input_section,
 290                   int                     offset)
 291 {
 292   bfd_vma value = 0;
 293   struct bfd_link_hash_entry * h;
 294
 295   h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
 296
 297   if (h == NULL
 298       || (h->type != bfd_link_hash_defined
 299           && h->type != bfd_link_hash_defweak))
 300     * status = info->callbacks->undefined_symbol
 301       (info, name, input_bfd, input_section, offset, TRUE);
 302   else
 303     value = (h->u.def.value
 304              + h->u.def.section->output_section->vma
 305              + h->u.def.section->output_offset);
 306
 307   return value;
 308 }
 309
 310 static bfd_vma
 311 get_romstart (bfd_reloc_status_type * status,
 312               struct bfd_link_info *  info,
 313               bfd *                   abfd,
 314               asection *              sec,
 315               int                     offset)
 316 {
 317   static bfd_boolean cached = FALSE;
 318   static bfd_vma     cached_value = 0;
 319
 320   if (!cached)
 321     {
 322       cached_value = get_symbol_value ("_start", status, info, abfd, sec, offset);
 323       cached = TRUE;
 324     }
 325   return cached_value;
 326 }
 327
 328 static bfd_vma
 329 get_ramstart (bfd_reloc_status_type * status,
 330               struct bfd_link_info *  info,
 331               bfd *                   abfd,
 332               asection *              sec,
 333               int                     offset)
 334 {
 335   static bfd_boolean cached = FALSE;
 336   static bfd_vma     cached_value = 0;
 337
 338   if (!cached)
 339     {
 340       cached_value = get_symbol_value ("__datastart", status, info, abfd, sec, offset);
 341       cached = TRUE;
 342     }
 343   return cached_value;
 344 }
 345
 346 #define NUM_STACK_ENTRIES 16
 347 static int32_t rl78_stack [ NUM_STACK_ENTRIES ];
 348 static unsigned int rl78_stack_top;
 349
 350 #define RL78_STACK_PUSH(val)                    \
 351   do                                            \
 352     {                                           \
 353       if (rl78_stack_top < NUM_STACK_ENTRIES)   \
 354         rl78_stack [rl78_stack_top ++] = (val); \
 355       else                                      \
 356         r = bfd_reloc_dangerous;                \
 357     }                                           \
 358   while (0)
 359
 360 #define RL78_STACK_POP(dest)                    \
 361   do                                            \
 362     {                                           \
 363       if (rl78_stack_top > 0)                   \
 364         (dest) = rl78_stack [-- rl78_stack_top];        \
 365       else                                      \
 366         (dest) = 0, r = bfd_reloc_dangerous;    \
 367     }                                           \
 368   while (0)
 369
 370 /* Relocate an RL78 ELF section.
 371    There is some attempt to make this function usable for many architectures,
 372    both USE_REL and USE_RELA ['twould be nice if such a critter existed],
 373    if only to serve as a learning tool.
 374
 375    The RELOCATE_SECTION function is called by the new ELF backend linker
 376    to handle the relocations for a section.
 377
 378    The relocs are always passed as Rela structures; if the section
 379    actually uses Rel structures, the r_addend field will always be
 380    zero.
 381
 382    This function is responsible for adjusting the section contents as
 383    necessary, and (if using Rela relocs and generating a relocatable
 384    output file) adjusting the reloc addend as necessary.
 385
 386    This function does not have to worry about setting the reloc
 387    address or the reloc symbol index.
 388
 389    LOCAL_SYMS is a pointer to the swapped in local symbols.
 390
 391    LOCAL_SECTIONS is an array giving the section in the input file
 392    corresponding to the st_shndx field of each local symbol.
 393
 394    The global hash table entry for the global symbols can be found
 395    via elf_sym_hashes (input_bfd).
 396
 397    When generating relocatable output, this function must handle
 398    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
 399    going to be the section symbol corresponding to the output
 400    section, which means that the addend must be adjusted
 401    accordingly.  */
 402
 403 static bfd_boolean
 404 rl78_elf_relocate_section
 405     (bfd *                   output_bfd,
 406      struct bfd_link_info *  info,
 407      bfd *                   input_bfd,
 408      asection *              input_section,
 409      bfd_byte *              contents,
 410      Elf_Internal_Rela *     relocs,
 411      Elf_Internal_Sym *      local_syms,
 412      asection **             local_sections)
 413 {
 414   Elf_Internal_Shdr *           symtab_hdr;
 415   struct elf_link_hash_entry ** sym_hashes;
 416   Elf_Internal_Rela *           rel;
 417   Elf_Internal_Rela *           relend;
 418   bfd *dynobj;
 419   asection *splt;
 420
 421   symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
 422   sym_hashes = elf_sym_hashes (input_bfd);
 423   relend     = relocs + input_section->reloc_count;
 424
 425   dynobj = elf_hash_table (info)->dynobj;
 426   splt = NULL;
 427   if (dynobj != NULL)
 428     splt = bfd_get_section_by_name (dynobj, ".plt");
 429
 430   for (rel = relocs; rel < relend; rel ++)
 431     {
 432       reloc_howto_type *           howto;
 433       unsigned long                r_symndx;
 434       Elf_Internal_Sym *           sym;
 435       asection *                   sec;
 436       struct elf_link_hash_entry * h;
 437       bfd_vma                      relocation;
 438       bfd_reloc_status_type        r;
 439       const char *                 name = NULL;
 440       bfd_boolean                  unresolved_reloc = TRUE;
 441       int                          r_type;
 442
 443       r_type = ELF32_R_TYPE (rel->r_info);
 444       r_symndx = ELF32_R_SYM (rel->r_info);
 445
 446       howto  = rl78_elf_howto_table + ELF32_R_TYPE (rel->r_info);
 447       h      = NULL;
 448       sym    = NULL;
 449       sec    = NULL;
 450       relocation = 0;
 451
 452       if (r_symndx < symtab_hdr->sh_info)
 453         {
 454           sym = local_syms + r_symndx;
 455           sec = local_sections [r_symndx];
 456           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, & sec, rel);
 457
 458           name = bfd_elf_string_from_elf_section
 459             (input_bfd, symtab_hdr->sh_link, sym->st_name);
 460           name = (sym->st_name == 0) ? bfd_section_name (input_bfd, sec) : name;
 461         }
 462       else
 463         {
 464           bfd_boolean warned;
 465
 466           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
 467                                    r_symndx, symtab_hdr, sym_hashes, h,
 468                                    sec, relocation, unresolved_reloc,
 469                                    warned);
 470
 471           name = h->root.root.string;
 472         }
 473
 474       if (sec != NULL && elf_discarded_section (sec))
 475         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
 476                                          rel, relend, howto, contents);
 477
 478       if (info->relocatable)
 479         {
 480           /* This is a relocatable link.  We don't have to change
 481              anything, unless the reloc is against a section symbol,
 482              in which case we have to adjust according to where the
 483              section symbol winds up in the output section.  */
 484           if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
 485             rel->r_addend += sec->output_offset;
 486           continue;
 487         }
 488
 489       switch (ELF32_R_TYPE (rel->r_info))
 490         {
 491         case R_RL78_DIR16S:
 492           {
 493             bfd_vma *plt_offset;
 494
 495             if (h != NULL)
 496               plt_offset = &h->plt.offset;
 497             else
 498               plt_offset = elf_local_got_offsets (input_bfd) + r_symndx;
 499
 500             /*      printf("%s: rel %x plt %d\n", h ? h->root.root.string : "(none)",
 501                     relocation, *plt_offset);*/
 502             if (! valid_16bit_address (relocation))
 503               {
 504                 /* If this is the first time we've processed this symbol,
 505                    fill in the plt entry with the correct symbol address.  */
 506                 if ((*plt_offset & 1) == 0)
 507                   {
 508                     unsigned int x;
 509
 510                     x = 0x000000ec;  /* br !!abs24 */
 511                     x |= (relocation << 8) & 0xffffff00;
 512                     bfd_put_32 (input_bfd, x, splt->contents + *plt_offset);
 513                     *plt_offset |= 1;
 514                   }
 515
 516                 relocation = (splt->output_section->vma
 517                               + splt->output_offset
 518                               + (*plt_offset & -2));
 519                 if (name)
 520                 {
 521                   char *newname = bfd_malloc (strlen(name)+5);
 522                   strcpy (newname, name);
 523                   strcat(newname, ".plt");
 524                   _bfd_generic_link_add_one_symbol (info,
 525                                                     input_bfd,
 526                                                     newname,
 527                                                     BSF_FUNCTION | BSF_WEAK,
 528                                                     splt,
 529                                                     (*plt_offset & -2),
 530                                                     0,
 531                                                     1,
 532                                                     0,
 533                                                     0);
 534                 }
 535               }
 536           }
 537           break;
 538         }
 539
 540       if (h != NULL && h->root.type == bfd_link_hash_undefweak)
 541         /* If the symbol is undefined and weak
 542            then the relocation resolves to zero.  */
 543         relocation = 0;
 544       else
 545         {
 546           if (howto->pc_relative)
 547             {
 548               relocation -= (input_section->output_section->vma
 549                              + input_section->output_offset
 550                              + rel->r_offset);
 551               relocation -= bfd_get_reloc_size (howto);
 552             }
 553
 554           relocation += rel->r_addend;
 555         }
 556
 557       r = bfd_reloc_ok;
 558
 559 #define RANGE(a,b) if (a > (long) relocation || (long) relocation > b) r = bfd_reloc_overflow
 560 #define ALIGN(m)   if (relocation & m) r = bfd_reloc_other;
 561 #define OP(i)      (contents[rel->r_offset + (i)])
 562
 563       /* Opcode relocs are always big endian.  Data relocs are bi-endian.  */
 564       switch (r_type)
 565         {
 566         case R_RL78_NONE:
 567           break;
 568
 569         case R_RL78_RH_RELAX:
 570           break;
 571
 572         case R_RL78_DIR8S_PCREL:
 573           RANGE (-128, 127);
 574           OP (0) = relocation;
 575           break;
 576
 577         case R_RL78_DIR8S:
 578           RANGE (-128, 255);
 579           OP (0) = relocation;
 580           break;
 581
 582         case R_RL78_DIR8U:
 583           RANGE (0, 255);
 584           OP (0) = relocation;
 585           break;
 586
 587         case R_RL78_DIR16S_PCREL:
 588           RANGE (-32768, 32767);
 589           OP (0) = relocation;
 590           OP (1) = relocation >> 8;
 591           break;
 592
 593         case R_RL78_DIR16S:
 594           if ((relocation & 0xf0000) == 0xf0000)
 595             relocation &= 0xffff;
 596           RANGE (-32768, 65535);
 597           OP (0) = relocation;
 598           OP (1) = relocation >> 8;
 599           break;
 600
 601         case R_RL78_DIR16U:
 602           RANGE (0, 65536);
 603           OP (0) = relocation;
 604           OP (1) = relocation >> 8;
 605           break;
 606
 607         case R_RL78_DIR16:
 608           RANGE (-32768, 65536);
 609           OP (0) = relocation;
 610           OP (1) = relocation >> 8;
 611           break;
 612
 613         case R_RL78_DIR16_REV:
 614           RANGE (-32768, 65536);
 615           OP (1) = relocation;
 616           OP (0) = relocation >> 8;
 617           break;
 618
 619         case R_RL78_DIR3U_PCREL:
 620           RANGE (3, 10);
 621           OP (0) &= 0xf8;
 622           OP (0) |= relocation & 0x07;
 623           break;
 624
 625         case R_RL78_DIR24S_PCREL:
 626           RANGE (-0x800000, 0x7fffff);
 627           OP (0) = relocation;
 628           OP (1) = relocation >> 8;
 629           OP (2) = relocation >> 16;
 630           break;
 631
 632         case R_RL78_DIR24S:
 633           RANGE (-0x800000, 0x7fffff);
 634           OP (0) = relocation;
 635           OP (1) = relocation >> 8;
 636           OP (2) = relocation >> 16;
 637           break;
 638
 639         case R_RL78_DIR32:
 640           OP (0) = relocation;
 641           OP (1) = relocation >> 8;
 642           OP (2) = relocation >> 16;
 643           OP (3) = relocation >> 24;
 644           break;
 645
 646         case R_RL78_DIR32_REV:
 647           OP (3) = relocation;
 648           OP (2) = relocation >> 8;
 649           OP (1) = relocation >> 16;
 650           OP (0) = relocation >> 24;
 651           break;
 652
 653         case R_RL78_RH_SFR:
 654           printf("SFR 0x%lx\n", relocation);
 655           RANGE (0xfff00, 0xfffff);
 656           OP (0) = relocation & 0xff;
 657           break;
 658
 659         case R_RL78_RH_SADDR:
 660           printf("SADDR 0x%lx\n", relocation);
 661           RANGE (0xffe20, 0xfff1f);
 662           OP (0) = relocation & 0xff;
 663           printf(" - in\n");
 664           break;
 665
 666           /* Complex reloc handling:  */
 667
 668         case R_RL78_ABS32:
 669           RL78_STACK_POP (relocation);
 670           OP (0) = relocation;
 671           OP (1) = relocation >> 8;
 672           OP (2) = relocation >> 16;
 673           OP (3) = relocation >> 24;
 674           break;
 675
 676         case R_RL78_ABS32_REV:
 677           RL78_STACK_POP (relocation);
 678           OP (3) = relocation;
 679           OP (2) = relocation >> 8;
 680           OP (1) = relocation >> 16;
 681           OP (0) = relocation >> 24;
 682           break;
 683
 684         case R_RL78_ABS24S_PCREL:
 685         case R_RL78_ABS24S:
 686           RL78_STACK_POP (relocation);
 687           RANGE (-0x800000, 0x7fffff);
 688           OP (0) = relocation;
 689           OP (1) = relocation >> 8;
 690           OP (2) = relocation >> 16;
 691           break;
 692
 693         case R_RL78_ABS16:
 694           RL78_STACK_POP (relocation);
 695           RANGE (-32768, 65535);
 696           OP (0) = relocation;
 697           OP (1) = relocation >> 8;
 698           break;
 699
 700         case R_RL78_ABS16_REV:
 701           RL78_STACK_POP (relocation);
 702           RANGE (-32768, 65535);
 703           OP (1) = relocation;
 704           OP (0) = relocation >> 8;
 705           break;
 706
 707         case R_RL78_ABS16S_PCREL:
 708         case R_RL78_ABS16S:
 709           RL78_STACK_POP (relocation);
 710           RANGE (-32768, 32767);
 711           OP (0) = relocation;
 712           OP (1) = relocation >> 8;
 713           break;
 714
 715         case R_RL78_ABS16U:
 716           RL78_STACK_POP (relocation);
 717           RANGE (0, 65536);
 718           OP (0) = relocation;
 719           OP (1) = relocation >> 8;
 720           break;
 721
 722         case R_RL78_ABS16UL:
 723           RL78_STACK_POP (relocation);
 724           relocation >>= 2;
 725           RANGE (0, 65536);
 726           OP (0) = relocation;
 727           OP (1) = relocation >> 8;
 728           break;
 729
 730         case R_RL78_ABS16UW:
 731           RL78_STACK_POP (relocation);
 732           relocation >>= 1;
 733           RANGE (0, 65536);
 734           OP (0) = relocation;
 735           OP (1) = relocation >> 8;
 736           break;
 737
 738         case R_RL78_ABS8:
 739           RL78_STACK_POP (relocation);
 740           RANGE (-128, 255);
 741           OP (0) = relocation;
 742           break;
 743
 744         case R_RL78_ABS8U:
 745           RL78_STACK_POP (relocation);
 746           RANGE (0, 255);
 747           OP (0) = relocation;
 748           break;
 749
 750         case R_RL78_ABS8UL:
 751           RL78_STACK_POP (relocation);
 752           relocation >>= 2;
 753           RANGE (0, 255);
 754           OP (0) = relocation;
 755           break;
 756
 757         case R_RL78_ABS8UW:
 758           RL78_STACK_POP (relocation);
 759           relocation >>= 1;
 760           RANGE (0, 255);
 761           OP (0) = relocation;
 762           break;
 763
 764         case R_RL78_ABS8S_PCREL:
 765         case R_RL78_ABS8S:
 766           RL78_STACK_POP (relocation);
 767           RANGE (-128, 127);
 768           OP (0) = relocation;
 769           break;
 770
 771         case R_RL78_SYM:
 772           if (r_symndx < symtab_hdr->sh_info)
 773             RL78_STACK_PUSH (sec->output_section->vma
 774                            + sec->output_offset
 775                            + sym->st_value
 776                            + rel->r_addend);
 777           else
 778             {
 779               if (h != NULL
 780                   && (h->root.type == bfd_link_hash_defined
 781                       || h->root.type == bfd_link_hash_defweak))
 782                 RL78_STACK_PUSH (h->root.u.def.value
 783                                + sec->output_section->vma
 784                                + sec->output_offset
 785                                + rel->r_addend);
 786               else
 787                 _bfd_error_handler (_("Warning: RL78_SYM reloc with an unknown symbol"));
 788             }
 789           break;
 790
 791         case R_RL78_OPneg:
 792           {
 793             int32_t tmp;
 794
 795             RL78_STACK_POP (tmp);
 796             tmp = - tmp;
 797             RL78_STACK_PUSH (tmp);
 798           }
 799           break;
 800
 801         case R_RL78_OPadd:
 802           {
 803             int32_t tmp1, tmp2;
 804
 805             RL78_STACK_POP (tmp2);
 806             RL78_STACK_POP (tmp1);
 807             tmp1 += tmp2;
 808             RL78_STACK_PUSH (tmp1);
 809           }
 810           break;
 811
 812         case R_RL78_OPsub:
 813           {
 814             int32_t tmp1, tmp2;
 815
 816             RL78_STACK_POP (tmp2);
 817             RL78_STACK_POP (tmp1);
 818             tmp2 -= tmp1;
 819             RL78_STACK_PUSH (tmp2);
 820           }
 821           break;
 822
 823         case R_RL78_OPmul:
 824           {
 825             int32_t tmp1, tmp2;
 826
 827             RL78_STACK_POP (tmp2);
 828             RL78_STACK_POP (tmp1);
 829             tmp1 *= tmp2;
 830             RL78_STACK_PUSH (tmp1);
 831           }
 832           break;
 833
 834         case R_RL78_OPdiv:
 835           {
 836             int32_t tmp1, tmp2;
 837
 838             RL78_STACK_POP (tmp2);
 839             RL78_STACK_POP (tmp1);
 840             tmp1 /= tmp2;
 841             RL78_STACK_PUSH (tmp1);
 842           }
 843           break;
 844
 845         case R_RL78_OPshla:
 846           {
 847             int32_t tmp1, tmp2;
 848
 849             RL78_STACK_POP (tmp2);
 850             RL78_STACK_POP (tmp1);
 851             tmp1 <<= tmp2;
 852             RL78_STACK_PUSH (tmp1);
 853           }
 854           break;
 855
 856         case R_RL78_OPshra:
 857           {
 858             int32_t tmp1, tmp2;
 859
 860             RL78_STACK_POP (tmp2);
 861             RL78_STACK_POP (tmp1);
 862             tmp1 >>= tmp2;
 863             RL78_STACK_PUSH (tmp1);
 864           }
 865           break;
 866
 867         case R_RL78_OPsctsize:
 868           RL78_STACK_PUSH (input_section->size);
 869           break;
 870
 871         case R_RL78_OPscttop:
 872           RL78_STACK_PUSH (input_section->output_section->vma);
 873           break;
 874
 875         case R_RL78_OPand:
 876           {
 877             int32_t tmp1, tmp2;
 878
 879             RL78_STACK_POP (tmp2);
 880             RL78_STACK_POP (tmp1);
 881             tmp1 &= tmp2;
 882             RL78_STACK_PUSH (tmp1);
 883           }
 884           break;
 885
 886         case R_RL78_OPor:
 887           {
 888             int32_t tmp1, tmp2;
 889
 890             RL78_STACK_POP (tmp2);
 891             RL78_STACK_POP (tmp1);
 892             tmp1 |= tmp2;
 893             RL78_STACK_PUSH (tmp1);
 894           }
 895           break;
 896
 897         case R_RL78_OPxor:
 898           {
 899             int32_t tmp1, tmp2;
 900
 901             RL78_STACK_POP (tmp2);
 902             RL78_STACK_POP (tmp1);
 903             tmp1 ^= tmp2;
 904             RL78_STACK_PUSH (tmp1);
 905           }
 906           break;
 907
 908         case R_RL78_OPnot:
 909           {
 910             int32_t tmp;
 911
 912             RL78_STACK_POP (tmp);
 913             tmp = ~ tmp;
 914             RL78_STACK_PUSH (tmp);
 915           }
 916           break;
 917
 918         case R_RL78_OPmod:
 919           {
 920             int32_t tmp1, tmp2;
 921
 922             RL78_STACK_POP (tmp2);
 923             RL78_STACK_POP (tmp1);
 924             tmp1 %= tmp2;
 925             RL78_STACK_PUSH (tmp1);
 926           }
 927           break;
 928
 929         case R_RL78_OPromtop:
 930           RL78_STACK_PUSH (get_romstart (&r, info, input_bfd, input_section, rel->r_offset));
 931           break;
 932
 933         case R_RL78_OPramtop:
 934           RL78_STACK_PUSH (get_ramstart (&r, info, input_bfd, input_section, rel->r_offset));
 935           break;
 936
 937         default:
 938           r = bfd_reloc_notsupported;
 939           break;
 940         }
 941
 942       if (r != bfd_reloc_ok)
 943         {
 944           const char * msg = NULL;
 945
 946           switch (r)
 947             {
 948             case bfd_reloc_overflow:
 949               /* Catch the case of a missing function declaration
 950                  and emit a more helpful error message.  */
 951               if (r_type == R_RL78_DIR24S_PCREL)
 952                 msg = _("%B(%A): error: call to undefined function '%s'");
 953               else
 954                 r = info->callbacks->reloc_overflow
 955                   (info, (h ? &h->root : NULL), name, howto->name, (bfd_vma) 0,
 956                    input_bfd, input_section, rel->r_offset);
 957               break;
 958
 959             case bfd_reloc_undefined:
 960               r = info->callbacks->undefined_symbol
 961                 (info, name, input_bfd, input_section, rel->r_offset,
 962                  TRUE);
 963               break;
 964
 965             case bfd_reloc_other:
 966               msg = _("%B(%A): warning: unaligned access to symbol '%s' in the small data area");
 967               break;
 968
 969             case bfd_reloc_outofrange:
 970               msg = _("%B(%A): internal error: out of range error");
 971               break;
 972
 973             case bfd_reloc_notsupported:
 974               msg = _("%B(%A): internal error: unsupported relocation error");
 975               break;
 976
 977             case bfd_reloc_dangerous:
 978               msg = _("%B(%A): internal error: dangerous relocation");
 979               break;
 980
 981             default:
 982               msg = _("%B(%A): internal error: unknown error");
 983               break;
 984             }
 985
 986           if (msg)
 987             _bfd_error_handler (msg, input_bfd, input_section, name);
 988
 989           if (! r)
 990             return FALSE;
 991         }
 992     }
 993
 994   return TRUE;
 995 }
 996 \f
 997 /* Function to set the ELF flag bits.  */
 998
 999 static bfd_boolean
1000 rl78_elf_set_private_flags (bfd * abfd, flagword flags)
1001 {
1002   elf_elfheader (abfd)->e_flags = flags;
1003   elf_flags_init (abfd) = TRUE;
1004   return TRUE;
1005 }
1006
1007 static bfd_boolean no_warn_mismatch = FALSE;
1008
1009 void bfd_elf32_rl78_set_target_flags (bfd_boolean);
1010
1011 void
1012 bfd_elf32_rl78_set_target_flags (bfd_boolean user_no_warn_mismatch)
1013 {
1014   no_warn_mismatch = user_no_warn_mismatch;
1015 }
1016
1017 /* Merge backend specific data from an object file to the output
1018    object file when linking.  */
1019
1020 static bfd_boolean
1021 rl78_elf_merge_private_bfd_data (bfd * ibfd, bfd * obfd)
1022 {
1023   flagword new_flags;
1024   bfd_boolean error = FALSE;
1025
1026   new_flags = elf_elfheader (ibfd)->e_flags;
1027
1028   if (!elf_flags_init (obfd))
1029     {
1030       /* First call, no flags set.  */
1031       elf_flags_init (obfd) = TRUE;
1032       elf_elfheader (obfd)->e_flags = new_flags;
1033     }
1034
1035   return !error;
1036 }
1037 \f
1038 static bfd_boolean
1039 rl78_elf_print_private_bfd_data (bfd * abfd, void * ptr)
1040 {
1041   FILE * file = (FILE *) ptr;
1042   flagword flags;
1043
1044   BFD_ASSERT (abfd != NULL && ptr != NULL);
1045
1046   /* Print normal ELF private data.  */
1047   _bfd_elf_print_private_bfd_data (abfd, ptr);
1048
1049   flags = elf_elfheader (abfd)->e_flags;
1050   fprintf (file, _("private flags = 0x%lx:"), (long) flags);
1051
1052   fputc ('\n', file);
1053   return TRUE;
1054 }
1055
1056 /* Return the MACH for an e_flags value.  */
1057
1058 static int
1059 elf32_rl78_machine (bfd * abfd)
1060 {
1061   if ((elf_elfheader (abfd)->e_flags & EF_RL78_CPU_MASK) == EF_RL78_CPU_RL78)
1062     return bfd_mach_rl78;
1063
1064   return 0;
1065 }
1066
1067 static bfd_boolean
1068 rl78_elf_object_p (bfd * abfd)
1069 {
1070   bfd_default_set_arch_mach (abfd, bfd_arch_rl78,
1071                              elf32_rl78_machine (abfd));
1072   return TRUE;
1073 }
1074  \f
1075 #ifdef DEBUG
1076 void
1077 rl78_dump_symtab (bfd * abfd, void * internal_syms, void * external_syms)
1078 {
1079   size_t locsymcount;
1080   Elf_Internal_Sym * isymbuf;
1081   Elf_Internal_Sym * isymend;
1082   Elf_Internal_Sym * isym;
1083   Elf_Internal_Shdr * symtab_hdr;
1084   bfd_boolean free_internal = FALSE, free_external = FALSE;
1085   char * st_info_str;
1086   char * st_info_stb_str;
1087   char * st_other_str;
1088   char * st_shndx_str;
1089
1090   if (! internal_syms)
1091     {
1092       internal_syms = bfd_malloc (1000);
1093       free_internal = 1;
1094     }
1095   if (! external_syms)
1096     {
1097       external_syms = bfd_malloc (1000);
1098       free_external = 1;
1099     }
1100
1101   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1102   locsymcount = symtab_hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
1103   if (free_internal)
1104     isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1105                                     symtab_hdr->sh_info, 0,
1106                                     internal_syms, external_syms, NULL);
1107   else
1108     isymbuf = internal_syms;
1109   isymend = isymbuf + locsymcount;
1110
1111   for (isym = isymbuf ; isym < isymend ; isym++)
1112     {
1113       switch (ELF_ST_TYPE (isym->st_info))
1114         {
1115         case STT_FUNC: st_info_str = "STT_FUNC";
1116         case STT_SECTION: st_info_str = "STT_SECTION";
1117         case STT_FILE: st_info_str = "STT_FILE";
1118         case STT_OBJECT: st_info_str = "STT_OBJECT";
1119         case STT_TLS: st_info_str = "STT_TLS";
1120         default: st_info_str = "";
1121         }
1122       switch (ELF_ST_BIND (isym->st_info))
1123         {
1124         case STB_LOCAL: st_info_stb_str = "STB_LOCAL";
1125         case STB_GLOBAL: st_info_stb_str = "STB_GLOBAL";
1126         default: st_info_stb_str = "";
1127         }
1128       switch (ELF_ST_VISIBILITY (isym->st_other))
1129         {
1130         case STV_DEFAULT: st_other_str = "STV_DEFAULT";
1131         case STV_INTERNAL: st_other_str = "STV_INTERNAL";
1132         case STV_PROTECTED: st_other_str = "STV_PROTECTED";
1133         default: st_other_str = "";
1134         }
1135       switch (isym->st_shndx)
1136         {
1137         case SHN_ABS: st_shndx_str = "SHN_ABS";
1138         case SHN_COMMON: st_shndx_str = "SHN_COMMON";
1139         case SHN_UNDEF: st_shndx_str = "SHN_UNDEF";
1140         default: st_shndx_str = "";
1141         }
1142
1143       printf ("isym = %p st_value = %lx st_size = %lx st_name = (%lu) %s "
1144               "st_info = (%d) %s %s st_other = (%d) %s st_shndx = (%d) %s\n",
1145               isym,
1146               (unsigned long) isym->st_value,
1147               (unsigned long) isym->st_size,
1148               isym->st_name,
1149               bfd_elf_string_from_elf_section (abfd, symtab_hdr->sh_link,
1150                                                isym->st_name),
1151               isym->st_info, st_info_str, st_info_stb_str,
1152               isym->st_other, st_other_str,
1153               isym->st_shndx, st_shndx_str);
1154     }
1155   if (free_internal)
1156     free (internal_syms);
1157   if (free_external)
1158     free (external_syms);
1159 }
1160
1161 char *
1162 rl78_get_reloc (long reloc)
1163 {
1164   if (0 <= reloc && reloc < R_RL78_max)
1165     return rl78_elf_howto_table[reloc].name;
1166   return "";
1167 }
1168 #endif /* DEBUG */
1169
1170 \f
1171 /* support PLT for 16-bit references to 24-bit functions.  */
1172
1173 /* We support 16-bit pointers to code above 64k by generating a thunk
1174    below 64k containing a JMP instruction to the final address.  */
1175
1176 static bfd_boolean
1177 rl78_elf_check_relocs
1178     (bfd *                     abfd,
1179      struct bfd_link_info *    info,
1180      asection *                sec,
1181      const Elf_Internal_Rela * relocs)
1182 {
1183   Elf_Internal_Shdr *           symtab_hdr;
1184   struct elf_link_hash_entry ** sym_hashes;
1185   const Elf_Internal_Rela *     rel;
1186   const Elf_Internal_Rela *     rel_end;
1187   bfd_vma *local_plt_offsets;
1188   asection *splt;
1189   bfd *dynobj;
1190
1191   if (info->relocatable)
1192     return TRUE;
1193
1194   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1195   sym_hashes = elf_sym_hashes (abfd);
1196   local_plt_offsets = elf_local_got_offsets (abfd);
1197   splt = NULL;
1198   dynobj = elf_hash_table(info)->dynobj;
1199
1200   rel_end = relocs + sec->reloc_count;
1201   for (rel = relocs; rel < rel_end; rel++)
1202     {
1203       struct elf_link_hash_entry *h;
1204       unsigned long r_symndx;
1205       bfd_vma *offset;
1206
1207       r_symndx = ELF32_R_SYM (rel->r_info);
1208       if (r_symndx < symtab_hdr->sh_info)
1209         h = NULL;
1210       else
1211         {
1212           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1213           while (h->root.type == bfd_link_hash_indirect
1214                  || h->root.type == bfd_link_hash_warning)
1215             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1216         }
1217
1218       switch (ELF32_R_TYPE (rel->r_info))
1219         {
1220           /* This relocation describes a 16-bit pointer to a function.
1221              We may need to allocate a thunk in low memory; reserve memory
1222              for it now.  */
1223         case R_RL78_DIR16S:
1224           if (dynobj == NULL)
1225             elf_hash_table (info)->dynobj = dynobj = abfd;
1226           if (splt == NULL)
1227             {
1228               splt = bfd_get_section_by_name (dynobj, ".plt");
1229               if (splt == NULL)
1230                 {
1231                   flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
1232                                     | SEC_IN_MEMORY | SEC_LINKER_CREATED
1233                                     | SEC_READONLY | SEC_CODE);
1234                   splt = bfd_make_section_with_flags (dynobj, ".plt", flags);
1235                   if (splt == NULL
1236                       || ! bfd_set_section_alignment (dynobj, splt, 1))
1237                     return FALSE;
1238                 }
1239             }
1240
1241           if (h != NULL)
1242             offset = &h->plt.offset;
1243           else
1244             {
1245               if (local_plt_offsets == NULL)
1246                 {
1247                   size_t size;
1248                   unsigned int i;
1249
1250                   size = symtab_hdr->sh_info * sizeof (bfd_vma);
1251                   local_plt_offsets = (bfd_vma *) bfd_alloc (abfd, size);
1252                   if (local_plt_offsets == NULL)
1253                     return FALSE;
1254                   elf_local_got_offsets (abfd) = local_plt_offsets;
1255
1256                   for (i = 0; i < symtab_hdr->sh_info; i++)
1257                     local_plt_offsets[i] = (bfd_vma) -1;
1258                 }
1259               offset = &local_plt_offsets[r_symndx];
1260             }
1261
1262           if (*offset == (bfd_vma) -1)
1263             {
1264               *offset = splt->size;
1265               splt->size += 4;
1266             }
1267           break;
1268         }
1269     }
1270
1271   return TRUE;
1272 }
1273
1274 /* This must exist if dynobj is ever set.  */
1275
1276 static bfd_boolean
1277 rl78_elf_finish_dynamic_sections (bfd *abfd ATTRIBUTE_UNUSED,
1278                                   struct bfd_link_info *info)
1279 {
1280   bfd *dynobj;
1281   asection *splt;
1282
1283   /* As an extra sanity check, verify that all plt entries have been
1284      filled in.  However, relaxing might have changed the relocs so
1285      that some plt entries don't get filled in, so we have to skip
1286      this check if we're relaxing.  Unfortunately, check_relocs is
1287      called before relaxation.  */
1288
1289   if (info->relax_trip > 0)
1290     {
1291       if ((dynobj = elf_hash_table (info)->dynobj) != NULL
1292           && (splt = bfd_get_section_by_name (dynobj, ".plt")) != NULL)
1293         {
1294           bfd_byte *contents = splt->contents;
1295           unsigned int i, size = splt->size;
1296           for (i = 0; i < size; i += 4)
1297             {
1298               unsigned int x = bfd_get_32 (dynobj, contents + i);
1299               BFD_ASSERT (x != 0);
1300             }
1301         }
1302     }
1303
1304   return TRUE;
1305 }
1306
1307 static bfd_boolean
1308 rl78_elf_always_size_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
1309                                struct bfd_link_info *info)
1310 {
1311   bfd *dynobj;
1312   asection *splt;
1313
1314   if (info->relocatable)
1315     return TRUE;
1316
1317   dynobj = elf_hash_table (info)->dynobj;
1318   if (dynobj == NULL)
1319     return TRUE;
1320
1321   splt = bfd_get_section_by_name (dynobj, ".plt");
1322   BFD_ASSERT (splt != NULL);
1323
1324   splt->contents = (bfd_byte *) bfd_zalloc (dynobj, splt->size);
1325   if (splt->contents == NULL)
1326     return FALSE;
1327
1328   return TRUE;
1329 }
1330
1331 \f
1332
1333 /* Handle relaxing.  */
1334
1335 /* A subroutine of rl78_elf_relax_section.  If the global symbol H
1336    is within the low 64k, remove any entry for it in the plt.  */
1337
1338 struct relax_plt_data
1339 {
1340   asection *splt;
1341   bfd_boolean *again;
1342 };
1343
1344 static bfd_boolean
1345 rl78_relax_plt_check (struct elf_link_hash_entry *h,
1346                       PTR xdata)
1347 {
1348   struct relax_plt_data *data = (struct relax_plt_data *) xdata;
1349
1350   if (h->plt.offset != (bfd_vma) -1)
1351     {
1352       bfd_vma address;
1353
1354       if (h->root.type == bfd_link_hash_undefined
1355           || h->root.type == bfd_link_hash_undefweak)
1356         address = 0;
1357       else
1358         address = (h->root.u.def.section->output_section->vma
1359                    + h->root.u.def.section->output_offset
1360                    + h->root.u.def.value);
1361
1362       if (valid_16bit_address (address))
1363         {
1364           h->plt.offset = -1;
1365           data->splt->size -= 4;
1366           *data->again = TRUE;
1367         }
1368     }
1369
1370   return TRUE;
1371 }
1372
1373 /* A subroutine of rl78_elf_relax_section.  If the global symbol H
1374    previously had a plt entry, give it a new entry offset.  */
1375
1376 static bfd_boolean
1377 rl78_relax_plt_realloc (struct elf_link_hash_entry *h,
1378                         PTR xdata)
1379 {
1380   bfd_vma *entry = (bfd_vma *) xdata;
1381
1382   if (h->plt.offset != (bfd_vma) -1)
1383     {
1384       h->plt.offset = *entry;
1385       *entry += 4;
1386     }
1387
1388   return TRUE;
1389 }
1390
1391 static bfd_boolean
1392 rl78_elf_relax_plt_section (bfd *dynobj,
1393                             asection *splt,
1394                             struct bfd_link_info *info,
1395                             bfd_boolean *again)
1396 {
1397   struct relax_plt_data relax_plt_data;
1398   bfd *ibfd;
1399
1400   /* Assume nothing changes.  */
1401   *again = FALSE;
1402
1403   if (info->relocatable)
1404     return TRUE;
1405
1406   /* We only relax the .plt section at the moment.  */
1407   if (dynobj != elf_hash_table (info)->dynobj
1408       || strcmp (splt->name, ".plt") != 0)
1409     return TRUE;
1410
1411   /* Quick check for an empty plt.  */
1412   if (splt->size == 0)
1413     return TRUE;
1414
1415   /* Map across all global symbols; see which ones happen to
1416      fall in the low 64k.  */
1417   relax_plt_data.splt = splt;
1418   relax_plt_data.again = again;
1419   elf_link_hash_traverse (elf_hash_table (info), rl78_relax_plt_check,
1420                           &relax_plt_data);
1421
1422   /* Likewise for local symbols, though that's somewhat less convenient
1423      as we have to walk the list of input bfds and swap in symbol data.  */
1424   for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link_next)
1425     {
1426       bfd_vma *local_plt_offsets = elf_local_got_offsets (ibfd);
1427       Elf_Internal_Shdr *symtab_hdr;
1428       Elf_Internal_Sym *isymbuf = NULL;
1429       unsigned int idx;
1430
1431       if (! local_plt_offsets)
1432         continue;
1433
1434       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
1435       if (symtab_hdr->sh_info != 0)
1436         {
1437           isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1438           if (isymbuf == NULL)
1439             isymbuf = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
1440                                             symtab_hdr->sh_info, 0,
1441                                             NULL, NULL, NULL);
1442           if (isymbuf == NULL)
1443             return FALSE;
1444         }
1445
1446       for (idx = 0; idx < symtab_hdr->sh_info; ++idx)
1447         {
1448           Elf_Internal_Sym *isym;
1449           asection *tsec;
1450           bfd_vma address;
1451
1452           if (local_plt_offsets[idx] == (bfd_vma) -1)
1453             continue;
1454
1455           isym = &isymbuf[idx];
1456           if (isym->st_shndx == SHN_UNDEF)
1457             continue;
1458           else if (isym->st_shndx == SHN_ABS)
1459             tsec = bfd_abs_section_ptr;
1460           else if (isym->st_shndx == SHN_COMMON)
1461             tsec = bfd_com_section_ptr;
1462           else
1463             tsec = bfd_section_from_elf_index (ibfd, isym->st_shndx);
1464
1465           address = (tsec->output_section->vma
1466                      + tsec->output_offset
1467                      + isym->st_value);
1468           if (valid_16bit_address (address))
1469             {
1470               local_plt_offsets[idx] = -1;
1471               splt->size -= 4;
1472               *again = TRUE;
1473             }
1474         }
1475
1476       if (isymbuf != NULL
1477           && symtab_hdr->contents != (unsigned char *) isymbuf)
1478         {
1479           if (! info->keep_memory)
1480             free (isymbuf);
1481           else
1482             {
1483               /* Cache the symbols for elf_link_input_bfd.  */
1484               symtab_hdr->contents = (unsigned char *) isymbuf;
1485             }
1486         }
1487     }
1488
1489   /* If we changed anything, walk the symbols again to reallocate
1490      .plt entry addresses.  */
1491   if (*again && splt->size > 0)
1492     {
1493       bfd_vma entry = 0;
1494
1495       elf_link_hash_traverse (elf_hash_table (info),
1496                               rl78_relax_plt_realloc, &entry);
1497
1498       for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link_next)
1499         {
1500           bfd_vma *local_plt_offsets = elf_local_got_offsets (ibfd);
1501           unsigned int nlocals = elf_tdata (ibfd)->symtab_hdr.sh_info;
1502           unsigned int idx;
1503
1504           if (! local_plt_offsets)
1505             continue;
1506
1507           for (idx = 0; idx < nlocals; ++idx)
1508             if (local_plt_offsets[idx] != (bfd_vma) -1)
1509               {
1510                 local_plt_offsets[idx] = entry;
1511                 entry += 4;
1512               }
1513         }
1514     }
1515
1516   return TRUE;
1517 }
1518
1519 /* Delete some bytes from a section while relaxing.  */
1520
1521 static bfd_boolean
1522 elf32_rl78_relax_delete_bytes (bfd *abfd, asection *sec, bfd_vma addr, int count,
1523                              Elf_Internal_Rela *alignment_rel, int force_snip)
1524 {
1525   Elf_Internal_Shdr * symtab_hdr;
1526   unsigned int        sec_shndx;
1527   bfd_byte *          contents;
1528   Elf_Internal_Rela * irel;
1529   Elf_Internal_Rela * irelend;
1530   Elf_Internal_Sym *  isym;
1531   Elf_Internal_Sym *  isymend;
1532   bfd_vma             toaddr;
1533   unsigned int        symcount;
1534   struct elf_link_hash_entry ** sym_hashes;
1535   struct elf_link_hash_entry ** end_hashes;
1536
1537   if (!alignment_rel)
1538     force_snip = 1;
1539
1540   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1541
1542   contents = elf_section_data (sec)->this_hdr.contents;
1543
1544   /* The deletion must stop at the next alignment boundary, if
1545      ALIGNMENT_REL is non-NULL.  */
1546   toaddr = sec->size;
1547   if (alignment_rel)
1548     toaddr = alignment_rel->r_offset;
1549
1550   irel = elf_section_data (sec)->relocs;
1551   irelend = irel + sec->reloc_count;
1552
1553   /* Actually delete the bytes.  */
1554   memmove (contents + addr, contents + addr + count,
1555            (size_t) (toaddr - addr - count));
1556
1557   /* If we don't have an alignment marker to worry about, we can just
1558      shrink the section.  Otherwise, we have to fill in the newly
1559      created gap with NOP insns (0x03).  */
1560   if (force_snip)
1561     sec->size -= count;
1562   else
1563     memset (contents + toaddr - count, 0x03, count);
1564
1565   /* Adjust all the relocs.  */
1566   for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1567     {
1568       /* Get the new reloc address.  */
1569       if (irel->r_offset > addr
1570           && (irel->r_offset < toaddr
1571               || (force_snip && irel->r_offset == toaddr)))
1572         irel->r_offset -= count;
1573
1574       /* If we see an ALIGN marker at the end of the gap, we move it
1575          to the beginning of the gap, since marking these gaps is what
1576          they're for.  */
1577       if (irel->r_offset == toaddr
1578           && ELF32_R_TYPE (irel->r_info) == R_RL78_RH_RELAX
1579           && irel->r_addend & RL78_RELAXA_ALIGN)
1580         irel->r_offset -= count;
1581     }
1582
1583   /* Adjust the local symbols defined in this section.  */
1584   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1585   isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1586   isymend = isym + symtab_hdr->sh_info;
1587
1588   for (; isym < isymend; isym++)
1589     {
1590       /* If the symbol is in the range of memory we just moved, we
1591          have to adjust its value.  */
1592       if (isym->st_shndx == sec_shndx
1593           && isym->st_value > addr
1594           && isym->st_value < toaddr)
1595         isym->st_value -= count;
1596
1597       /* If the symbol *spans* the bytes we just deleted (i.e. it's
1598          *end* is in the moved bytes but it's *start* isn't), then we
1599          must adjust its size.  */
1600       if (isym->st_shndx == sec_shndx
1601           && isym->st_value < addr
1602           && isym->st_value + isym->st_size > addr
1603           && isym->st_value + isym->st_size < toaddr)
1604         isym->st_size -= count;
1605     }
1606
1607   /* Now adjust the global symbols defined in this section.  */
1608   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1609               - symtab_hdr->sh_info);
1610   sym_hashes = elf_sym_hashes (abfd);
1611   end_hashes = sym_hashes + symcount;
1612
1613   for (; sym_hashes < end_hashes; sym_hashes++)
1614     {
1615       struct elf_link_hash_entry *sym_hash = *sym_hashes;
1616
1617       if ((sym_hash->root.type == bfd_link_hash_defined
1618            || sym_hash->root.type == bfd_link_hash_defweak)
1619           && sym_hash->root.u.def.section == sec)
1620         {
1621           /* As above, adjust the value if needed.  */
1622           if (sym_hash->root.u.def.value > addr
1623               && sym_hash->root.u.def.value < toaddr)
1624             sym_hash->root.u.def.value -= count;
1625
1626           /* As above, adjust the size if needed.  */
1627           if (sym_hash->root.u.def.value < addr
1628               && sym_hash->root.u.def.value + sym_hash->size > addr
1629               && sym_hash->root.u.def.value + sym_hash->size < toaddr)
1630             sym_hash->size -= count;
1631         }
1632     }
1633
1634   return TRUE;
1635 }
1636
1637 /* Used to sort relocs by address.  If relocs have the same address,
1638    we maintain their relative order, except that R_RL78_RH_RELAX
1639    alignment relocs must be the first reloc for any given address.  */
1640
1641 static void
1642 reloc_bubblesort (Elf_Internal_Rela * r, int count)
1643 {
1644   int i;
1645   bfd_boolean again;
1646   bfd_boolean swappit;
1647
1648   /* This is almost a classic bubblesort.  It's the slowest sort, but
1649      we're taking advantage of the fact that the relocations are
1650      mostly in order already (the assembler emits them that way) and
1651      we need relocs with the same address to remain in the same
1652      relative order.  */
1653   again = TRUE;
1654   while (again)
1655     {
1656       again = FALSE;
1657       for (i = 0; i < count - 1; i ++)
1658         {
1659           if (r[i].r_offset > r[i + 1].r_offset)
1660             swappit = TRUE;
1661           else if (r[i].r_offset < r[i + 1].r_offset)
1662             swappit = FALSE;
1663           else if (ELF32_R_TYPE (r[i + 1].r_info) == R_RL78_RH_RELAX
1664                    && (r[i + 1].r_addend & RL78_RELAXA_ALIGN))
1665             swappit = TRUE;
1666           else if (ELF32_R_TYPE (r[i + 1].r_info) == R_RL78_RH_RELAX
1667                    && (r[i + 1].r_addend & RL78_RELAXA_ELIGN)
1668                    && !(ELF32_R_TYPE (r[i].r_info) == R_RL78_RH_RELAX
1669                         && (r[i].r_addend & RL78_RELAXA_ALIGN)))
1670             swappit = TRUE;
1671           else
1672             swappit = FALSE;
1673
1674           if (swappit)
1675             {
1676               Elf_Internal_Rela tmp;
1677
1678               tmp = r[i];
1679               r[i] = r[i + 1];
1680               r[i + 1] = tmp;
1681               /* If we do move a reloc back, re-scan to see if it
1682                  needs to be moved even further back.  This avoids
1683                  most of the O(n^2) behavior for our cases.  */
1684               if (i > 0)
1685                 i -= 2;
1686               again = TRUE;
1687             }
1688         }
1689     }
1690 }
1691
1692
1693 #define OFFSET_FOR_RELOC(rel, lrel, scale) \
1694   rl78_offset_for_reloc (abfd, rel + 1, symtab_hdr, shndx_buf, intsyms, \
1695                        lrel, abfd, sec, link_info, scale)
1696
1697 static bfd_vma
1698 rl78_offset_for_reloc (bfd *                    abfd,
1699                      Elf_Internal_Rela *      rel,
1700                      Elf_Internal_Shdr *      symtab_hdr,
1701                      Elf_External_Sym_Shndx * shndx_buf ATTRIBUTE_UNUSED,
1702                      Elf_Internal_Sym *       intsyms,
1703                      Elf_Internal_Rela **     lrel,
1704                      bfd *                    input_bfd,
1705                      asection *               input_section,
1706                      struct bfd_link_info *   info,
1707                      int *                    scale)
1708 {
1709   bfd_vma symval;
1710   bfd_reloc_status_type r;
1711
1712   *scale = 1;
1713
1714   /* REL is the first of 1..N relocations.  We compute the symbol
1715      value for each relocation, then combine them if needed.  LREL
1716      gets a pointer to the last relocation used.  */
1717   while (1)
1718     {
1719       int32_t tmp1, tmp2;
1720
1721       /* Get the value of the symbol referred to by the reloc.  */
1722       if (ELF32_R_SYM (rel->r_info) < symtab_hdr->sh_info)
1723         {
1724           /* A local symbol.  */
1725           Elf_Internal_Sym *isym;
1726           asection *ssec;
1727
1728           isym = intsyms + ELF32_R_SYM (rel->r_info);
1729
1730           if (isym->st_shndx == SHN_UNDEF)
1731             ssec = bfd_und_section_ptr;
1732           else if (isym->st_shndx == SHN_ABS)
1733             ssec = bfd_abs_section_ptr;
1734           else if (isym->st_shndx == SHN_COMMON)
1735             ssec = bfd_com_section_ptr;
1736           else
1737             ssec = bfd_section_from_elf_index (abfd,
1738                                                isym->st_shndx);
1739
1740           /* Initial symbol value.  */
1741           symval = isym->st_value;
1742
1743           /* GAS may have made this symbol relative to a section, in
1744              which case, we have to add the addend to find the
1745              symbol.  */
1746           if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
1747             symval += rel->r_addend;
1748
1749           if (ssec)
1750             {
1751               if ((ssec->flags & SEC_MERGE)
1752                   && ssec->sec_info_type == ELF_INFO_TYPE_MERGE)
1753                 symval = _bfd_merged_section_offset (abfd, & ssec,
1754                                                      elf_section_data (ssec)->sec_info,
1755                                                      symval);
1756             }
1757
1758           /* Now make the offset relative to where the linker is putting it.  */
1759           if (ssec)
1760             symval +=
1761               ssec->output_section->vma + ssec->output_offset;
1762
1763           symval += rel->r_addend;
1764         }
1765       else
1766         {
1767           unsigned long indx;
1768           struct elf_link_hash_entry * h;
1769
1770           /* An external symbol.  */
1771           indx = ELF32_R_SYM (rel->r_info) - symtab_hdr->sh_info;
1772           h = elf_sym_hashes (abfd)[indx];
1773           BFD_ASSERT (h != NULL);
1774
1775           if (h->root.type != bfd_link_hash_defined
1776               && h->root.type != bfd_link_hash_defweak)
1777             {
1778               /* This appears to be a reference to an undefined
1779                  symbol.  Just ignore it--it will be caught by the
1780                  regular reloc processing.  */
1781               if (lrel)
1782                 *lrel = rel;
1783               return 0;
1784             }
1785
1786           symval = (h->root.u.def.value
1787                     + h->root.u.def.section->output_section->vma
1788                     + h->root.u.def.section->output_offset);
1789
1790           symval += rel->r_addend;
1791         }
1792
1793       switch (ELF32_R_TYPE (rel->r_info))
1794         {
1795         case R_RL78_SYM:
1796           RL78_STACK_PUSH (symval);
1797           break;
1798
1799         case R_RL78_OPneg:
1800           RL78_STACK_POP (tmp1);
1801           tmp1 = - tmp1;
1802           RL78_STACK_PUSH (tmp1);
1803           break;
1804
1805         case R_RL78_OPadd:
1806           RL78_STACK_POP (tmp1);
1807           RL78_STACK_POP (tmp2);
1808           tmp1 += tmp2;
1809           RL78_STACK_PUSH (tmp1);
1810           break;
1811
1812         case R_RL78_OPsub:
1813           RL78_STACK_POP (tmp1);
1814           RL78_STACK_POP (tmp2);
1815           tmp2 -= tmp1;
1816           RL78_STACK_PUSH (tmp2);
1817           break;
1818
1819         case R_RL78_OPmul:
1820           RL78_STACK_POP (tmp1);
1821           RL78_STACK_POP (tmp2);
1822           tmp1 *= tmp2;
1823           RL78_STACK_PUSH (tmp1);
1824           break;
1825
1826         case R_RL78_OPdiv:
1827           RL78_STACK_POP (tmp1);
1828           RL78_STACK_POP (tmp2);
1829           tmp1 /= tmp2;
1830           RL78_STACK_PUSH (tmp1);
1831           break;
1832
1833         case R_RL78_OPshla:
1834           RL78_STACK_POP (tmp1);
1835           RL78_STACK_POP (tmp2);
1836           tmp1 <<= tmp2;
1837           RL78_STACK_PUSH (tmp1);
1838           break;
1839
1840         case R_RL78_OPshra:
1841           RL78_STACK_POP (tmp1);
1842           RL78_STACK_POP (tmp2);
1843           tmp1 >>= tmp2;
1844           RL78_STACK_PUSH (tmp1);
1845           break;
1846
1847         case R_RL78_OPsctsize:
1848           RL78_STACK_PUSH (input_section->size);
1849           break;
1850
1851         case R_RL78_OPscttop:
1852           RL78_STACK_PUSH (input_section->output_section->vma);
1853           break;
1854
1855         case R_RL78_OPand:
1856           RL78_STACK_POP (tmp1);
1857           RL78_STACK_POP (tmp2);
1858           tmp1 &= tmp2;
1859           RL78_STACK_PUSH (tmp1);
1860           break;
1861
1862         case R_RL78_OPor:
1863           RL78_STACK_POP (tmp1);
1864           RL78_STACK_POP (tmp2);
1865           tmp1 |= tmp2;
1866           RL78_STACK_PUSH (tmp1);
1867           break;
1868
1869         case R_RL78_OPxor:
1870           RL78_STACK_POP (tmp1);
1871           RL78_STACK_POP (tmp2);
1872           tmp1 ^= tmp2;
1873           RL78_STACK_PUSH (tmp1);
1874           break;
1875
1876         case R_RL78_OPnot:
1877           RL78_STACK_POP (tmp1);
1878           tmp1 = ~ tmp1;
1879           RL78_STACK_PUSH (tmp1);
1880           break;
1881
1882         case R_RL78_OPmod:
1883           RL78_STACK_POP (tmp1);
1884           RL78_STACK_POP (tmp2);
1885           tmp1 %= tmp2;
1886           RL78_STACK_PUSH (tmp1);
1887           break;
1888
1889         case R_RL78_OPromtop:
1890           RL78_STACK_PUSH (get_romstart (&r, info, input_bfd, input_section, rel->r_offset));
1891           break;
1892
1893         case R_RL78_OPramtop:
1894           RL78_STACK_PUSH (get_ramstart (&r, info, input_bfd, input_section, rel->r_offset));
1895           break;
1896
1897         case R_RL78_DIR16UL:
1898         case R_RL78_DIR8UL:
1899         case R_RL78_ABS16UL:
1900         case R_RL78_ABS8UL:
1901           if (rl78_stack_top)
1902             RL78_STACK_POP (symval);
1903           if (lrel)
1904             *lrel = rel;
1905           *scale = 4;
1906           return symval;
1907
1908         case R_RL78_DIR16UW:
1909         case R_RL78_DIR8UW:
1910         case R_RL78_ABS16UW:
1911         case R_RL78_ABS8UW:
1912           if (rl78_stack_top)
1913             RL78_STACK_POP (symval);
1914           if (lrel)
1915             *lrel = rel;
1916           *scale = 2;
1917           return symval;
1918
1919         default:
1920           if (rl78_stack_top)
1921             RL78_STACK_POP (symval);
1922           if (lrel)
1923             *lrel = rel;
1924           return symval;
1925         }
1926
1927       rel ++;
1928     }
1929 }
1930
1931 struct {
1932   int prefix;           /* or -1 for "no prefix" */
1933   int insn;             /* or -1 for "end of list" */
1934   int insn_for_saddr;   /* or -1 for "no alternative" */
1935   int insn_for_sfr;     /* or -1 for "no alternative" */
1936 } relax_addr16[] = {
1937   { -1, 0x02, 0x06, -1 },       /* ADDW AX, !addr16 */
1938   { -1, 0x22, 0x26, -1 },       /* SUBW AX, !addr16 */
1939   { -1, 0x42, 0x46, -1 },       /* CMPW AX, !addr16 */
1940   { -1, 0x40, 0x4a, -1 },       /* CMP  !addr16, #byte */
1941
1942   { -1, 0x0f, 0x0b, -1 },       /* ADD  A, !addr16 */
1943   { -1, 0x1f, 0x1b, -1 },       /* ADDC A, !addr16 */
1944   { -1, 0x2f, 0x2b, -1 },       /* SUB  A, !addr16 */
1945   { -1, 0x3f, 0x3b, -1 },       /* SUBC A, !addr16 */
1946   { -1, 0x4f, 0x4b, -1 },       /* CMP  A, !addr16 */
1947   { -1, 0x5f, 0x5b, -1 },       /* AND  A, !addr16 */
1948   { -1, 0x6f, 0x6b, -1 },       /* OR   A, !addr16 */
1949   { -1, 0x7f, 0x7b, -1 },       /* XOR  A, !addr16 */
1950
1951   { -1, 0x8f, 0x8d, 0x8e },     /* MOV  A, !addr16 */
1952   { -1, 0x9f, 0x9d, 0x9e },     /* MOV  !addr16, A */
1953   { -1, 0xaf, 0xad, 0xae },     /* MOVW AX, !addr16 */
1954   { -1, 0xbf, 0xbd, 0xbe },     /* MOVW !addr16, AX */
1955   { -1, 0xcf, 0xcd, 0xce },     /* MOVW !addr16, #word */
1956
1957   { -1, 0xa0, 0xa4, -1 },       /* INC  !addr16 */
1958   { -1, 0xa2, 0xa6, -1 },       /* INCW !addr16 */
1959   { -1, 0xb0, 0xb4, -1 },       /* DEC  !addr16 */
1960   { -1, 0xb2, 0xb6, -1 },       /* DECW !addr16 */
1961
1962   { -1, 0xd5, 0xd4, -1 },       /* CMP0 !addr16 */
1963   { -1, 0xe5, 0xe4, -1 },       /* ONEB !addr16 */
1964   { -1, 0xf5, 0xf4, -1 },       /* CLRB !addr16 */
1965
1966   { -1, 0xd9, 0xd8, -1 },       /* MOV  X, !addr16 */
1967   { -1, 0xe9, 0xe8, -1 },       /* MOV  B, !addr16 */
1968   { -1, 0xf9, 0xf8, -1 },       /* MOV  C, !addr16 */
1969   { -1, 0xdb, 0xda, -1 },       /* MOVW BC, !addr16 */
1970   { -1, 0xeb, 0xea, -1 },       /* MOVW DE, !addr16 */
1971   { -1, 0xfb, 0xfa, -1 },       /* MOVW HL, !addr16 */
1972
1973   { 0x61, 0xaa, 0xa8, -1 },     /* XCH  A, !addr16 */
1974
1975   { 0x71, 0x00, 0x02, 0x0a },   /* SET1 !addr16.0 */
1976   { 0x71, 0x10, 0x12, 0x1a },   /* SET1 !addr16.0 */
1977   { 0x71, 0x20, 0x22, 0x2a },   /* SET1 !addr16.0 */
1978   { 0x71, 0x30, 0x32, 0x3a },   /* SET1 !addr16.0 */
1979   { 0x71, 0x40, 0x42, 0x4a },   /* SET1 !addr16.0 */
1980   { 0x71, 0x50, 0x52, 0x5a },   /* SET1 !addr16.0 */
1981   { 0x71, 0x60, 0x62, 0x6a },   /* SET1 !addr16.0 */
1982   { 0x71, 0x70, 0x72, 0x7a },   /* SET1 !addr16.0 */
1983
1984   { 0x71, 0x08, 0x03, 0x0b },   /* CLR1 !addr16.0 */
1985   { 0x71, 0x18, 0x13, 0x1b },   /* CLR1 !addr16.0 */
1986   { 0x71, 0x28, 0x23, 0x2b },   /* CLR1 !addr16.0 */
1987   { 0x71, 0x38, 0x33, 0x3b },   /* CLR1 !addr16.0 */
1988   { 0x71, 0x48, 0x43, 0x4b },   /* CLR1 !addr16.0 */
1989   { 0x71, 0x58, 0x53, 0x5b },   /* CLR1 !addr16.0 */
1990   { 0x71, 0x68, 0x63, 0x6b },   /* CLR1 !addr16.0 */
1991   { 0x71, 0x78, 0x73, 0x7b },   /* CLR1 !addr16.0 */
1992
1993   { -1, -1, -1, -1 }
1994 };
1995
1996 /* Relax one section.  */
1997
1998 static bfd_boolean
1999 rl78_elf_relax_section
2000     (bfd *                  abfd,
2001      asection *             sec,
2002      struct bfd_link_info * link_info,
2003      bfd_boolean *          again)
2004 {
2005   Elf_Internal_Shdr * symtab_hdr;
2006   Elf_Internal_Shdr * shndx_hdr;
2007   Elf_Internal_Rela * internal_relocs;
2008   Elf_Internal_Rela * free_relocs = NULL;
2009   Elf_Internal_Rela * irel;
2010   Elf_Internal_Rela * srel;
2011   Elf_Internal_Rela * irelend;
2012   Elf_Internal_Rela * next_alignment;
2013   Elf_Internal_Rela * prev_alignment;
2014   bfd_byte *          contents = NULL;
2015   bfd_byte *          free_contents = NULL;
2016   Elf_Internal_Sym *  intsyms = NULL;
2017   Elf_Internal_Sym *  free_intsyms = NULL;
2018   Elf_External_Sym_Shndx * shndx_buf = NULL;
2019   bfd_vma pc;
2020   bfd_vma sec_start;
2021   bfd_vma symval ATTRIBUTE_UNUSED = 0;
2022   int pcrel ATTRIBUTE_UNUSED = 0;
2023   int code ATTRIBUTE_UNUSED = 0;
2024   int section_alignment_glue;
2025   int scale;
2026
2027   if (abfd == elf_hash_table (link_info)->dynobj
2028       && strcmp (sec->name, ".plt") == 0)
2029     return rl78_elf_relax_plt_section (abfd, sec, link_info, again);
2030
2031   /* Assume nothing changes.  */
2032   *again = FALSE;
2033
2034   /* We don't have to do anything for a relocatable link, if
2035      this section does not have relocs, or if this is not a
2036      code section.  */
2037   if (link_info->relocatable
2038       || (sec->flags & SEC_RELOC) == 0
2039       || sec->reloc_count == 0
2040       || (sec->flags & SEC_CODE) == 0)
2041     return TRUE;
2042
2043   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2044   shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
2045
2046   sec_start = sec->output_section->vma + sec->output_offset;
2047
2048   /* Get the section contents.  */
2049   if (elf_section_data (sec)->this_hdr.contents != NULL)
2050     contents = elf_section_data (sec)->this_hdr.contents;
2051   /* Go get them off disk.  */
2052   else
2053     {
2054       if (! bfd_malloc_and_get_section (abfd, sec, &contents))
2055         goto error_return;
2056       elf_section_data (sec)->this_hdr.contents = contents;
2057     }
2058
2059   /* Read this BFD's symbols.  */
2060   /* Get cached copy if it exists.  */
2061   if (symtab_hdr->contents != NULL)
2062     intsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
2063   else
2064     {
2065       intsyms = bfd_elf_get_elf_syms (abfd, symtab_hdr, symtab_hdr->sh_info, 0, NULL, NULL, NULL);
2066       symtab_hdr->contents = (bfd_byte *) intsyms;
2067     }
2068
2069   if (shndx_hdr->sh_size != 0)
2070     {
2071       bfd_size_type amt;
2072
2073       amt = symtab_hdr->sh_info;
2074       amt *= sizeof (Elf_External_Sym_Shndx);
2075       shndx_buf = (Elf_External_Sym_Shndx *) bfd_malloc (amt);
2076       if (shndx_buf == NULL)
2077         goto error_return;
2078       if (bfd_seek (abfd, shndx_hdr->sh_offset, SEEK_SET) != 0
2079           || bfd_bread ((PTR) shndx_buf, amt, abfd) != amt)
2080         goto error_return;
2081       shndx_hdr->contents = (bfd_byte *) shndx_buf;
2082     }
2083
2084   /* Get a copy of the native relocations.  */
2085   internal_relocs = (_bfd_elf_link_read_relocs
2086                      (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
2087                       link_info->keep_memory));
2088   if (internal_relocs == NULL)
2089     goto error_return;
2090   if (! link_info->keep_memory)
2091     free_relocs = internal_relocs;
2092
2093   /* The RL_ relocs must be just before the operand relocs they go
2094      with, so we must sort them to guarantee this.  We use bubblesort
2095      instead of qsort so we can guarantee that relocs with the same
2096      address remain in the same relative order.  */
2097   reloc_bubblesort (internal_relocs, sec->reloc_count);
2098
2099   /* Walk through them looking for relaxing opportunities.  */
2100   irelend = internal_relocs + sec->reloc_count;
2101
2102
2103   /* This will either be NULL or a pointer to the next alignment
2104      relocation.  */
2105   next_alignment = internal_relocs;
2106   /* This will be the previous alignment, although at first it points
2107      to the first real relocation.  */
2108   prev_alignment = internal_relocs;
2109
2110   /* We calculate worst case shrinkage caused by alignment directives.
2111      No fool-proof, but better than either ignoring the problem or
2112      doing heavy duty analysis of all the alignment markers in all
2113      input sections.  */
2114   section_alignment_glue = 0;
2115   for (irel = internal_relocs; irel < irelend; irel++)
2116       if (ELF32_R_TYPE (irel->r_info) == R_RL78_RH_RELAX
2117           && irel->r_addend & RL78_RELAXA_ALIGN)
2118         {
2119           int this_glue = 1 << (irel->r_addend & RL78_RELAXA_ANUM);
2120
2121           if (section_alignment_glue < this_glue)
2122             section_alignment_glue = this_glue;
2123         }
2124   /* Worst case is all 0..N alignments, in order, causing 2*N-1 byte
2125      shrinkage.  */
2126   section_alignment_glue *= 2;
2127
2128   for (irel = internal_relocs; irel < irelend; irel++)
2129     {
2130       unsigned char *insn;
2131       int nrelocs;
2132
2133       /* The insns we care about are all marked with one of these.  */
2134       if (ELF32_R_TYPE (irel->r_info) != R_RL78_RH_RELAX)
2135         continue;
2136
2137       if (irel->r_addend & RL78_RELAXA_ALIGN
2138           || next_alignment == internal_relocs)
2139         {
2140           /* When we delete bytes, we need to maintain all the alignments
2141              indicated.  In addition, we need to be careful about relaxing
2142              jumps across alignment boundaries - these displacements
2143              *grow* when we delete bytes.  For now, don't shrink
2144              displacements across an alignment boundary, just in case.
2145              Note that this only affects relocations to the same
2146              section.  */
2147           prev_alignment = next_alignment;
2148           next_alignment += 2;
2149           while (next_alignment < irelend
2150                  && (ELF32_R_TYPE (next_alignment->r_info) != R_RL78_RH_RELAX
2151                      || !(next_alignment->r_addend & RL78_RELAXA_ELIGN)))
2152             next_alignment ++;
2153           if (next_alignment >= irelend || next_alignment->r_offset == 0)
2154             next_alignment = NULL;
2155         }
2156
2157       /* When we hit alignment markers, see if we've shrunk enough
2158          before them to reduce the gap without violating the alignment
2159          requirements.  */
2160       if (irel->r_addend & RL78_RELAXA_ALIGN)
2161         {
2162           /* At this point, the next relocation *should* be the ELIGN
2163              end marker.  */
2164           Elf_Internal_Rela *erel = irel + 1;
2165           unsigned int alignment, nbytes;
2166
2167           if (ELF32_R_TYPE (erel->r_info) != R_RL78_RH_RELAX)
2168             continue;
2169           if (!(erel->r_addend & RL78_RELAXA_ELIGN))
2170             continue;
2171
2172           alignment = 1 << (irel->r_addend & RL78_RELAXA_ANUM);
2173
2174           if (erel->r_offset - irel->r_offset < alignment)
2175             continue;
2176
2177           nbytes = erel->r_offset - irel->r_offset;
2178           nbytes /= alignment;
2179           nbytes *= alignment;
2180
2181           elf32_rl78_relax_delete_bytes (abfd, sec, erel->r_offset-nbytes, nbytes, next_alignment,
2182                                        erel->r_offset == sec->size);
2183           *again = TRUE;
2184
2185           continue;
2186         }
2187
2188       if (irel->r_addend & RL78_RELAXA_ELIGN)
2189           continue;
2190
2191       insn = contents + irel->r_offset;
2192
2193       nrelocs = irel->r_addend & RL78_RELAXA_RNUM;
2194
2195       /* At this point, we have an insn that is a candidate for linker
2196          relaxation.  There are NRELOCS relocs following that may be
2197          relaxed, although each reloc may be made of more than one
2198          reloc entry (such as gp-rel symbols).  */
2199
2200       /* Get the value of the symbol referred to by the reloc.  Just
2201          in case this is the last reloc in the list, use the RL's
2202          addend to choose between this reloc (no addend) or the next
2203          (yes addend, which means at least one following reloc).  */
2204
2205       /* srel points to the "current" reloction for this insn -
2206          actually the last reloc for a given operand, which is the one
2207          we need to update.  We check the relaxations in the same
2208          order that the relocations happen, so we'll just push it
2209          along as we go.  */
2210       srel = irel;
2211
2212       pc = sec->output_section->vma + sec->output_offset
2213         + srel->r_offset;
2214
2215 #define GET_RELOC \
2216       symval = OFFSET_FOR_RELOC (srel, &srel, &scale); \
2217       pcrel = symval - pc + srel->r_addend; \
2218       nrelocs --;
2219
2220 #define SNIPNR(offset, nbytes) \
2221         elf32_rl78_relax_delete_bytes (abfd, sec, (insn - contents) + offset, nbytes, next_alignment, 0);
2222 #define SNIP(offset, nbytes, newtype) \
2223         SNIPNR (offset, nbytes);                                                \
2224         srel->r_info = ELF32_R_INFO (ELF32_R_SYM (srel->r_info), newtype)
2225
2226       /* The order of these bit tests must match the order that the
2227          relocs appear in.  Since we sorted those by offset, we can
2228          predict them.  */
2229
2230       /*----------------------------------------------------------------------*/
2231       /* EF ad          BR $rel8        pcrel
2232          ED al ah       BR !abs16       abs
2233          EE al ah       BR $!rel16      pcrel
2234          EC al ah as    BR !!abs20      abs
2235
2236          FD al ah       CALL !abs16     abs
2237          FE al ah       CALL $!rel16    pcrel
2238          FC al ah as    CALL !!abs20    abs
2239
2240          DC ad          BC  $rel8
2241          DE ad          BNC $rel8
2242          DD ad          BZ  $rel8
2243          DF ad          BNZ $rel8
2244          61 C3 ad       BH  $rel8
2245          61 D3 ad       BNH $rel8
2246          61 C8 EF ad    SKC  ; BR $rel8
2247          61 D8 EF ad    SKNC ; BR $rel8
2248          61 E8 EF ad    SKZ  ; BR $rel8
2249          61 F8 EF ad    SKNZ ; BR $rel8
2250          61 E3 EF ad    SKH  ; BR $rel8
2251          61 F3 EF ad    SKNH ; BR $rel8
2252        */
2253
2254       if (irel->r_addend & RL78_RELAXA_BRA)
2255         {
2256           GET_RELOC;
2257
2258           switch (insn[0])
2259             {
2260             case 0xec: /* BR !!abs20 */
2261
2262               if (pcrel < 127
2263                   && pcrel > -127)
2264                 {
2265                   insn[0] = 0xef;
2266                   insn[1] = pcrel;
2267                   SNIP (2, 2, R_RL78_DIR8S_PCREL);
2268                   *again = TRUE;
2269                 }
2270               else if (symval < 65536)
2271                 {
2272                   insn[0] = 0xed;
2273                   insn[1] = symval & 0xff;
2274                   insn[2] = symval >> 8;
2275                   SNIP (2, 1, R_RL78_DIR16S);
2276                   *again = TRUE;
2277                 }
2278               else if (pcrel < 32767
2279                        && pcrel > -32767)
2280                 {
2281                   insn[0] = 0xee;
2282                   insn[1] = pcrel & 0xff;
2283                   insn[2] = pcrel >> 8;
2284                   SNIP (2, 1, R_RL78_DIR16S_PCREL);
2285                   *again = TRUE;
2286                 }
2287               break;
2288
2289             case 0xee: /* BR $!pcrel16 */
2290             case 0xed: /* BR $!abs16 */
2291               if (pcrel < 127
2292                   && pcrel > -127)
2293                 {
2294                   insn[0] = 0xef;
2295                   insn[1] = pcrel;
2296                   SNIP (2, 1, R_RL78_DIR8S_PCREL);
2297                   *again = TRUE;
2298                 }
2299               break;
2300
2301             case 0xfc: /* CALL !!abs20 */
2302               if (symval < 65536)
2303                 {
2304                   insn[0] = 0xfd;
2305                   insn[1] = symval & 0xff;
2306                   insn[2] = symval >> 8;
2307                   SNIP (2, 1, R_RL78_DIR16S);
2308                   *again = TRUE;
2309                 }
2310               else if (pcrel < 32767
2311                        && pcrel > -32767)
2312                 {
2313                   insn[0] = 0xfe;
2314                   insn[1] = pcrel & 0xff;
2315                   insn[2] = pcrel >> 8;
2316                   SNIP (2, 1, R_RL78_DIR16S_PCREL);
2317                   *again = TRUE;
2318                 }
2319               break;
2320
2321             case 0x61: /* PREFIX */
2322               /* For SKIP/BR, we change the BR opcode and delete the
2323                  SKIP.  That way, we don't have to find and change the
2324                  relocation for the BR.  */
2325               switch (insn[1])
2326                 {
2327                 case 0xc8: /* SKC */
2328                   if (insn[2] == 0xef)
2329                     {
2330                       insn[2] = 0xde; /* BNC */
2331                       SNIPNR (0, 2);
2332                     }
2333                   break;
2334
2335                 case 0xd8: /* SKNC */
2336                   if (insn[2] == 0xef)
2337                     {
2338                       insn[2] = 0xdc; /* BC */
2339                       SNIPNR (0, 2);
2340                     }
2341                   break;
2342
2343                 case 0xe8: /* SKZ */
2344                   if (insn[2] == 0xef)
2345                     {
2346                       insn[2] = 0xdf; /* BNZ */
2347                       SNIPNR (0, 2);
2348                     }
2349                   break;
2350
2351                 case 0xf8: /* SKNZ */
2352                   if (insn[2] == 0xef)
2353                     {
2354                       insn[2] = 0xdd; /* BZ */
2355                       SNIPNR (0, 2);
2356                     }
2357                   break;
2358
2359                 case 0xe3: /* SKH */
2360                   if (insn[2] == 0xef)
2361                     {
2362                       insn[2] = 0xd3; /* BNH */
2363                       SNIPNR (1, 1); /* we reuse the 0x61 prefix from the SKH */
2364                     }
2365                   break;
2366
2367                 case 0xf3: /* SKNH */
2368                   if (insn[2] == 0xef)
2369                     {
2370                       insn[2] = 0xc3; /* BH */
2371                       SNIPNR (1, 1); /* we reuse the 0x61 prefix from the SKH */
2372                     }
2373                   break;
2374                 }
2375               break;
2376             }
2377
2378         }
2379
2380       if (irel->r_addend & RL78_RELAXA_ADDR16)
2381         {
2382           /*----------------------------------------------------------------------*/
2383           /* Some insns have both a 16-bit address operand and an 8-bit
2384              variant if the address is within a special range:
2385
2386              Address            16-bit operand  SADDR range     SFR range
2387              FFF00-FFFFF        0xff00-0xffff   0x00-0xff
2388              FFE20-FFF1F        0xfe20-0xff1f                   0x00-0xff
2389
2390              The RELAX_ADDR16[] array has the insn encodings for the
2391              16-bit operand version, as well as the SFR and SADDR
2392              variants.  We only need to replace the encodings and
2393              adjust the operand.
2394
2395              Note: we intentionally do not attempt to decode and skip
2396              any ES: prefix, as adding ES: means the addr16 (likely)
2397              no longer points to saddr/sfr space.
2398           */
2399
2400           int is_sfr;
2401           int is_saddr;
2402           int idx;
2403           int poff;
2404
2405           GET_RELOC;
2406
2407           printf("relax_addr16 detected, symval 0x%lx %02x %02x\n", symval, insn[0], insn[1]);
2408
2409           if (0xffe20 <= symval && symval <= 0xfffff)
2410             {
2411
2412               is_saddr = (0xffe20 <= symval && symval <= 0xfff1f);
2413               is_sfr   = (0xfff00 <= symval && symval <= 0xfffff);
2414
2415               for (idx = 0; relax_addr16[idx].insn != -1; idx ++)
2416                 {
2417                   if (relax_addr16[idx].prefix != -1
2418                       && insn[0] == relax_addr16[idx].prefix
2419                       && insn[1] == relax_addr16[idx].insn)
2420                     {
2421                       poff = 1;
2422                     }
2423                   else if (relax_addr16[idx].prefix == -1
2424                            && insn[0] == relax_addr16[idx].insn)
2425                     {
2426                       poff = 0;
2427                     }
2428                   else
2429                     continue;
2430
2431                   /* We have a matched insn, and poff is 0 or 1 depending
2432                      on the base pattern size.  */
2433
2434                   if (is_sfr && relax_addr16[idx].insn_for_sfr != -1)
2435                     {
2436                       insn[poff] = relax_addr16[idx].insn_for_sfr;
2437                       SNIP (poff+2, 1, R_RL78_RH_SFR);
2438                       printf(" - replaced by SFR\n");
2439                     }
2440
2441                   else if  (is_saddr && relax_addr16[idx].insn_for_saddr != -1)
2442                     {
2443                       insn[poff] = relax_addr16[idx].insn_for_saddr;
2444                       SNIP (poff+2, 1, R_RL78_RH_SADDR);
2445                       printf(" - replaced by SADDR\n");
2446                     }
2447
2448                 }
2449             }
2450         }
2451
2452       /*----------------------------------------------------------------------*/
2453
2454     }
2455
2456   return TRUE;
2457
2458  error_return:
2459   if (free_relocs != NULL)
2460     free (free_relocs);
2461
2462   if (free_contents != NULL)
2463     free (free_contents);
2464
2465   if (shndx_buf != NULL)
2466     {
2467       shndx_hdr->contents = NULL;
2468       free (shndx_buf);
2469     }
2470
2471   if (free_intsyms != NULL)
2472     free (free_intsyms);
2473
2474   return TRUE;
2475 }
2476
2477 \f
2478
2479 #define ELF_ARCH                bfd_arch_rl78
2480 #define ELF_MACHINE_CODE        EM_RL78
2481 #define ELF_MAXPAGESIZE         0x1000
2482
2483 #define TARGET_LITTLE_SYM       bfd_elf32_rl78_vec
2484 #define TARGET_LITTLE_NAME      "elf32-rl78"
2485
2486 #define elf_info_to_howto_rel                   NULL
2487 #define elf_info_to_howto                       rl78_info_to_howto_rela
2488 #define elf_backend_object_p                    rl78_elf_object_p
2489 #define elf_backend_relocate_section            rl78_elf_relocate_section
2490 #define elf_symbol_leading_char                 ('_')
2491 #define elf_backend_can_gc_sections             1
2492
2493 #define bfd_elf32_bfd_reloc_type_lookup         rl78_reloc_type_lookup
2494 #define bfd_elf32_bfd_reloc_name_lookup         rl78_reloc_name_lookup
2495 #define bfd_elf32_bfd_set_private_flags         rl78_elf_set_private_flags
2496 #define bfd_elf32_bfd_merge_private_bfd_data    rl78_elf_merge_private_bfd_data
2497 #define bfd_elf32_bfd_print_private_bfd_data    rl78_elf_print_private_bfd_data
2498
2499 #define bfd_elf32_bfd_relax_section             rl78_elf_relax_section
2500 #define elf_backend_check_relocs                rl78_elf_check_relocs
2501 #define elf_backend_always_size_sections \
2502   rl78_elf_always_size_sections
2503 #define elf_backend_finish_dynamic_sections \
2504   rl78_elf_finish_dynamic_sections
2505
2506 #include "elf32-target.h"