bfd/elf32-rl78.c

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