bfd/elf32-rl78.c

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