bfd/elf32-rx.c

   1 /* Renesas RX specific support for 32-bit ELF.
   2    Copyright (C) 2008-2017 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/rx.h"
  26 #include "libiberty.h"
  27 #include "elf32-rx.h"
  28
  29 #define RX_OPCODE_BIG_ENDIAN 0
  30
  31 /* This is a meta-target that's used only with objcopy, to avoid the
  32    endian-swap we would otherwise get.  We check for this in
  33    rx_elf_object_p().  */
  34 const bfd_target rx_elf32_be_ns_vec;
  35 const bfd_target rx_elf32_be_vec;
  36
  37 #ifdef DEBUG
  38 char * rx_get_reloc (long);
  39 void rx_dump_symtab (bfd *, void *, void *);
  40 #endif
  41
  42 #define RXREL(n,sz,bit,shift,complain,pcrel)                                 \
  43   HOWTO (R_RX_##n, shift, sz, bit, pcrel, 0, complain_overflow_ ## complain, \
  44          bfd_elf_generic_reloc, "R_RX_" #n, FALSE, 0, ~0, FALSE)
  45
  46 /* Note that the relocations around 0x7f are internal to this file;
  47    feel free to move them as needed to avoid conflicts with published
  48    relocation numbers.  */
  49
  50 static reloc_howto_type rx_elf_howto_table [] =
  51 {
  52   RXREL (NONE,         3,  0, 0, dont,     FALSE),
  53   RXREL (DIR32,        2, 32, 0, signed,   FALSE),
  54   RXREL (DIR24S,       2, 24, 0, signed,   FALSE),
  55   RXREL (DIR16,        1, 16, 0, dont,     FALSE),
  56   RXREL (DIR16U,       1, 16, 0, unsigned, FALSE),
  57   RXREL (DIR16S,       1, 16, 0, signed,   FALSE),
  58   RXREL (DIR8,         0,  8, 0, dont,     FALSE),
  59   RXREL (DIR8U,        0,  8, 0, unsigned, FALSE),
  60   RXREL (DIR8S,        0,  8, 0, signed,   FALSE),
  61   RXREL (DIR24S_PCREL, 2, 24, 0, signed,   TRUE),
  62   RXREL (DIR16S_PCREL, 1, 16, 0, signed,   TRUE),
  63   RXREL (DIR8S_PCREL,  0,  8, 0, signed,   TRUE),
  64   RXREL (DIR16UL,      1, 16, 2, unsigned, FALSE),
  65   RXREL (DIR16UW,      1, 16, 1, unsigned, FALSE),
  66   RXREL (DIR8UL,       0,  8, 2, unsigned, FALSE),
  67   RXREL (DIR8UW,       0,  8, 1, unsigned, FALSE),
  68   RXREL (DIR32_REV,    1, 16, 0, dont,     FALSE),
  69   RXREL (DIR16_REV,    1, 16, 0, dont,     FALSE),
  70   RXREL (DIR3U_PCREL,  0,  3, 0, dont,     TRUE),
  71
  72   EMPTY_HOWTO (0x13),
  73   EMPTY_HOWTO (0x14),
  74   EMPTY_HOWTO (0x15),
  75   EMPTY_HOWTO (0x16),
  76   EMPTY_HOWTO (0x17),
  77   EMPTY_HOWTO (0x18),
  78   EMPTY_HOWTO (0x19),
  79   EMPTY_HOWTO (0x1a),
  80   EMPTY_HOWTO (0x1b),
  81   EMPTY_HOWTO (0x1c),
  82   EMPTY_HOWTO (0x1d),
  83   EMPTY_HOWTO (0x1e),
  84   EMPTY_HOWTO (0x1f),
  85
  86   RXREL (RH_3_PCREL, 0,  3, 0, signed,   TRUE),
  87   RXREL (RH_16_OP,   1, 16, 0, signed,   FALSE),
  88   RXREL (RH_24_OP,   2, 24, 0, signed,   FALSE),
  89   RXREL (RH_32_OP,   2, 32, 0, signed,   FALSE),
  90   RXREL (RH_24_UNS,  2, 24, 0, unsigned, FALSE),
  91   RXREL (RH_8_NEG,   0,  8, 0, signed,   FALSE),
  92   RXREL (RH_16_NEG,  1, 16, 0, signed,   FALSE),
  93   RXREL (RH_24_NEG,  2, 24, 0, signed,   FALSE),
  94   RXREL (RH_32_NEG,  2, 32, 0, signed,   FALSE),
  95   RXREL (RH_DIFF,    2, 32, 0, signed,   FALSE),
  96   RXREL (RH_GPRELB,  1, 16, 0, unsigned, FALSE),
  97   RXREL (RH_GPRELW,  1, 16, 0, unsigned, FALSE),
  98   RXREL (RH_GPRELL,  1, 16, 0, unsigned, FALSE),
  99   RXREL (RH_RELAX,   0,  0, 0, dont,     FALSE),
 100
 101   EMPTY_HOWTO (0x2e),
 102   EMPTY_HOWTO (0x2f),
 103   EMPTY_HOWTO (0x30),
 104   EMPTY_HOWTO (0x31),
 105   EMPTY_HOWTO (0x32),
 106   EMPTY_HOWTO (0x33),
 107   EMPTY_HOWTO (0x34),
 108   EMPTY_HOWTO (0x35),
 109   EMPTY_HOWTO (0x36),
 110   EMPTY_HOWTO (0x37),
 111   EMPTY_HOWTO (0x38),
 112   EMPTY_HOWTO (0x39),
 113   EMPTY_HOWTO (0x3a),
 114   EMPTY_HOWTO (0x3b),
 115   EMPTY_HOWTO (0x3c),
 116   EMPTY_HOWTO (0x3d),
 117   EMPTY_HOWTO (0x3e),
 118   EMPTY_HOWTO (0x3f),
 119   EMPTY_HOWTO (0x40),
 120
 121   RXREL (ABS32,        2, 32, 0, dont,     FALSE),
 122   RXREL (ABS24S,       2, 24, 0, signed,   FALSE),
 123   RXREL (ABS16,        1, 16, 0, dont,     FALSE),
 124   RXREL (ABS16U,       1, 16, 0, unsigned, FALSE),
 125   RXREL (ABS16S,       1, 16, 0, signed,   FALSE),
 126   RXREL (ABS8,         0,  8, 0, dont,     FALSE),
 127   RXREL (ABS8U,        0,  8, 0, unsigned, FALSE),
 128   RXREL (ABS8S,        0,  8, 0, signed,   FALSE),
 129   RXREL (ABS24S_PCREL, 2, 24, 0, signed,   TRUE),
 130   RXREL (ABS16S_PCREL, 1, 16, 0, signed,   TRUE),
 131   RXREL (ABS8S_PCREL,  0,  8, 0, signed,   TRUE),
 132   RXREL (ABS16UL,      1, 16, 0, unsigned, FALSE),
 133   RXREL (ABS16UW,      1, 16, 0, unsigned, FALSE),
 134   RXREL (ABS8UL,       0,  8, 0, unsigned, FALSE),
 135   RXREL (ABS8UW,       0,  8, 0, unsigned, FALSE),
 136   RXREL (ABS32_REV,    2, 32, 0, dont,     FALSE),
 137   RXREL (ABS16_REV,    1, 16, 0, dont,     FALSE),
 138
 139 #define STACK_REL_P(x) ((x) <= R_RX_ABS16_REV && (x) >= R_RX_ABS32)
 140
 141   EMPTY_HOWTO (0x52),
 142   EMPTY_HOWTO (0x53),
 143   EMPTY_HOWTO (0x54),
 144   EMPTY_HOWTO (0x55),
 145   EMPTY_HOWTO (0x56),
 146   EMPTY_HOWTO (0x57),
 147   EMPTY_HOWTO (0x58),
 148   EMPTY_HOWTO (0x59),
 149   EMPTY_HOWTO (0x5a),
 150   EMPTY_HOWTO (0x5b),
 151   EMPTY_HOWTO (0x5c),
 152   EMPTY_HOWTO (0x5d),
 153   EMPTY_HOWTO (0x5e),
 154   EMPTY_HOWTO (0x5f),
 155   EMPTY_HOWTO (0x60),
 156   EMPTY_HOWTO (0x61),
 157   EMPTY_HOWTO (0x62),
 158   EMPTY_HOWTO (0x63),
 159   EMPTY_HOWTO (0x64),
 160   EMPTY_HOWTO (0x65),
 161   EMPTY_HOWTO (0x66),
 162   EMPTY_HOWTO (0x67),
 163   EMPTY_HOWTO (0x68),
 164   EMPTY_HOWTO (0x69),
 165   EMPTY_HOWTO (0x6a),
 166   EMPTY_HOWTO (0x6b),
 167   EMPTY_HOWTO (0x6c),
 168   EMPTY_HOWTO (0x6d),
 169   EMPTY_HOWTO (0x6e),
 170   EMPTY_HOWTO (0x6f),
 171   EMPTY_HOWTO (0x70),
 172   EMPTY_HOWTO (0x71),
 173   EMPTY_HOWTO (0x72),
 174   EMPTY_HOWTO (0x73),
 175   EMPTY_HOWTO (0x74),
 176   EMPTY_HOWTO (0x75),
 177   EMPTY_HOWTO (0x76),
 178   EMPTY_HOWTO (0x77),
 179
 180   /* These are internal.  */
 181   /* A 5-bit unsigned displacement to a B/W/L address, at bit position 8/12.  */
 182   /* ---- ----   4--- 3210.  */
 183 #define R_RX_RH_ABS5p8B 0x78
 184   RXREL (RH_ABS5p8B,   0,  0, 0, dont,     FALSE),
 185 #define R_RX_RH_ABS5p8W 0x79
 186   RXREL (RH_ABS5p8W,   0,  0, 0, dont,     FALSE),
 187 #define R_RX_RH_ABS5p8L 0x7a
 188   RXREL (RH_ABS5p8L,   0,  0, 0, dont,     FALSE),
 189   /* A 5-bit unsigned displacement to a B/W/L address, at bit position 5/12.  */
 190   /* ---- -432   1--- 0---.  */
 191 #define R_RX_RH_ABS5p5B 0x7b
 192   RXREL (RH_ABS5p5B,   0,  0, 0, dont,     FALSE),
 193 #define R_RX_RH_ABS5p5W 0x7c
 194   RXREL (RH_ABS5p5W,   0,  0, 0, dont,     FALSE),
 195 #define R_RX_RH_ABS5p5L 0x7d
 196   RXREL (RH_ABS5p5L,   0,  0, 0, dont,     FALSE),
 197   /* A 4-bit unsigned immediate at bit position 8.  */
 198 #define R_RX_RH_UIMM4p8 0x7e
 199   RXREL (RH_UIMM4p8,   0,  0, 0, dont,     FALSE),
 200   /* A 4-bit negative unsigned immediate at bit position 8.  */
 201 #define R_RX_RH_UNEG4p8 0x7f
 202   RXREL (RH_UNEG4p8,   0,  0, 0, dont,     FALSE),
 203   /* End of internal relocs.  */
 204
 205   RXREL (SYM,       2, 32, 0, dont, FALSE),
 206   RXREL (OPneg,     2, 32, 0, dont, FALSE),
 207   RXREL (OPadd,     2, 32, 0, dont, FALSE),
 208   RXREL (OPsub,     2, 32, 0, dont, FALSE),
 209   RXREL (OPmul,     2, 32, 0, dont, FALSE),
 210   RXREL (OPdiv,     2, 32, 0, dont, FALSE),
 211   RXREL (OPshla,    2, 32, 0, dont, FALSE),
 212   RXREL (OPshra,    2, 32, 0, dont, FALSE),
 213   RXREL (OPsctsize, 2, 32, 0, dont, FALSE),
 214   RXREL (OPscttop,  2, 32, 0, dont, FALSE),
 215   RXREL (OPand,     2, 32, 0, dont, FALSE),
 216   RXREL (OPor,      2, 32, 0, dont, FALSE),
 217   RXREL (OPxor,     2, 32, 0, dont, FALSE),
 218   RXREL (OPnot,     2, 32, 0, dont, FALSE),
 219   RXREL (OPmod,     2, 32, 0, dont, FALSE),
 220   RXREL (OPromtop,  2, 32, 0, dont, FALSE),
 221   RXREL (OPramtop,  2, 32, 0, dont, FALSE)
 222 };
 223 \f
 224 /* Map BFD reloc types to RX ELF reloc types.  */
 225
 226 struct rx_reloc_map
 227 {
 228   bfd_reloc_code_real_type  bfd_reloc_val;
 229   unsigned int              rx_reloc_val;
 230 };
 231
 232 static const struct rx_reloc_map rx_reloc_map [] =
 233 {
 234   { BFD_RELOC_NONE,             R_RX_NONE },
 235   { BFD_RELOC_8,                R_RX_DIR8S },
 236   { BFD_RELOC_16,               R_RX_DIR16S },
 237   { BFD_RELOC_24,               R_RX_DIR24S },
 238   { BFD_RELOC_32,               R_RX_DIR32 },
 239   { BFD_RELOC_RX_16_OP,         R_RX_DIR16 },
 240   { BFD_RELOC_RX_DIR3U_PCREL,   R_RX_DIR3U_PCREL },
 241   { BFD_RELOC_8_PCREL,          R_RX_DIR8S_PCREL },
 242   { BFD_RELOC_16_PCREL,         R_RX_DIR16S_PCREL },
 243   { BFD_RELOC_24_PCREL,         R_RX_DIR24S_PCREL },
 244   { BFD_RELOC_RX_8U,            R_RX_DIR8U },
 245   { BFD_RELOC_RX_16U,           R_RX_DIR16U },
 246   { BFD_RELOC_RX_24U,           R_RX_RH_24_UNS },
 247   { BFD_RELOC_RX_NEG8,          R_RX_RH_8_NEG },
 248   { BFD_RELOC_RX_NEG16,         R_RX_RH_16_NEG },
 249   { BFD_RELOC_RX_NEG24,         R_RX_RH_24_NEG },
 250   { BFD_RELOC_RX_NEG32,         R_RX_RH_32_NEG },
 251   { BFD_RELOC_RX_DIFF,          R_RX_RH_DIFF },
 252   { BFD_RELOC_RX_GPRELB,        R_RX_RH_GPRELB },
 253   { BFD_RELOC_RX_GPRELW,        R_RX_RH_GPRELW },
 254   { BFD_RELOC_RX_GPRELL,        R_RX_RH_GPRELL },
 255   { BFD_RELOC_RX_RELAX,         R_RX_RH_RELAX },
 256   { BFD_RELOC_RX_SYM,           R_RX_SYM },
 257   { BFD_RELOC_RX_OP_SUBTRACT,   R_RX_OPsub },
 258   { BFD_RELOC_RX_OP_NEG,        R_RX_OPneg },
 259   { BFD_RELOC_RX_ABS8,          R_RX_ABS8 },
 260   { BFD_RELOC_RX_ABS16,         R_RX_ABS16 },
 261   { BFD_RELOC_RX_ABS16_REV,     R_RX_ABS16_REV },
 262   { BFD_RELOC_RX_ABS32,         R_RX_ABS32 },
 263   { BFD_RELOC_RX_ABS32_REV,     R_RX_ABS32_REV },
 264   { BFD_RELOC_RX_ABS16UL,       R_RX_ABS16UL },
 265   { BFD_RELOC_RX_ABS16UW,       R_RX_ABS16UW },
 266   { BFD_RELOC_RX_ABS16U,        R_RX_ABS16U }
 267 };
 268
 269 #define BIGE(abfd)       ((abfd)->xvec->byteorder == BFD_ENDIAN_BIG)
 270
 271 static reloc_howto_type *
 272 rx_reloc_type_lookup (bfd *                    abfd ATTRIBUTE_UNUSED,
 273                       bfd_reloc_code_real_type code)
 274 {
 275   unsigned int i;
 276
 277   if (code == BFD_RELOC_RX_32_OP)
 278     return rx_elf_howto_table + R_RX_DIR32;
 279
 280   for (i = ARRAY_SIZE (rx_reloc_map); i--;)
 281     if (rx_reloc_map [i].bfd_reloc_val == code)
 282       return rx_elf_howto_table + rx_reloc_map[i].rx_reloc_val;
 283
 284   return NULL;
 285 }
 286
 287 static reloc_howto_type *
 288 rx_reloc_name_lookup (bfd * abfd ATTRIBUTE_UNUSED, const char * r_name)
 289 {
 290   unsigned int i;
 291
 292   for (i = 0; i < ARRAY_SIZE (rx_elf_howto_table); i++)
 293     if (rx_elf_howto_table[i].name != NULL
 294         && strcasecmp (rx_elf_howto_table[i].name, r_name) == 0)
 295       return rx_elf_howto_table + i;
 296
 297   return NULL;
 298 }
 299
 300 /* Set the howto pointer for an RX ELF reloc.  */
 301
 302 static void
 303 rx_info_to_howto_rela (bfd *               abfd ATTRIBUTE_UNUSED,
 304                        arelent *           cache_ptr,
 305                        Elf_Internal_Rela * dst)
 306 {
 307   unsigned int r_type;
 308
 309   r_type = ELF32_R_TYPE (dst->r_info);
 310   if (r_type >= (unsigned int) R_RX_max)
 311     {
 312       /* xgettext:c-format */
 313       _bfd_error_handler (_("%B: invalid RX reloc number: %d"), abfd, r_type);
 314       r_type = 0;
 315     }
 316   cache_ptr->howto = rx_elf_howto_table + r_type;
 317 }
 318 \f
 319 static bfd_vma
 320 get_symbol_value (const char *            name,
 321                   struct bfd_link_info *  info,
 322                   bfd *                   input_bfd,
 323                   asection *              input_section,
 324                   int                     offset)
 325 {
 326   bfd_vma value = 0;
 327   struct bfd_link_hash_entry * h;
 328
 329   h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
 330
 331   if (h == NULL
 332       || (h->type != bfd_link_hash_defined
 333           && h->type != bfd_link_hash_defweak))
 334     (*info->callbacks->undefined_symbol)
 335       (info, name, input_bfd, input_section, offset, TRUE);
 336   else
 337     value = (h->u.def.value
 338              + h->u.def.section->output_section->vma
 339              + h->u.def.section->output_offset);
 340
 341   return value;
 342 }
 343
 344 static bfd_vma
 345 get_symbol_value_maybe (const char *            name,
 346                         struct bfd_link_info *  info)
 347 {
 348   bfd_vma value = 0;
 349   struct bfd_link_hash_entry * h;
 350
 351   h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
 352
 353   if (h == NULL
 354       || (h->type != bfd_link_hash_defined
 355           && h->type != bfd_link_hash_defweak))
 356     return 0;
 357   else
 358     value = (h->u.def.value
 359              + h->u.def.section->output_section->vma
 360              + h->u.def.section->output_offset);
 361
 362   return value;
 363 }
 364
 365 static bfd_vma
 366 get_gp (struct bfd_link_info *  info,
 367         bfd *                   abfd,
 368         asection *              sec,
 369         int                     offset)
 370 {
 371   static bfd_boolean cached = FALSE;
 372   static bfd_vma     cached_value = 0;
 373
 374   if (!cached)
 375     {
 376       cached_value = get_symbol_value ("__gp", info, abfd, sec, offset);
 377       cached = TRUE;
 378     }
 379   return cached_value;
 380 }
 381
 382 static bfd_vma
 383 get_romstart (struct bfd_link_info *  info,
 384               bfd *                   abfd,
 385               asection *              sec,
 386               int                     offset)
 387 {
 388   static bfd_boolean cached = FALSE;
 389   static bfd_vma     cached_value = 0;
 390
 391   if (!cached)
 392     {
 393       cached_value = get_symbol_value ("_start", info, abfd, sec, offset);
 394       cached = TRUE;
 395     }
 396   return cached_value;
 397 }
 398
 399 static bfd_vma
 400 get_ramstart (struct bfd_link_info *  info,
 401               bfd *                   abfd,
 402               asection *              sec,
 403               int                     offset)
 404 {
 405   static bfd_boolean cached = FALSE;
 406   static bfd_vma     cached_value = 0;
 407
 408   if (!cached)
 409     {
 410       cached_value = get_symbol_value ("__datastart", info, abfd, sec, offset);
 411       cached = TRUE;
 412     }
 413   return cached_value;
 414 }
 415
 416 #define NUM_STACK_ENTRIES 16
 417 static int32_t rx_stack [ NUM_STACK_ENTRIES ];
 418 static unsigned int rx_stack_top;
 419
 420 #define RX_STACK_PUSH(val)                      \
 421   do                                            \
 422     {                                           \
 423       if (rx_stack_top < NUM_STACK_ENTRIES)     \
 424         rx_stack [rx_stack_top ++] = (val);     \
 425       else                                      \
 426         r = bfd_reloc_dangerous;                \
 427     }                                           \
 428   while (0)
 429
 430 #define RX_STACK_POP(dest)                      \
 431   do                                            \
 432     {                                           \
 433       if (rx_stack_top > 0)                     \
 434         (dest) = rx_stack [-- rx_stack_top];    \
 435       else                                      \
 436         (dest) = 0, r = bfd_reloc_dangerous;    \
 437     }                                           \
 438   while (0)
 439
 440 /* Relocate an RX ELF section.
 441    There is some attempt to make this function usable for many architectures,
 442    both USE_REL and USE_RELA ['twould be nice if such a critter existed],
 443    if only to serve as a learning tool.
 444
 445    The RELOCATE_SECTION function is called by the new ELF backend linker
 446    to handle the relocations for a section.
 447
 448    The relocs are always passed as Rela structures; if the section
 449    actually uses Rel structures, the r_addend field will always be
 450    zero.
 451
 452    This function is responsible for adjusting the section contents as
 453    necessary, and (if using Rela relocs and generating a relocatable
 454    output file) adjusting the reloc addend as necessary.
 455
 456    This function does not have to worry about setting the reloc
 457    address or the reloc symbol index.
 458
 459    LOCAL_SYMS is a pointer to the swapped in local symbols.
 460
 461    LOCAL_SECTIONS is an array giving the section in the input file
 462    corresponding to the st_shndx field of each local symbol.
 463
 464    The global hash table entry for the global symbols can be found
 465    via elf_sym_hashes (input_bfd).
 466
 467    When generating relocatable output, this function must handle
 468    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
 469    going to be the section symbol corresponding to the output
 470    section, which means that the addend must be adjusted
 471    accordingly.  */
 472
 473 static bfd_boolean
 474 rx_elf_relocate_section
 475     (bfd *                   output_bfd,
 476      struct bfd_link_info *  info,
 477      bfd *                   input_bfd,
 478      asection *              input_section,
 479      bfd_byte *              contents,
 480      Elf_Internal_Rela *     relocs,
 481      Elf_Internal_Sym *      local_syms,
 482      asection **             local_sections)
 483 {
 484   Elf_Internal_Shdr *           symtab_hdr;
 485   struct elf_link_hash_entry ** sym_hashes;
 486   Elf_Internal_Rela *           rel;
 487   Elf_Internal_Rela *           relend;
 488   bfd_boolean                   pid_mode;
 489   bfd_boolean                   saw_subtract = FALSE;
 490   const char *                  table_default_cache = NULL;
 491   bfd_vma                       table_start_cache = 0;
 492   bfd_vma                       table_end_cache = 0;
 493
 494   if (elf_elfheader (output_bfd)->e_flags & E_FLAG_RX_PID)
 495     pid_mode = TRUE;
 496   else
 497     pid_mode = FALSE;
 498
 499   symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
 500   sym_hashes = elf_sym_hashes (input_bfd);
 501   relend     = relocs + input_section->reloc_count;
 502   for (rel = relocs; rel < relend; rel ++)
 503     {
 504       reloc_howto_type *           howto;
 505       unsigned long                r_symndx;
 506       Elf_Internal_Sym *           sym;
 507       asection *                   sec;
 508       struct elf_link_hash_entry * h;
 509       bfd_vma                      relocation;
 510       bfd_reloc_status_type        r;
 511       const char *                 name = NULL;
 512       bfd_boolean                  unresolved_reloc = TRUE;
 513       int                          r_type;
 514
 515       r_type = ELF32_R_TYPE (rel->r_info);
 516       r_symndx = ELF32_R_SYM (rel->r_info);
 517
 518       howto  = rx_elf_howto_table + ELF32_R_TYPE (rel->r_info);
 519       h      = NULL;
 520       sym    = NULL;
 521       sec    = NULL;
 522       relocation = 0;
 523
 524       if (rx_stack_top == 0)
 525         saw_subtract = FALSE;
 526
 527       if (r_symndx < symtab_hdr->sh_info)
 528         {
 529           sym = local_syms + r_symndx;
 530           sec = local_sections [r_symndx];
 531           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, & sec, rel);
 532
 533           name = bfd_elf_string_from_elf_section
 534             (input_bfd, symtab_hdr->sh_link, sym->st_name);
 535           name = (sym->st_name == 0) ? bfd_section_name (input_bfd, sec) : name;
 536         }
 537       else
 538         {
 539           bfd_boolean warned, ignored;
 540
 541           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
 542                                    r_symndx, symtab_hdr, sym_hashes, h,
 543                                    sec, relocation, unresolved_reloc,
 544                                    warned, ignored);
 545
 546           name = h->root.root.string;
 547         }
 548
 549       if (strncmp (name, "$tableentry$default$", 20) == 0)
 550         {
 551           bfd_vma entry_vma;
 552           int idx;
 553           char *buf;
 554
 555           if (table_default_cache != name)
 556             {
 557
 558               /* All relocs for a given table should be to the same
 559                  (weak) default symbol) so we can use it to detect a
 560                  cache miss.  We use the offset into the table to find
 561                  the "real" symbol.  Calculate and store the table's
 562                  offset here.  */
 563
 564               table_default_cache = name;
 565
 566               /* We have already done error checking in rx_table_find().  */
 567
 568               buf = (char *) malloc (13 + strlen (name + 20));
 569
 570               sprintf (buf, "$tablestart$%s", name + 20);
 571               table_start_cache = get_symbol_value (buf,
 572                                                     info,
 573                                                     input_bfd,
 574                                                     input_section,
 575                                                     rel->r_offset);
 576
 577               sprintf (buf, "$tableend$%s", name + 20);
 578               table_end_cache = get_symbol_value (buf,
 579                                                   info,
 580                                                   input_bfd,
 581                                                   input_section,
 582                                                   rel->r_offset);
 583
 584               free (buf);
 585             }
 586
 587           entry_vma = (input_section->output_section->vma
 588                        + input_section->output_offset
 589                        + rel->r_offset);
 590
 591           if (table_end_cache <= entry_vma || entry_vma < table_start_cache)
 592             {
 593               /* xgettext:c-format */
 594               _bfd_error_handler (_("%B:%A: table entry %s outside table"),
 595                                   input_bfd, input_section,
 596                                   name);
 597             }
 598           else if ((int) (entry_vma - table_start_cache) % 4)
 599             {
 600               /* xgettext:c-format */
 601               _bfd_error_handler (_("%B:%A: table entry %s not word-aligned within table"),
 602                                   input_bfd, input_section,
 603                                   name);
 604             }
 605           else
 606             {
 607               idx = (int) (entry_vma - table_start_cache) / 4;
 608
 609               /* This will look like $tableentry$<N>$<name> */
 610               buf = (char *) malloc (12 + 20 + strlen (name + 20));
 611               sprintf (buf, "$tableentry$%d$%s", idx, name + 20);
 612
 613               h = (struct elf_link_hash_entry *) bfd_link_hash_lookup (info->hash, buf, FALSE, FALSE, TRUE);
 614
 615               if (h)
 616                 {
 617                   relocation = (h->root.u.def.value
 618                                 + h->root.u.def.section->output_section->vma
 619                                 + h->root.u.def.section->output_offset);;
 620                 }
 621
 622               free (buf);
 623             }
 624         }
 625
 626       if (sec != NULL && discarded_section (sec))
 627         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
 628                                          rel, 1, relend, howto, 0, contents);
 629
 630       if (bfd_link_relocatable (info))
 631         {
 632           /* This is a relocatable link.  We don't have to change
 633              anything, unless the reloc is against a section symbol,
 634              in which case we have to adjust according to where the
 635              section symbol winds up in the output section.  */
 636           if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
 637             rel->r_addend += sec->output_offset;
 638           continue;
 639         }
 640
 641       if (h != NULL && h->root.type == bfd_link_hash_undefweak)
 642         /* If the symbol is undefined and weak
 643            then the relocation resolves to zero.  */
 644         relocation = 0;
 645       else
 646         {
 647           if (howto->pc_relative)
 648             {
 649               relocation -= (input_section->output_section->vma
 650                              + input_section->output_offset
 651                              + rel->r_offset);
 652               if (r_type != R_RX_RH_3_PCREL
 653                   && r_type != R_RX_DIR3U_PCREL)
 654                 relocation ++;
 655             }
 656
 657           relocation += rel->r_addend;
 658         }
 659
 660       r = bfd_reloc_ok;
 661
 662 #define RANGE(a,b) if (a > (long) relocation || (long) relocation > b) r = bfd_reloc_overflow
 663 #define ALIGN(m)   if (relocation & m) r = bfd_reloc_other;
 664 #define OP(i)      (contents[rel->r_offset + (i)])
 665 #define WARN_REDHAT(type) \
 666       /* xgettext:c-format */ \
 667       _bfd_error_handler (_("%B:%A: Warning: deprecated Red Hat reloc " type " detected against: %s."), \
 668       input_bfd, input_section, name)
 669
 670       /* Check for unsafe relocs in PID mode.  These are any relocs where
 671          an absolute address is being computed.  There are special cases
 672          for relocs against symbols that are known to be referenced in
 673          crt0.o before the PID base address register has been initialised.  */
 674 #define UNSAFE_FOR_PID                                                  \
 675   do                                                                    \
 676     {                                                                   \
 677       if (pid_mode                                                      \
 678           && sec != NULL                                                \
 679           && sec->flags & SEC_READONLY                                  \
 680           && !(input_section->flags & SEC_DEBUGGING)                    \
 681           && strcmp (name, "__pid_base") != 0                           \
 682           && strcmp (name, "__gp") != 0                                 \
 683           && strcmp (name, "__romdatastart") != 0                       \
 684           && !saw_subtract)                                             \
 685         /* xgettext:c-format */                                         \
 686         _bfd_error_handler (_("%B(%A): unsafe PID relocation %s at 0x%08lx (against %s in %s)"), \
 687                             input_bfd, input_section, howto->name,      \
 688                             input_section->output_section->vma + input_section->output_offset + rel->r_offset, \
 689                             name, sec->name);                           \
 690     }                                                                   \
 691   while (0)
 692
 693       /* Opcode relocs are always big endian.  Data relocs are bi-endian.  */
 694       switch (r_type)
 695         {
 696         case R_RX_NONE:
 697           break;
 698
 699         case R_RX_RH_RELAX:
 700           break;
 701
 702         case R_RX_RH_3_PCREL:
 703           WARN_REDHAT ("RX_RH_3_PCREL");
 704           RANGE (3, 10);
 705           OP (0) &= 0xf8;
 706           OP (0) |= relocation & 0x07;
 707           break;
 708
 709         case R_RX_RH_8_NEG:
 710           WARN_REDHAT ("RX_RH_8_NEG");
 711           relocation = - relocation;
 712           /* Fall through.  */
 713         case R_RX_DIR8S_PCREL:
 714           UNSAFE_FOR_PID;
 715           RANGE (-128, 127);
 716           OP (0) = relocation;
 717           break;
 718
 719         case R_RX_DIR8S:
 720           UNSAFE_FOR_PID;
 721           RANGE (-128, 255);
 722           OP (0) = relocation;
 723           break;
 724
 725         case R_RX_DIR8U:
 726           UNSAFE_FOR_PID;
 727           RANGE (0, 255);
 728           OP (0) = relocation;
 729           break;
 730
 731         case R_RX_RH_16_NEG:
 732           WARN_REDHAT ("RX_RH_16_NEG");
 733           relocation = - relocation;
 734           /* Fall through.  */
 735         case R_RX_DIR16S_PCREL:
 736           UNSAFE_FOR_PID;
 737           RANGE (-32768, 32767);
 738 #if RX_OPCODE_BIG_ENDIAN
 739 #else
 740           OP (0) = relocation;
 741           OP (1) = relocation >> 8;
 742 #endif
 743           break;
 744
 745         case R_RX_RH_16_OP:
 746           WARN_REDHAT ("RX_RH_16_OP");
 747           UNSAFE_FOR_PID;
 748           RANGE (-32768, 32767);
 749 #if RX_OPCODE_BIG_ENDIAN
 750           OP (1) = relocation;
 751           OP (0) = relocation >> 8;
 752 #else
 753           OP (0) = relocation;
 754           OP (1) = relocation >> 8;
 755 #endif
 756           break;
 757
 758         case R_RX_DIR16S:
 759           UNSAFE_FOR_PID;
 760           RANGE (-32768, 65535);
 761           if (BIGE (output_bfd) && !(input_section->flags & SEC_CODE))
 762             {
 763               OP (1) = relocation;
 764               OP (0) = relocation >> 8;
 765             }
 766           else
 767             {
 768               OP (0) = relocation;
 769               OP (1) = relocation >> 8;
 770             }
 771           break;
 772
 773         case R_RX_DIR16U:
 774           UNSAFE_FOR_PID;
 775           RANGE (0, 65536);
 776 #if RX_OPCODE_BIG_ENDIAN
 777           OP (1) = relocation;
 778           OP (0) = relocation >> 8;
 779 #else
 780           OP (0) = relocation;
 781           OP (1) = relocation >> 8;
 782 #endif
 783           break;
 784
 785         case R_RX_DIR16:
 786           UNSAFE_FOR_PID;
 787           RANGE (-32768, 65536);
 788 #if RX_OPCODE_BIG_ENDIAN
 789           OP (1) = relocation;
 790           OP (0) = relocation >> 8;
 791 #else
 792           OP (0) = relocation;
 793           OP (1) = relocation >> 8;
 794 #endif
 795           break;
 796
 797         case R_RX_DIR16_REV:
 798           UNSAFE_FOR_PID;
 799           RANGE (-32768, 65536);
 800 #if RX_OPCODE_BIG_ENDIAN
 801           OP (0) = relocation;
 802           OP (1) = relocation >> 8;
 803 #else
 804           OP (1) = relocation;
 805           OP (0) = relocation >> 8;
 806 #endif
 807           break;
 808
 809         case R_RX_DIR3U_PCREL:
 810           RANGE (3, 10);
 811           OP (0) &= 0xf8;
 812           OP (0) |= relocation & 0x07;
 813           break;
 814
 815         case R_RX_RH_24_NEG:
 816           UNSAFE_FOR_PID;
 817           WARN_REDHAT ("RX_RH_24_NEG");
 818           relocation = - relocation;
 819           /* Fall through.  */
 820         case R_RX_DIR24S_PCREL:
 821           RANGE (-0x800000, 0x7fffff);
 822 #if RX_OPCODE_BIG_ENDIAN
 823           OP (2) = relocation;
 824           OP (1) = relocation >> 8;
 825           OP (0) = relocation >> 16;
 826 #else
 827           OP (0) = relocation;
 828           OP (1) = relocation >> 8;
 829           OP (2) = relocation >> 16;
 830 #endif
 831           break;
 832
 833         case R_RX_RH_24_OP:
 834           UNSAFE_FOR_PID;
 835           WARN_REDHAT ("RX_RH_24_OP");
 836           RANGE (-0x800000, 0x7fffff);
 837 #if RX_OPCODE_BIG_ENDIAN
 838           OP (2) = relocation;
 839           OP (1) = relocation >> 8;
 840           OP (0) = relocation >> 16;
 841 #else
 842           OP (0) = relocation;
 843           OP (1) = relocation >> 8;
 844           OP (2) = relocation >> 16;
 845 #endif
 846           break;
 847
 848         case R_RX_DIR24S:
 849           UNSAFE_FOR_PID;
 850           RANGE (-0x800000, 0x7fffff);
 851           if (BIGE (output_bfd) && !(input_section->flags & SEC_CODE))
 852             {
 853               OP (2) = relocation;
 854               OP (1) = relocation >> 8;
 855               OP (0) = relocation >> 16;
 856             }
 857           else
 858             {
 859               OP (0) = relocation;
 860               OP (1) = relocation >> 8;
 861               OP (2) = relocation >> 16;
 862             }
 863           break;
 864
 865         case R_RX_RH_24_UNS:
 866           UNSAFE_FOR_PID;
 867           WARN_REDHAT ("RX_RH_24_UNS");
 868           RANGE (0, 0xffffff);
 869 #if RX_OPCODE_BIG_ENDIAN
 870           OP (2) = relocation;
 871           OP (1) = relocation >> 8;
 872           OP (0) = relocation >> 16;
 873 #else
 874           OP (0) = relocation;
 875           OP (1) = relocation >> 8;
 876           OP (2) = relocation >> 16;
 877 #endif
 878           break;
 879
 880         case R_RX_RH_32_NEG:
 881           UNSAFE_FOR_PID;
 882           WARN_REDHAT ("RX_RH_32_NEG");
 883           relocation = - relocation;
 884 #if RX_OPCODE_BIG_ENDIAN
 885           OP (3) = relocation;
 886           OP (2) = relocation >> 8;
 887           OP (1) = relocation >> 16;
 888           OP (0) = relocation >> 24;
 889 #else
 890           OP (0) = relocation;
 891           OP (1) = relocation >> 8;
 892           OP (2) = relocation >> 16;
 893           OP (3) = relocation >> 24;
 894 #endif
 895           break;
 896
 897         case R_RX_RH_32_OP:
 898           UNSAFE_FOR_PID;
 899           WARN_REDHAT ("RX_RH_32_OP");
 900 #if RX_OPCODE_BIG_ENDIAN
 901           OP (3) = relocation;
 902           OP (2) = relocation >> 8;
 903           OP (1) = relocation >> 16;
 904           OP (0) = relocation >> 24;
 905 #else
 906           OP (0) = relocation;
 907           OP (1) = relocation >> 8;
 908           OP (2) = relocation >> 16;
 909           OP (3) = relocation >> 24;
 910 #endif
 911           break;
 912
 913         case R_RX_DIR32:
 914           if (BIGE (output_bfd) && !(input_section->flags & SEC_CODE))
 915             {
 916               OP (3) = relocation;
 917               OP (2) = relocation >> 8;
 918               OP (1) = relocation >> 16;
 919               OP (0) = relocation >> 24;
 920             }
 921           else
 922             {
 923               OP (0) = relocation;
 924               OP (1) = relocation >> 8;
 925               OP (2) = relocation >> 16;
 926               OP (3) = relocation >> 24;
 927             }
 928           break;
 929
 930         case R_RX_DIR32_REV:
 931           if (BIGE (output_bfd))
 932             {
 933               OP (0) = relocation;
 934               OP (1) = relocation >> 8;
 935               OP (2) = relocation >> 16;
 936               OP (3) = relocation >> 24;
 937             }
 938           else
 939             {
 940               OP (3) = relocation;
 941               OP (2) = relocation >> 8;
 942               OP (1) = relocation >> 16;
 943               OP (0) = relocation >> 24;
 944             }
 945           break;
 946
 947         case R_RX_RH_DIFF:
 948           {
 949             bfd_vma val;
 950             WARN_REDHAT ("RX_RH_DIFF");
 951             val = bfd_get_32 (output_bfd, & OP (0));
 952             val -= relocation;
 953             bfd_put_32 (output_bfd, val, & OP (0));
 954           }
 955           break;
 956
 957         case R_RX_RH_GPRELB:
 958           WARN_REDHAT ("RX_RH_GPRELB");
 959           relocation -= get_gp (info, input_bfd, input_section, rel->r_offset);
 960           RANGE (0, 65535);
 961 #if RX_OPCODE_BIG_ENDIAN
 962           OP (1) = relocation;
 963           OP (0) = relocation >> 8;
 964 #else
 965           OP (0) = relocation;
 966           OP (1) = relocation >> 8;
 967 #endif
 968           break;
 969
 970         case R_RX_RH_GPRELW:
 971           WARN_REDHAT ("RX_RH_GPRELW");
 972           relocation -= get_gp (info, input_bfd, input_section, rel->r_offset);
 973           ALIGN (1);
 974           relocation >>= 1;
 975           RANGE (0, 65535);
 976 #if RX_OPCODE_BIG_ENDIAN
 977           OP (1) = relocation;
 978           OP (0) = relocation >> 8;
 979 #else
 980           OP (0) = relocation;
 981           OP (1) = relocation >> 8;
 982 #endif
 983           break;
 984
 985         case R_RX_RH_GPRELL:
 986           WARN_REDHAT ("RX_RH_GPRELL");
 987           relocation -= get_gp (info, input_bfd, input_section, rel->r_offset);
 988           ALIGN (3);
 989           relocation >>= 2;
 990           RANGE (0, 65535);
 991 #if RX_OPCODE_BIG_ENDIAN
 992           OP (1) = relocation;
 993           OP (0) = relocation >> 8;
 994 #else
 995           OP (0) = relocation;
 996           OP (1) = relocation >> 8;
 997 #endif
 998           break;
 999
1000         /* Internal relocations just for relaxation:  */
1001         case R_RX_RH_ABS5p5B:
1002           RX_STACK_POP (relocation);
1003           RANGE (0, 31);
1004           OP (0) &= 0xf8;
1005           OP (0) |= relocation >> 2;
1006           OP (1) &= 0x77;
1007           OP (1) |= (relocation << 6) & 0x80;
1008           OP (1) |= (relocation << 3) & 0x08;
1009           break;
1010
1011         case R_RX_RH_ABS5p5W:
1012           RX_STACK_POP (relocation);
1013           RANGE (0, 62);
1014           ALIGN (1);
1015           relocation >>= 1;
1016           OP (0) &= 0xf8;
1017           OP (0) |= relocation >> 2;
1018           OP (1) &= 0x77;
1019           OP (1) |= (relocation << 6) & 0x80;
1020           OP (1) |= (relocation << 3) & 0x08;
1021           break;
1022
1023         case R_RX_RH_ABS5p5L:
1024           RX_STACK_POP (relocation);
1025           RANGE (0, 124);
1026           ALIGN (3);
1027           relocation >>= 2;
1028           OP (0) &= 0xf8;
1029           OP (0) |= relocation >> 2;
1030           OP (1) &= 0x77;
1031           OP (1) |= (relocation << 6) & 0x80;
1032           OP (1) |= (relocation << 3) & 0x08;
1033           break;
1034
1035         case R_RX_RH_ABS5p8B:
1036           RX_STACK_POP (relocation);
1037           RANGE (0, 31);
1038           OP (0) &= 0x70;
1039           OP (0) |= (relocation << 3) & 0x80;
1040           OP (0) |= relocation & 0x0f;
1041           break;
1042
1043         case R_RX_RH_ABS5p8W:
1044           RX_STACK_POP (relocation);
1045           RANGE (0, 62);
1046           ALIGN (1);
1047           relocation >>= 1;
1048           OP (0) &= 0x70;
1049           OP (0) |= (relocation << 3) & 0x80;
1050           OP (0) |= relocation & 0x0f;
1051           break;
1052
1053         case R_RX_RH_ABS5p8L:
1054           RX_STACK_POP (relocation);
1055           RANGE (0, 124);
1056           ALIGN (3);
1057           relocation >>= 2;
1058           OP (0) &= 0x70;
1059           OP (0) |= (relocation << 3) & 0x80;
1060           OP (0) |= relocation & 0x0f;
1061           break;
1062
1063         case R_RX_RH_UIMM4p8:
1064           RANGE (0, 15);
1065           OP (0) &= 0x0f;
1066           OP (0) |= relocation << 4;
1067           break;
1068
1069         case R_RX_RH_UNEG4p8:
1070           RANGE (-15, 0);
1071           OP (0) &= 0x0f;
1072           OP (0) |= (-relocation) << 4;
1073           break;
1074
1075           /* Complex reloc handling:  */
1076
1077         case R_RX_ABS32:
1078           UNSAFE_FOR_PID;
1079           RX_STACK_POP (relocation);
1080 #if RX_OPCODE_BIG_ENDIAN
1081           OP (3) = relocation;
1082           OP (2) = relocation >> 8;
1083           OP (1) = relocation >> 16;
1084           OP (0) = relocation >> 24;
1085 #else
1086           OP (0) = relocation;
1087           OP (1) = relocation >> 8;
1088           OP (2) = relocation >> 16;
1089           OP (3) = relocation >> 24;
1090 #endif
1091           break;
1092
1093         case R_RX_ABS32_REV:
1094           UNSAFE_FOR_PID;
1095           RX_STACK_POP (relocation);
1096 #if RX_OPCODE_BIG_ENDIAN
1097           OP (0) = relocation;
1098           OP (1) = relocation >> 8;
1099           OP (2) = relocation >> 16;
1100           OP (3) = relocation >> 24;
1101 #else
1102           OP (3) = relocation;
1103           OP (2) = relocation >> 8;
1104           OP (1) = relocation >> 16;
1105           OP (0) = relocation >> 24;
1106 #endif
1107           break;
1108
1109         case R_RX_ABS24S_PCREL:
1110         case R_RX_ABS24S:
1111           UNSAFE_FOR_PID;
1112           RX_STACK_POP (relocation);
1113           RANGE (-0x800000, 0x7fffff);
1114           if (BIGE (output_bfd) && !(input_section->flags & SEC_CODE))
1115             {
1116               OP (2) = relocation;
1117               OP (1) = relocation >> 8;
1118               OP (0) = relocation >> 16;
1119             }
1120           else
1121             {
1122               OP (0) = relocation;
1123               OP (1) = relocation >> 8;
1124               OP (2) = relocation >> 16;
1125             }
1126           break;
1127
1128         case R_RX_ABS16:
1129           UNSAFE_FOR_PID;
1130           RX_STACK_POP (relocation);
1131           RANGE (-32768, 65535);
1132 #if RX_OPCODE_BIG_ENDIAN
1133           OP (1) = relocation;
1134           OP (0) = relocation >> 8;
1135 #else
1136           OP (0) = relocation;
1137           OP (1) = relocation >> 8;
1138 #endif
1139           break;
1140
1141         case R_RX_ABS16_REV:
1142           UNSAFE_FOR_PID;
1143           RX_STACK_POP (relocation);
1144           RANGE (-32768, 65535);
1145 #if RX_OPCODE_BIG_ENDIAN
1146           OP (0) = relocation;
1147           OP (1) = relocation >> 8;
1148 #else
1149           OP (1) = relocation;
1150           OP (0) = relocation >> 8;
1151 #endif
1152           break;
1153
1154         case R_RX_ABS16S_PCREL:
1155         case R_RX_ABS16S:
1156           RX_STACK_POP (relocation);
1157           RANGE (-32768, 32767);
1158           if (BIGE (output_bfd) && !(input_section->flags & SEC_CODE))
1159             {
1160               OP (1) = relocation;
1161               OP (0) = relocation >> 8;
1162             }
1163           else
1164             {
1165               OP (0) = relocation;
1166               OP (1) = relocation >> 8;
1167             }
1168           break;
1169
1170         case R_RX_ABS16U:
1171           UNSAFE_FOR_PID;
1172           RX_STACK_POP (relocation);
1173           RANGE (0, 65536);
1174 #if RX_OPCODE_BIG_ENDIAN
1175           OP (1) = relocation;
1176           OP (0) = relocation >> 8;
1177 #else
1178           OP (0) = relocation;
1179           OP (1) = relocation >> 8;
1180 #endif
1181           break;
1182
1183         case R_RX_ABS16UL:
1184           UNSAFE_FOR_PID;
1185           RX_STACK_POP (relocation);
1186           relocation >>= 2;
1187           RANGE (0, 65536);
1188 #if RX_OPCODE_BIG_ENDIAN
1189           OP (1) = relocation;
1190           OP (0) = relocation >> 8;
1191 #else
1192           OP (0) = relocation;
1193           OP (1) = relocation >> 8;
1194 #endif
1195           break;
1196
1197         case R_RX_ABS16UW:
1198           UNSAFE_FOR_PID;
1199           RX_STACK_POP (relocation);
1200           relocation >>= 1;
1201           RANGE (0, 65536);
1202 #if RX_OPCODE_BIG_ENDIAN
1203           OP (1) = relocation;
1204           OP (0) = relocation >> 8;
1205 #else
1206           OP (0) = relocation;
1207           OP (1) = relocation >> 8;
1208 #endif
1209           break;
1210
1211         case R_RX_ABS8:
1212           UNSAFE_FOR_PID;
1213           RX_STACK_POP (relocation);
1214           RANGE (-128, 255);
1215           OP (0) = relocation;
1216           break;
1217
1218         case R_RX_ABS8U:
1219           UNSAFE_FOR_PID;
1220           RX_STACK_POP (relocation);
1221           RANGE (0, 255);
1222           OP (0) = relocation;
1223           break;
1224
1225         case R_RX_ABS8UL:
1226           UNSAFE_FOR_PID;
1227           RX_STACK_POP (relocation);
1228           relocation >>= 2;
1229           RANGE (0, 255);
1230           OP (0) = relocation;
1231           break;
1232
1233         case R_RX_ABS8UW:
1234           UNSAFE_FOR_PID;
1235           RX_STACK_POP (relocation);
1236           relocation >>= 1;
1237           RANGE (0, 255);
1238           OP (0) = relocation;
1239           break;
1240
1241         case R_RX_ABS8S:
1242           UNSAFE_FOR_PID;
1243           /* Fall through.  */
1244         case R_RX_ABS8S_PCREL:
1245           RX_STACK_POP (relocation);
1246           RANGE (-128, 127);
1247           OP (0) = relocation;
1248           break;
1249
1250         case R_RX_SYM:
1251           if (r_symndx < symtab_hdr->sh_info)
1252             RX_STACK_PUSH (sec->output_section->vma
1253                            + sec->output_offset
1254                            + sym->st_value
1255                            + rel->r_addend);
1256           else
1257             {
1258               if (h != NULL
1259                   && (h->root.type == bfd_link_hash_defined
1260                       || h->root.type == bfd_link_hash_defweak))
1261                 RX_STACK_PUSH (h->root.u.def.value
1262                                + sec->output_section->vma
1263                                + sec->output_offset
1264                                + rel->r_addend);
1265               else
1266                 _bfd_error_handler (_("Warning: RX_SYM reloc with an unknown symbol"));
1267             }
1268           break;
1269
1270         case R_RX_OPneg:
1271           {
1272             int32_t tmp;
1273
1274             saw_subtract = TRUE;
1275             RX_STACK_POP (tmp);
1276             tmp = - tmp;
1277             RX_STACK_PUSH (tmp);
1278           }
1279           break;
1280
1281         case R_RX_OPadd:
1282           {
1283             int32_t tmp1, tmp2;
1284
1285             RX_STACK_POP (tmp1);
1286             RX_STACK_POP (tmp2);
1287             tmp1 += tmp2;
1288             RX_STACK_PUSH (tmp1);
1289           }
1290           break;
1291
1292         case R_RX_OPsub:
1293           {
1294             int32_t tmp1, tmp2;
1295
1296             saw_subtract = TRUE;
1297             RX_STACK_POP (tmp1);
1298             RX_STACK_POP (tmp2);
1299             tmp2 -= tmp1;
1300             RX_STACK_PUSH (tmp2);
1301           }
1302           break;
1303
1304         case R_RX_OPmul:
1305           {
1306             int32_t tmp1, tmp2;
1307
1308             RX_STACK_POP (tmp1);
1309             RX_STACK_POP (tmp2);
1310             tmp1 *= tmp2;
1311             RX_STACK_PUSH (tmp1);
1312           }
1313           break;
1314
1315         case R_RX_OPdiv:
1316           {
1317             int32_t tmp1, tmp2;
1318
1319             RX_STACK_POP (tmp1);
1320             RX_STACK_POP (tmp2);
1321             tmp1 /= tmp2;
1322             RX_STACK_PUSH (tmp1);
1323           }
1324           break;
1325
1326         case R_RX_OPshla:
1327           {
1328             int32_t tmp1, tmp2;
1329
1330             RX_STACK_POP (tmp1);
1331             RX_STACK_POP (tmp2);
1332             tmp1 <<= tmp2;
1333             RX_STACK_PUSH (tmp1);
1334           }
1335           break;
1336
1337         case R_RX_OPshra:
1338           {
1339             int32_t tmp1, tmp2;
1340
1341             RX_STACK_POP (tmp1);
1342             RX_STACK_POP (tmp2);
1343             tmp1 >>= tmp2;
1344             RX_STACK_PUSH (tmp1);
1345           }
1346           break;
1347
1348         case R_RX_OPsctsize:
1349           RX_STACK_PUSH (input_section->size);
1350           break;
1351
1352         case R_RX_OPscttop:
1353           RX_STACK_PUSH (input_section->output_section->vma);
1354           break;
1355
1356         case R_RX_OPand:
1357           {
1358             int32_t tmp1, tmp2;
1359
1360             RX_STACK_POP (tmp1);
1361             RX_STACK_POP (tmp2);
1362             tmp1 &= tmp2;
1363             RX_STACK_PUSH (tmp1);
1364           }
1365           break;
1366
1367         case R_RX_OPor:
1368           {
1369             int32_t tmp1, tmp2;
1370
1371             RX_STACK_POP (tmp1);
1372             RX_STACK_POP (tmp2);
1373             tmp1 |= tmp2;
1374             RX_STACK_PUSH (tmp1);
1375           }
1376           break;
1377
1378         case R_RX_OPxor:
1379           {
1380             int32_t tmp1, tmp2;
1381
1382             RX_STACK_POP (tmp1);
1383             RX_STACK_POP (tmp2);
1384             tmp1 ^= tmp2;
1385             RX_STACK_PUSH (tmp1);
1386           }
1387           break;
1388
1389         case R_RX_OPnot:
1390           {
1391             int32_t tmp;
1392
1393             RX_STACK_POP (tmp);
1394             tmp = ~ tmp;
1395             RX_STACK_PUSH (tmp);
1396           }
1397           break;
1398
1399         case R_RX_OPmod:
1400           {
1401             int32_t tmp1, tmp2;
1402
1403             RX_STACK_POP (tmp1);
1404             RX_STACK_POP (tmp2);
1405             tmp1 %= tmp2;
1406             RX_STACK_PUSH (tmp1);
1407           }
1408           break;
1409
1410         case R_RX_OPromtop:
1411           RX_STACK_PUSH (get_romstart (info, input_bfd, input_section, rel->r_offset));
1412           break;
1413
1414         case R_RX_OPramtop:
1415           RX_STACK_PUSH (get_ramstart (info, input_bfd, input_section, rel->r_offset));
1416           break;
1417
1418         default:
1419           r = bfd_reloc_notsupported;
1420           break;
1421         }
1422
1423       if (r != bfd_reloc_ok)
1424         {
1425           const char * msg = NULL;
1426
1427           switch (r)
1428             {
1429             case bfd_reloc_overflow:
1430               /* Catch the case of a missing function declaration
1431                  and emit a more helpful error message.  */
1432               if (r_type == R_RX_DIR24S_PCREL)
1433                 /* xgettext:c-format */
1434                 msg = _("%B(%A): error: call to undefined function '%s'");
1435               else
1436                 (*info->callbacks->reloc_overflow)
1437                   (info, (h ? &h->root : NULL), name, howto->name, (bfd_vma) 0,
1438                    input_bfd, input_section, rel->r_offset);
1439               break;
1440
1441             case bfd_reloc_undefined:
1442               (*info->callbacks->undefined_symbol)
1443                 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
1444               break;
1445
1446             case bfd_reloc_other:
1447               /* xgettext:c-format */
1448               msg = _("%B(%A): warning: unaligned access to symbol '%s' in the small data area");
1449               break;
1450
1451             case bfd_reloc_outofrange:
1452               /* xgettext:c-format */
1453               msg = _("%B(%A): internal error: out of range error");
1454               break;
1455
1456             case bfd_reloc_notsupported:
1457               /* xgettext:c-format */
1458               msg = _("%B(%A): internal error: unsupported relocation error");
1459               break;
1460
1461             case bfd_reloc_dangerous:
1462               /* xgettext:c-format */
1463               msg = _("%B(%A): internal error: dangerous relocation");
1464               break;
1465
1466             default:
1467               /* xgettext:c-format */
1468               msg = _("%B(%A): internal error: unknown error");
1469               break;
1470             }
1471
1472           if (msg)
1473             _bfd_error_handler (msg, input_bfd, input_section, name);
1474         }
1475     }
1476
1477   return TRUE;
1478 }
1479 \f
1480 /* Relaxation Support.  */
1481
1482 /* Progression of relocations from largest operand size to smallest
1483    operand size.  */
1484
1485 static int
1486 next_smaller_reloc (int r)
1487 {
1488   switch (r)
1489     {
1490     case R_RX_DIR32:            return R_RX_DIR24S;
1491     case R_RX_DIR24S:           return R_RX_DIR16S;
1492     case R_RX_DIR16S:           return R_RX_DIR8S;
1493     case R_RX_DIR8S:            return R_RX_NONE;
1494
1495     case R_RX_DIR16:            return R_RX_DIR8;
1496     case R_RX_DIR8:             return R_RX_NONE;
1497
1498     case R_RX_DIR16U:           return R_RX_DIR8U;
1499     case R_RX_DIR8U:            return R_RX_NONE;
1500
1501     case R_RX_DIR24S_PCREL:     return R_RX_DIR16S_PCREL;
1502     case R_RX_DIR16S_PCREL:     return R_RX_DIR8S_PCREL;
1503     case R_RX_DIR8S_PCREL:      return R_RX_DIR3U_PCREL;
1504
1505     case R_RX_DIR16UL:          return R_RX_DIR8UL;
1506     case R_RX_DIR8UL:           return R_RX_NONE;
1507     case R_RX_DIR16UW:          return R_RX_DIR8UW;
1508     case R_RX_DIR8UW:           return R_RX_NONE;
1509
1510     case R_RX_RH_32_OP:         return R_RX_RH_24_OP;
1511     case R_RX_RH_24_OP:         return R_RX_RH_16_OP;
1512     case R_RX_RH_16_OP:         return R_RX_DIR8;
1513
1514     case R_RX_ABS32:            return R_RX_ABS24S;
1515     case R_RX_ABS24S:           return R_RX_ABS16S;
1516     case R_RX_ABS16:            return R_RX_ABS8;
1517     case R_RX_ABS16U:           return R_RX_ABS8U;
1518     case R_RX_ABS16S:           return R_RX_ABS8S;
1519     case R_RX_ABS8:             return R_RX_NONE;
1520     case R_RX_ABS8U:            return R_RX_NONE;
1521     case R_RX_ABS8S:            return R_RX_NONE;
1522     case R_RX_ABS24S_PCREL:     return R_RX_ABS16S_PCREL;
1523     case R_RX_ABS16S_PCREL:     return R_RX_ABS8S_PCREL;
1524     case R_RX_ABS8S_PCREL:      return R_RX_NONE;
1525     case R_RX_ABS16UL:          return R_RX_ABS8UL;
1526     case R_RX_ABS16UW:          return R_RX_ABS8UW;
1527     case R_RX_ABS8UL:           return R_RX_NONE;
1528     case R_RX_ABS8UW:           return R_RX_NONE;
1529     }
1530   return r;
1531 };
1532
1533 /* Delete some bytes from a section while relaxing.  */
1534
1535 static bfd_boolean
1536 elf32_rx_relax_delete_bytes (bfd *abfd, asection *sec, bfd_vma addr, int count,
1537                              Elf_Internal_Rela *alignment_rel, int force_snip,
1538                              Elf_Internal_Rela *irelstart)
1539 {
1540   Elf_Internal_Shdr * symtab_hdr;
1541   unsigned int        sec_shndx;
1542   bfd_byte *          contents;
1543   Elf_Internal_Rela * irel;
1544   Elf_Internal_Rela * irelend;
1545   Elf_Internal_Sym *  isym;
1546   Elf_Internal_Sym *  isymend;
1547   bfd_vma             toaddr;
1548   unsigned int        symcount;
1549   struct elf_link_hash_entry ** sym_hashes;
1550   struct elf_link_hash_entry ** end_hashes;
1551
1552   if (!alignment_rel)
1553     force_snip = 1;
1554
1555   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1556
1557   contents = elf_section_data (sec)->this_hdr.contents;
1558
1559   /* The deletion must stop at the next alignment boundary, if
1560      ALIGNMENT_REL is non-NULL.  */
1561   toaddr = sec->size;
1562   if (alignment_rel)
1563     toaddr = alignment_rel->r_offset;
1564
1565   BFD_ASSERT (toaddr > addr);
1566
1567   /* Actually delete the bytes.  */
1568   memmove (contents + addr, contents + addr + count,
1569            (size_t) (toaddr - addr - count));
1570
1571   /* If we don't have an alignment marker to worry about, we can just
1572      shrink the section.  Otherwise, we have to fill in the newly
1573      created gap with NOP insns (0x03).  */
1574   if (force_snip)
1575     sec->size -= count;
1576   else
1577     memset (contents + toaddr - count, 0x03, count);
1578
1579   irel = irelstart;
1580   BFD_ASSERT (irel != NULL || sec->reloc_count == 0);
1581   irelend = irel + sec->reloc_count;
1582
1583   /* Adjust all the relocs.  */
1584   for (; irel < irelend; irel++)
1585     {
1586       /* Get the new reloc address.  */
1587       if (irel->r_offset > addr
1588           && (irel->r_offset < toaddr
1589               || (force_snip && irel->r_offset == toaddr)))
1590         irel->r_offset -= count;
1591
1592       /* If we see an ALIGN marker at the end of the gap, we move it
1593          to the beginning of the gap, since marking these gaps is what
1594          they're for.  */
1595       if (irel->r_offset == toaddr
1596           && ELF32_R_TYPE (irel->r_info) == R_RX_RH_RELAX
1597           && irel->r_addend & RX_RELAXA_ALIGN)
1598         irel->r_offset -= count;
1599     }
1600
1601   /* Adjust the local symbols defined in this section.  */
1602   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1603   isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1604   isymend = isym + symtab_hdr->sh_info;
1605
1606   for (; isym < isymend; isym++)
1607     {
1608       /* If the symbol is in the range of memory we just moved, we
1609          have to adjust its value.  */
1610       if (isym->st_shndx == sec_shndx
1611           && isym->st_value > addr
1612           && isym->st_value < toaddr)
1613         isym->st_value -= count;
1614
1615       /* If the symbol *spans* the bytes we just deleted (i.e. it's
1616          *end* is in the moved bytes but it's *start* isn't), then we
1617          must adjust its size.  */
1618       if (isym->st_shndx == sec_shndx
1619           && isym->st_value < addr
1620           && isym->st_value + isym->st_size > addr
1621           && isym->st_value + isym->st_size < toaddr)
1622         isym->st_size -= count;
1623     }
1624
1625   /* Now adjust the global symbols defined in this section.  */
1626   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1627               - symtab_hdr->sh_info);
1628   sym_hashes = elf_sym_hashes (abfd);
1629   end_hashes = sym_hashes + symcount;
1630
1631   for (; sym_hashes < end_hashes; sym_hashes++)
1632     {
1633       struct elf_link_hash_entry *sym_hash = *sym_hashes;
1634
1635       if ((sym_hash->root.type == bfd_link_hash_defined
1636            || sym_hash->root.type == bfd_link_hash_defweak)
1637           && sym_hash->root.u.def.section == sec)
1638         {
1639           /* As above, adjust the value if needed.  */
1640           if (sym_hash->root.u.def.value > addr
1641               && sym_hash->root.u.def.value < toaddr)
1642             sym_hash->root.u.def.value -= count;
1643
1644           /* As above, adjust the size if needed.  */
1645           if (sym_hash->root.u.def.value < addr
1646               && sym_hash->root.u.def.value + sym_hash->size > addr
1647               && sym_hash->root.u.def.value + sym_hash->size < toaddr)
1648             sym_hash->size -= count;
1649         }
1650     }
1651
1652   return TRUE;
1653 }
1654
1655 /* Used to sort relocs by address.  If relocs have the same address,
1656    we maintain their relative order, except that R_RX_RH_RELAX
1657    alignment relocs must be the first reloc for any given address.  */
1658
1659 static void
1660 reloc_bubblesort (Elf_Internal_Rela * r, int count)
1661 {
1662   int i;
1663   bfd_boolean again;
1664   bfd_boolean swappit;
1665
1666   /* This is almost a classic bubblesort.  It's the slowest sort, but
1667      we're taking advantage of the fact that the relocations are
1668      mostly in order already (the assembler emits them that way) and
1669      we need relocs with the same address to remain in the same
1670      relative order.  */
1671   again = TRUE;
1672   while (again)
1673     {
1674       again = FALSE;
1675       for (i = 0; i < count - 1; i ++)
1676         {
1677           if (r[i].r_offset > r[i + 1].r_offset)
1678             swappit = TRUE;
1679           else if (r[i].r_offset < r[i + 1].r_offset)
1680             swappit = FALSE;
1681           else if (ELF32_R_TYPE (r[i + 1].r_info) == R_RX_RH_RELAX
1682                    && (r[i + 1].r_addend & RX_RELAXA_ALIGN))
1683             swappit = TRUE;
1684           else if (ELF32_R_TYPE (r[i + 1].r_info) == R_RX_RH_RELAX
1685                    && (r[i + 1].r_addend & RX_RELAXA_ELIGN)
1686                    && !(ELF32_R_TYPE (r[i].r_info) == R_RX_RH_RELAX
1687                         && (r[i].r_addend & RX_RELAXA_ALIGN)))
1688             swappit = TRUE;
1689           else
1690             swappit = FALSE;
1691
1692           if (swappit)
1693             {
1694               Elf_Internal_Rela tmp;
1695
1696               tmp = r[i];
1697               r[i] = r[i + 1];
1698               r[i + 1] = tmp;
1699               /* If we do move a reloc back, re-scan to see if it
1700                  needs to be moved even further back.  This avoids
1701                  most of the O(n^2) behavior for our cases.  */
1702               if (i > 0)
1703                 i -= 2;
1704               again = TRUE;
1705             }
1706         }
1707     }
1708 }
1709
1710
1711 #define OFFSET_FOR_RELOC(rel, lrel, scale) \
1712   rx_offset_for_reloc (abfd, rel + 1, symtab_hdr, shndx_buf, intsyms, \
1713                        lrel, abfd, sec, link_info, scale)
1714
1715 static bfd_vma
1716 rx_offset_for_reloc (bfd *                    abfd,
1717                      Elf_Internal_Rela *      rel,
1718                      Elf_Internal_Shdr *      symtab_hdr,
1719                      Elf_External_Sym_Shndx * shndx_buf ATTRIBUTE_UNUSED,
1720                      Elf_Internal_Sym *       intsyms,
1721                      Elf_Internal_Rela **     lrel,
1722                      bfd *                    input_bfd,
1723                      asection *               input_section,
1724                      struct bfd_link_info *   info,
1725                      int *                    scale)
1726 {
1727   bfd_vma symval;
1728   bfd_reloc_status_type r;
1729
1730   *scale = 1;
1731
1732   /* REL is the first of 1..N relocations.  We compute the symbol
1733      value for each relocation, then combine them if needed.  LREL
1734      gets a pointer to the last relocation used.  */
1735   while (1)
1736     {
1737       int32_t tmp1, tmp2;
1738
1739       /* Get the value of the symbol referred to by the reloc.  */
1740       if (ELF32_R_SYM (rel->r_info) < symtab_hdr->sh_info)
1741         {
1742           /* A local symbol.  */
1743           Elf_Internal_Sym *isym;
1744           asection *ssec;
1745
1746           isym = intsyms + ELF32_R_SYM (rel->r_info);
1747
1748           if (isym->st_shndx == SHN_UNDEF)
1749             ssec = bfd_und_section_ptr;
1750           else if (isym->st_shndx == SHN_ABS)
1751             ssec = bfd_abs_section_ptr;
1752           else if (isym->st_shndx == SHN_COMMON)
1753             ssec = bfd_com_section_ptr;
1754           else
1755             ssec = bfd_section_from_elf_index (abfd,
1756                                                isym->st_shndx);
1757
1758           /* Initial symbol value.  */
1759           symval = isym->st_value;
1760
1761           /* GAS may have made this symbol relative to a section, in
1762              which case, we have to add the addend to find the
1763              symbol.  */
1764           if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
1765             symval += rel->r_addend;
1766
1767           if (ssec)
1768             {
1769               if ((ssec->flags & SEC_MERGE)
1770                   && ssec->sec_info_type == SEC_INFO_TYPE_MERGE)
1771                 symval = _bfd_merged_section_offset (abfd, & ssec,
1772                                                      elf_section_data (ssec)->sec_info,
1773                                                      symval);
1774             }
1775
1776           /* Now make the offset relative to where the linker is putting it.  */
1777           if (ssec)
1778             symval +=
1779               ssec->output_section->vma + ssec->output_offset;
1780
1781           symval += rel->r_addend;
1782         }
1783       else
1784         {
1785           unsigned long indx;
1786           struct elf_link_hash_entry * h;
1787
1788           /* An external symbol.  */
1789           indx = ELF32_R_SYM (rel->r_info) - symtab_hdr->sh_info;
1790           h = elf_sym_hashes (abfd)[indx];
1791           BFD_ASSERT (h != NULL);
1792
1793           if (h->root.type != bfd_link_hash_defined
1794               && h->root.type != bfd_link_hash_defweak)
1795             {
1796               /* This appears to be a reference to an undefined
1797                  symbol.  Just ignore it--it will be caught by the
1798                  regular reloc processing.  */
1799               if (lrel)
1800                 *lrel = rel;
1801               return 0;
1802             }
1803
1804           symval = (h->root.u.def.value
1805                     + h->root.u.def.section->output_section->vma
1806                     + h->root.u.def.section->output_offset);
1807
1808           symval += rel->r_addend;
1809         }
1810
1811       switch (ELF32_R_TYPE (rel->r_info))
1812         {
1813         case R_RX_SYM:
1814           RX_STACK_PUSH (symval);
1815           break;
1816
1817         case R_RX_OPneg:
1818           RX_STACK_POP (tmp1);
1819           tmp1 = - tmp1;
1820           RX_STACK_PUSH (tmp1);
1821           break;
1822
1823         case R_RX_OPadd:
1824           RX_STACK_POP (tmp1);
1825           RX_STACK_POP (tmp2);
1826           tmp1 += tmp2;
1827           RX_STACK_PUSH (tmp1);
1828           break;
1829
1830         case R_RX_OPsub:
1831           RX_STACK_POP (tmp1);
1832           RX_STACK_POP (tmp2);
1833           tmp2 -= tmp1;
1834           RX_STACK_PUSH (tmp2);
1835           break;
1836
1837         case R_RX_OPmul:
1838           RX_STACK_POP (tmp1);
1839           RX_STACK_POP (tmp2);
1840           tmp1 *= tmp2;
1841           RX_STACK_PUSH (tmp1);
1842           break;
1843
1844         case R_RX_OPdiv:
1845           RX_STACK_POP (tmp1);
1846           RX_STACK_POP (tmp2);
1847           tmp1 /= tmp2;
1848           RX_STACK_PUSH (tmp1);
1849           break;
1850
1851         case R_RX_OPshla:
1852           RX_STACK_POP (tmp1);
1853           RX_STACK_POP (tmp2);
1854           tmp1 <<= tmp2;
1855           RX_STACK_PUSH (tmp1);
1856           break;
1857
1858         case R_RX_OPshra:
1859           RX_STACK_POP (tmp1);
1860           RX_STACK_POP (tmp2);
1861           tmp1 >>= tmp2;
1862           RX_STACK_PUSH (tmp1);
1863           break;
1864
1865         case R_RX_OPsctsize:
1866           RX_STACK_PUSH (input_section->size);
1867           break;
1868
1869         case R_RX_OPscttop:
1870           RX_STACK_PUSH (input_section->output_section->vma);
1871           break;
1872
1873         case R_RX_OPand:
1874           RX_STACK_POP (tmp1);
1875           RX_STACK_POP (tmp2);
1876           tmp1 &= tmp2;
1877           RX_STACK_PUSH (tmp1);
1878           break;
1879
1880         case R_RX_OPor:
1881           RX_STACK_POP (tmp1);
1882           RX_STACK_POP (tmp2);
1883           tmp1 |= tmp2;
1884           RX_STACK_PUSH (tmp1);
1885           break;
1886
1887         case R_RX_OPxor:
1888           RX_STACK_POP (tmp1);
1889           RX_STACK_POP (tmp2);
1890           tmp1 ^= tmp2;
1891           RX_STACK_PUSH (tmp1);
1892           break;
1893
1894         case R_RX_OPnot:
1895           RX_STACK_POP (tmp1);
1896           tmp1 = ~ tmp1;
1897           RX_STACK_PUSH (tmp1);
1898           break;
1899
1900         case R_RX_OPmod:
1901           RX_STACK_POP (tmp1);
1902           RX_STACK_POP (tmp2);
1903           tmp1 %= tmp2;
1904           RX_STACK_PUSH (tmp1);
1905           break;
1906
1907         case R_RX_OPromtop:
1908           RX_STACK_PUSH (get_romstart (info, input_bfd, input_section, rel->r_offset));
1909           break;
1910
1911         case R_RX_OPramtop:
1912           RX_STACK_PUSH (get_ramstart (info, input_bfd, input_section, rel->r_offset));
1913           break;
1914
1915         case R_RX_DIR16UL:
1916         case R_RX_DIR8UL:
1917         case R_RX_ABS16UL:
1918         case R_RX_ABS8UL:
1919           if (rx_stack_top)
1920             RX_STACK_POP (symval);
1921           if (lrel)
1922             *lrel = rel;
1923           *scale = 4;
1924           return symval;
1925
1926         case R_RX_DIR16UW:
1927         case R_RX_DIR8UW:
1928         case R_RX_ABS16UW:
1929         case R_RX_ABS8UW:
1930           if (rx_stack_top)
1931             RX_STACK_POP (symval);
1932           if (lrel)
1933             *lrel = rel;
1934           *scale = 2;
1935           return symval;
1936
1937         default:
1938           if (rx_stack_top)
1939             RX_STACK_POP (symval);
1940           if (lrel)
1941             *lrel = rel;
1942           return symval;
1943         }
1944
1945       rel ++;
1946     }
1947   /* FIXME.  */
1948   (void) r;
1949 }
1950
1951 static void
1952 move_reloc (Elf_Internal_Rela * irel, Elf_Internal_Rela * srel, int delta)
1953 {
1954   bfd_vma old_offset = srel->r_offset;
1955
1956   irel ++;
1957   while (irel <= srel)
1958     {
1959       if (irel->r_offset == old_offset)
1960         irel->r_offset += delta;
1961       irel ++;
1962     }
1963 }
1964
1965 /* Relax one section.  */
1966
1967 static bfd_boolean
1968 elf32_rx_relax_section (bfd *                  abfd,
1969                         asection *             sec,
1970                         struct bfd_link_info * link_info,
1971                         bfd_boolean *          again,
1972                         bfd_boolean            allow_pcrel3)
1973 {
1974   Elf_Internal_Shdr * symtab_hdr;
1975   Elf_Internal_Shdr * shndx_hdr;
1976   Elf_Internal_Rela * internal_relocs;
1977   Elf_Internal_Rela * irel;
1978   Elf_Internal_Rela * srel;
1979   Elf_Internal_Rela * irelend;
1980   Elf_Internal_Rela * next_alignment;
1981   Elf_Internal_Rela * prev_alignment;
1982   bfd_byte *          contents = NULL;
1983   bfd_byte *          free_contents = NULL;
1984   Elf_Internal_Sym *  intsyms = NULL;
1985   Elf_Internal_Sym *  free_intsyms = NULL;
1986   Elf_External_Sym_Shndx * shndx_buf = NULL;
1987   bfd_vma pc;
1988   bfd_vma sec_start;
1989   bfd_vma symval = 0;
1990   int pcrel = 0;
1991   int code = 0;
1992   int section_alignment_glue;
1993   /* how much to scale the relocation by - 1, 2, or 4.  */
1994   int scale;
1995
1996   /* Assume nothing changes.  */
1997   *again = FALSE;
1998
1999   /* We don't have to do anything for a relocatable link, if
2000      this section does not have relocs, or if this is not a
2001      code section.  */
2002   if (bfd_link_relocatable (link_info)
2003       || (sec->flags & SEC_RELOC) == 0
2004       || sec->reloc_count == 0
2005       || (sec->flags & SEC_CODE) == 0)
2006     return TRUE;
2007
2008   symtab_hdr = & elf_symtab_hdr (abfd);
2009   if (elf_symtab_shndx_list (abfd))
2010     shndx_hdr = & elf_symtab_shndx_list (abfd)->hdr;
2011   else
2012     shndx_hdr = NULL;
2013
2014   sec_start = sec->output_section->vma + sec->output_offset;
2015
2016   /* Get the section contents.  */
2017   if (elf_section_data (sec)->this_hdr.contents != NULL)
2018     contents = elf_section_data (sec)->this_hdr.contents;
2019   /* Go get them off disk.  */
2020   else
2021     {
2022       if (! bfd_malloc_and_get_section (abfd, sec, &contents))
2023         goto error_return;
2024       elf_section_data (sec)->this_hdr.contents = contents;
2025     }
2026
2027   /* Read this BFD's symbols.  */
2028   /* Get cached copy if it exists.  */
2029   if (symtab_hdr->contents != NULL)
2030     intsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
2031   else
2032     {
2033       intsyms = bfd_elf_get_elf_syms (abfd, symtab_hdr, symtab_hdr->sh_info, 0, NULL, NULL, NULL);
2034       symtab_hdr->contents = (bfd_byte *) intsyms;
2035     }
2036
2037   if (shndx_hdr && shndx_hdr->sh_size != 0)
2038     {
2039       bfd_size_type amt;
2040
2041       amt = symtab_hdr->sh_info;
2042       amt *= sizeof (Elf_External_Sym_Shndx);
2043       shndx_buf = (Elf_External_Sym_Shndx *) bfd_malloc (amt);
2044       if (shndx_buf == NULL)
2045         goto error_return;
2046       if (bfd_seek (abfd, shndx_hdr->sh_offset, SEEK_SET) != 0
2047           || bfd_bread (shndx_buf, amt, abfd) != amt)
2048         goto error_return;
2049       shndx_hdr->contents = (bfd_byte *) shndx_buf;
2050     }
2051
2052   /* Get a copy of the native relocations.  */
2053   /* Note - we ignore the setting of link_info->keep_memory when reading
2054      in these relocs.  We have to maintain a permanent copy of the relocs
2055      because we are going to walk over them multiple times, adjusting them
2056      as bytes are deleted from the section, and with this relaxation
2057      function itself being called multiple times on the same section...  */
2058   internal_relocs = _bfd_elf_link_read_relocs
2059     (abfd, sec, NULL, (Elf_Internal_Rela *) NULL, TRUE);
2060   if (internal_relocs == NULL)
2061     goto error_return;
2062
2063   /* The RL_ relocs must be just before the operand relocs they go
2064      with, so we must sort them to guarantee this.  We use bubblesort
2065      instead of qsort so we can guarantee that relocs with the same
2066      address remain in the same relative order.  */
2067   reloc_bubblesort (internal_relocs, sec->reloc_count);
2068
2069   /* Walk through them looking for relaxing opportunities.  */
2070   irelend = internal_relocs + sec->reloc_count;
2071
2072   /* This will either be NULL or a pointer to the next alignment
2073      relocation.  */
2074   next_alignment = internal_relocs;
2075   /* This will be the previous alignment, although at first it points
2076      to the first real relocation.  */
2077   prev_alignment = internal_relocs;
2078
2079   /* We calculate worst case shrinkage caused by alignment directives.
2080      No fool-proof, but better than either ignoring the problem or
2081      doing heavy duty analysis of all the alignment markers in all
2082      input sections.  */
2083   section_alignment_glue = 0;
2084   for (irel = internal_relocs; irel < irelend; irel++)
2085       if (ELF32_R_TYPE (irel->r_info) == R_RX_RH_RELAX
2086           && irel->r_addend & RX_RELAXA_ALIGN)
2087         {
2088           int this_glue = 1 << (irel->r_addend & RX_RELAXA_ANUM);
2089
2090           if (section_alignment_glue < this_glue)
2091             section_alignment_glue = this_glue;
2092         }
2093   /* Worst case is all 0..N alignments, in order, causing 2*N-1 byte
2094      shrinkage.  */
2095   section_alignment_glue *= 2;
2096
2097   for (irel = internal_relocs; irel < irelend; irel++)
2098     {
2099       unsigned char *insn;
2100       int nrelocs;
2101
2102       /* The insns we care about are all marked with one of these.  */
2103       if (ELF32_R_TYPE (irel->r_info) != R_RX_RH_RELAX)
2104         continue;
2105
2106       if (irel->r_addend & RX_RELAXA_ALIGN
2107           || next_alignment == internal_relocs)
2108         {
2109           /* When we delete bytes, we need to maintain all the alignments
2110              indicated.  In addition, we need to be careful about relaxing
2111              jumps across alignment boundaries - these displacements
2112              *grow* when we delete bytes.  For now, don't shrink
2113              displacements across an alignment boundary, just in case.
2114              Note that this only affects relocations to the same
2115              section.  */
2116           prev_alignment = next_alignment;
2117           next_alignment += 2;
2118           while (next_alignment < irelend
2119                  && (ELF32_R_TYPE (next_alignment->r_info) != R_RX_RH_RELAX
2120                      || !(next_alignment->r_addend & RX_RELAXA_ELIGN)))
2121             next_alignment ++;
2122           if (next_alignment >= irelend || next_alignment->r_offset == 0)
2123             next_alignment = NULL;
2124         }
2125
2126       /* When we hit alignment markers, see if we've shrunk enough
2127          before them to reduce the gap without violating the alignment
2128          requirements.  */
2129       if (irel->r_addend & RX_RELAXA_ALIGN)
2130         {
2131           /* At this point, the next relocation *should* be the ELIGN
2132              end marker.  */
2133           Elf_Internal_Rela *erel = irel + 1;
2134           unsigned int alignment, nbytes;
2135
2136           if (ELF32_R_TYPE (erel->r_info) != R_RX_RH_RELAX)
2137             continue;
2138           if (!(erel->r_addend & RX_RELAXA_ELIGN))
2139             continue;
2140
2141           alignment = 1 << (irel->r_addend & RX_RELAXA_ANUM);
2142
2143           if (erel->r_offset - irel->r_offset < alignment)
2144             continue;
2145
2146           nbytes = erel->r_offset - irel->r_offset;
2147           nbytes /= alignment;
2148           nbytes *= alignment;
2149
2150           elf32_rx_relax_delete_bytes (abfd, sec, erel->r_offset-nbytes, nbytes, next_alignment,
2151                                        erel->r_offset == sec->size, internal_relocs);
2152           *again = TRUE;
2153
2154           continue;
2155         }
2156
2157       if (irel->r_addend & RX_RELAXA_ELIGN)
2158           continue;
2159
2160       insn = contents + irel->r_offset;
2161
2162       nrelocs = irel->r_addend & RX_RELAXA_RNUM;
2163
2164       /* At this point, we have an insn that is a candidate for linker
2165          relaxation.  There are NRELOCS relocs following that may be
2166          relaxed, although each reloc may be made of more than one
2167          reloc entry (such as gp-rel symbols).  */
2168
2169       /* Get the value of the symbol referred to by the reloc.  Just
2170          in case this is the last reloc in the list, use the RL's
2171          addend to choose between this reloc (no addend) or the next
2172          (yes addend, which means at least one following reloc).  */
2173
2174       /* srel points to the "current" reloction for this insn -
2175          actually the last reloc for a given operand, which is the one
2176          we need to update.  We check the relaxations in the same
2177          order that the relocations happen, so we'll just push it
2178          along as we go.  */
2179       srel = irel;
2180
2181       pc = sec->output_section->vma + sec->output_offset
2182         + srel->r_offset;
2183
2184 #define GET_RELOC \
2185       symval = OFFSET_FOR_RELOC (srel, &srel, &scale); \
2186       pcrel = symval - pc + srel->r_addend; \
2187       nrelocs --;
2188
2189 #define SNIPNR(offset, nbytes) \
2190       elf32_rx_relax_delete_bytes (abfd, sec, (insn - contents) + offset, nbytes, next_alignment, 0, internal_relocs);
2191 #define SNIP(offset, nbytes, newtype) \
2192         SNIPNR (offset, nbytes);                                                \
2193         srel->r_info = ELF32_R_INFO (ELF32_R_SYM (srel->r_info), newtype)
2194
2195       /* The order of these bit tests must match the order that the
2196          relocs appear in.  Since we sorted those by offset, we can
2197          predict them.  */
2198
2199       /* Note that the numbers in, say, DSP6 are the bit offsets of
2200          the code fields that describe the operand.  Bits number 0 for
2201          the MSB of insn[0].  */
2202
2203       /* DSP* codes:
2204            0  00  [reg]
2205            1  01  dsp:8[reg]
2206            2  10  dsp:16[reg]
2207            3  11  reg  */
2208       if (irel->r_addend & RX_RELAXA_DSP6)
2209         {
2210           GET_RELOC;
2211
2212           code = insn[0] & 3;
2213           if (code == 2 && symval/scale <= 255)
2214             {
2215               unsigned int newrel = ELF32_R_TYPE (srel->r_info);
2216               insn[0] &= 0xfc;
2217               insn[0] |= 0x01;
2218               newrel = next_smaller_reloc (ELF32_R_TYPE (srel->r_info));
2219               if (newrel != ELF32_R_TYPE (srel->r_info))
2220                 {
2221                   SNIP (3, 1, newrel);
2222                   *again = TRUE;
2223                 }
2224             }
2225
2226           else if (code == 1 && symval == 0)
2227             {
2228               insn[0] &= 0xfc;
2229               SNIP (2, 1, R_RX_NONE);
2230               *again = TRUE;
2231             }
2232
2233           /* Special case DSP:5 format: MOV.bwl dsp:5[Rsrc],Rdst.  */
2234           else if (code == 1 && symval/scale <= 31
2235                    /* Decodable bits.  */
2236                    && (insn[0] & 0xcc) == 0xcc
2237                    /* Width.  */
2238                    && (insn[0] & 0x30) != 0x30
2239                    /* Register MSBs.  */
2240                    && (insn[1] & 0x88)  == 0x00)
2241             {
2242               int newrel = 0;
2243
2244               insn[0] = 0x88 | (insn[0] & 0x30);
2245               /* The register fields are in the right place already.  */
2246
2247               /* We can't relax this new opcode.  */
2248               irel->r_addend = 0;
2249
2250               switch ((insn[0] & 0x30) >> 4)
2251                 {
2252                 case 0:
2253                   newrel = R_RX_RH_ABS5p5B;
2254                   break;
2255                 case 1:
2256                   newrel = R_RX_RH_ABS5p5W;
2257                   break;
2258                 case 2:
2259                   newrel = R_RX_RH_ABS5p5L;
2260                   break;
2261                 }
2262
2263               move_reloc (irel, srel, -2);
2264               SNIP (2, 1, newrel);
2265             }
2266
2267           /* Special case DSP:5 format: MOVU.bw dsp:5[Rsrc],Rdst.  */
2268           else if (code == 1 && symval/scale <= 31
2269                    /* Decodable bits.  */
2270                    && (insn[0] & 0xf8) == 0x58
2271                    /* Register MSBs.  */
2272                    && (insn[1] & 0x88)  == 0x00)
2273             {
2274               int newrel = 0;
2275
2276               insn[0] = 0xb0 | ((insn[0] & 0x04) << 1);
2277               /* The register fields are in the right place already.  */
2278
2279               /* We can't relax this new opcode.  */
2280               irel->r_addend = 0;
2281
2282               switch ((insn[0] & 0x08) >> 3)
2283                 {
2284                 case 0:
2285                   newrel = R_RX_RH_ABS5p5B;
2286                   break;
2287                 case 1:
2288                   newrel = R_RX_RH_ABS5p5W;
2289                   break;
2290                 }
2291
2292               move_reloc (irel, srel, -2);
2293               SNIP (2, 1, newrel);
2294             }
2295         }
2296
2297       /* A DSP4 operand always follows a DSP6 operand, even if there's
2298          no relocation for it.  We have to read the code out of the
2299          opcode to calculate the offset of the operand.  */
2300       if (irel->r_addend & RX_RELAXA_DSP4)
2301         {
2302           int code6, offset = 0;
2303
2304           GET_RELOC;
2305
2306           code6 = insn[0] & 0x03;
2307           switch (code6)
2308             {
2309             case 0: offset = 2; break;
2310             case 1: offset = 3; break;
2311             case 2: offset = 4; break;
2312             case 3: offset = 2; break;
2313             }
2314
2315           code = (insn[0] & 0x0c) >> 2;
2316
2317           if (code == 2 && symval / scale <= 255)
2318             {
2319               unsigned int newrel = ELF32_R_TYPE (srel->r_info);
2320
2321               insn[0] &= 0xf3;
2322               insn[0] |= 0x04;
2323               newrel = next_smaller_reloc (ELF32_R_TYPE (srel->r_info));
2324               if (newrel != ELF32_R_TYPE (srel->r_info))
2325                 {
2326                   SNIP (offset+1, 1, newrel);
2327                   *again = TRUE;
2328                 }
2329             }
2330
2331           else if (code == 1 && symval == 0)
2332             {
2333               insn[0] &= 0xf3;
2334               SNIP (offset, 1, R_RX_NONE);
2335               *again = TRUE;
2336             }
2337           /* Special case DSP:5 format: MOV.bwl Rsrc,dsp:5[Rdst] */
2338           else if (code == 1 && symval/scale <= 31
2339                    /* Decodable bits.  */
2340                    && (insn[0] & 0xc3) == 0xc3
2341                    /* Width.  */
2342                    && (insn[0] & 0x30) != 0x30
2343                    /* Register MSBs.  */
2344                    && (insn[1] & 0x88)  == 0x00)
2345             {
2346               int newrel = 0;
2347
2348               insn[0] = 0x80 | (insn[0] & 0x30);
2349               /* The register fields are in the right place already.  */
2350
2351               /* We can't relax this new opcode.  */
2352               irel->r_addend = 0;
2353
2354               switch ((insn[0] & 0x30) >> 4)
2355                 {
2356                 case 0:
2357                   newrel = R_RX_RH_ABS5p5B;
2358                   break;
2359                 case 1:
2360                   newrel = R_RX_RH_ABS5p5W;
2361                   break;
2362                 case 2:
2363                   newrel = R_RX_RH_ABS5p5L;
2364                   break;
2365                 }
2366
2367               move_reloc (irel, srel, -2);
2368               SNIP (2, 1, newrel);
2369             }
2370         }
2371
2372       /* These always occur alone, but the offset depends on whether
2373          it's a MEMEX opcode (0x06) or not.  */
2374       if (irel->r_addend & RX_RELAXA_DSP14)
2375         {
2376           int offset;
2377           GET_RELOC;
2378
2379           if (insn[0] == 0x06)
2380             offset = 3;
2381           else
2382             offset = 4;
2383
2384           code = insn[1] & 3;
2385
2386           if (code == 2 && symval / scale <= 255)
2387             {
2388               unsigned int newrel = ELF32_R_TYPE (srel->r_info);
2389
2390               insn[1] &= 0xfc;
2391               insn[1] |= 0x01;
2392               newrel = next_smaller_reloc (ELF32_R_TYPE (srel->r_info));
2393               if (newrel != ELF32_R_TYPE (srel->r_info))
2394                 {
2395                   SNIP (offset, 1, newrel);
2396                   *again = TRUE;
2397                 }
2398             }
2399           else if (code == 1 && symval == 0)
2400             {
2401               insn[1] &= 0xfc;
2402               SNIP (offset, 1, R_RX_NONE);
2403               *again = TRUE;
2404             }
2405         }
2406
2407       /* IMM* codes:
2408            0  00  imm:32
2409            1  01  simm:8
2410            2  10  simm:16
2411            3  11  simm:24.  */
2412
2413       /* These always occur alone.  */
2414       if (irel->r_addend & RX_RELAXA_IMM6)
2415         {
2416           long ssymval;
2417
2418           GET_RELOC;
2419
2420           /* These relocations sign-extend, so we must do signed compares.  */
2421           ssymval = (long) symval;
2422
2423           code = insn[0] & 0x03;
2424
2425           if (code == 0 && ssymval <= 8388607 && ssymval >= -8388608)
2426             {
2427               unsigned int newrel = ELF32_R_TYPE (srel->r_info);
2428
2429               insn[0] &= 0xfc;
2430               insn[0] |= 0x03;
2431               newrel = next_smaller_reloc (ELF32_R_TYPE (srel->r_info));
2432               if (newrel != ELF32_R_TYPE (srel->r_info))
2433                 {
2434                   SNIP (2, 1, newrel);
2435                   *again = TRUE;
2436                 }
2437             }
2438
2439           else if (code == 3 && ssymval <= 32767 && ssymval >= -32768)
2440             {
2441               unsigned int newrel = ELF32_R_TYPE (srel->r_info);
2442
2443               insn[0] &= 0xfc;
2444               insn[0] |= 0x02;
2445               newrel = next_smaller_reloc (ELF32_R_TYPE (srel->r_info));
2446               if (newrel != ELF32_R_TYPE (srel->r_info))
2447                 {
2448                   SNIP (2, 1, newrel);
2449                   *again = TRUE;
2450                 }
2451             }
2452
2453           /* Special case UIMM8 format: CMP #uimm8,Rdst.  */
2454           else if (code == 2 && ssymval <= 255 && ssymval >= 16
2455                    /* Decodable bits.  */
2456                    && (insn[0] & 0xfc) == 0x74
2457                    /* Decodable bits.  */
2458                    && ((insn[1] & 0xf0) == 0x00))
2459             {
2460               int newrel;
2461
2462               insn[0] = 0x75;
2463               insn[1] = 0x50 | (insn[1] & 0x0f);
2464
2465               /* We can't relax this new opcode.  */
2466               irel->r_addend = 0;
2467
2468               if (STACK_REL_P (ELF32_R_TYPE (srel->r_info)))
2469                 newrel = R_RX_ABS8U;
2470               else
2471                 newrel = R_RX_DIR8U;
2472
2473               SNIP (2, 1, newrel);
2474               *again = TRUE;
2475             }
2476
2477           else if (code == 2 && ssymval <= 127 && ssymval >= -128)
2478             {
2479               unsigned int newrel = ELF32_R_TYPE (srel->r_info);
2480
2481               insn[0] &= 0xfc;
2482               insn[0] |= 0x01;
2483               newrel = next_smaller_reloc (ELF32_R_TYPE (srel->r_info));
2484               if (newrel != ELF32_R_TYPE (srel->r_info))
2485                 {
2486                   SNIP (2, 1, newrel);
2487                   *again = TRUE;
2488                 }
2489             }
2490
2491           /* Special case UIMM4 format: CMP, MUL, AND, OR.  */
2492           else if (code == 1 && ssymval <= 15 && ssymval >= 0
2493                    /* Decodable bits and immediate type.  */
2494                    && insn[0] == 0x75
2495                    /* Decodable bits.  */
2496                    && (insn[1] & 0xc0)  == 0x00)
2497             {
2498               static const int newop[4] = { 1, 3, 4, 5 };
2499
2500               insn[0] = 0x60 | newop[insn[1] >> 4];
2501               /* The register number doesn't move.  */
2502
2503               /* We can't relax this new opcode.  */
2504               irel->r_addend = 0;
2505
2506               move_reloc (irel, srel, -1);
2507
2508               SNIP (2, 1, R_RX_RH_UIMM4p8);
2509               *again = TRUE;
2510             }
2511
2512           /* Special case UIMM4 format: ADD -> ADD/SUB.  */
2513           else if (code == 1 && ssymval <= 15 && ssymval >= -15
2514                    /* Decodable bits and immediate type.  */
2515                    && insn[0] == 0x71
2516                    /* Same register for source and destination.  */
2517                    && ((insn[1] >> 4) == (insn[1] & 0x0f)))
2518             {
2519               int newrel;
2520
2521               /* Note that we can't turn "add $0,Rs" into a NOP
2522                  because the flags need to be set right.  */
2523
2524               if (ssymval < 0)
2525                 {
2526                   insn[0] = 0x60; /* Subtract.  */
2527                   newrel = R_RX_RH_UNEG4p8;
2528                 }
2529               else
2530                 {
2531                   insn[0] = 0x62; /* Add.  */
2532                   newrel = R_RX_RH_UIMM4p8;
2533                 }
2534
2535               /* The register number is in the right place.  */
2536
2537               /* We can't relax this new opcode.  */
2538               irel->r_addend = 0;
2539
2540               move_reloc (irel, srel, -1);
2541
2542               SNIP (2, 1, newrel);
2543               *again = TRUE;
2544             }
2545         }
2546
2547       /* These are either matched with a DSP6 (2-byte base) or an id24
2548          (3-byte base).  */
2549       if (irel->r_addend & RX_RELAXA_IMM12)
2550         {
2551           int dspcode, offset = 0;
2552           long ssymval;
2553
2554           GET_RELOC;
2555
2556           if ((insn[0] & 0xfc) == 0xfc)
2557             dspcode = 1; /* Just something with one byte operand.  */
2558           else
2559             dspcode = insn[0] & 3;
2560           switch (dspcode)
2561             {
2562             case 0: offset = 2; break;
2563             case 1: offset = 3; break;
2564             case 2: offset = 4; break;
2565             case 3: offset = 2; break;
2566             }
2567
2568           /* These relocations sign-extend, so we must do signed compares.  */
2569           ssymval = (long) symval;
2570
2571           code = (insn[1] >> 2) & 3;
2572           if (code == 0 && ssymval <= 8388607 && ssymval >= -8388608)
2573             {
2574               unsigned int newrel = ELF32_R_TYPE (srel->r_info);
2575
2576               insn[1] &= 0xf3;
2577               insn[1] |= 0x0c;
2578               newrel = next_smaller_reloc (ELF32_R_TYPE (srel->r_info));
2579               if (newrel != ELF32_R_TYPE (srel->r_info))
2580                 {
2581                   SNIP (offset, 1, newrel);
2582                   *again = TRUE;
2583                 }
2584             }
2585
2586           else if (code == 3 && ssymval <= 32767 && ssymval >= -32768)
2587             {
2588               unsigned int newrel = ELF32_R_TYPE (srel->r_info);
2589
2590               insn[1] &= 0xf3;
2591               insn[1] |= 0x08;
2592               newrel = next_smaller_reloc (ELF32_R_TYPE (srel->r_info));
2593               if (newrel != ELF32_R_TYPE (srel->r_info))
2594                 {
2595                   SNIP (offset, 1, newrel);
2596                   *again = TRUE;
2597                 }
2598             }
2599
2600           /* Special case UIMM8 format: MOV #uimm8,Rdst.  */
2601           else if (code == 2 && ssymval <= 255 && ssymval >= 16
2602                    /* Decodable bits.  */
2603                    && insn[0] == 0xfb
2604                    /* Decodable bits.  */
2605                    && ((insn[1] & 0x03) == 0x02))
2606             {
2607               int newrel;
2608
2609               insn[0] = 0x75;
2610               insn[1] = 0x40 | (insn[1] >> 4);
2611
2612               /* We can't relax this new opcode.  */
2613               irel->r_addend = 0;
2614
2615               if (STACK_REL_P (ELF32_R_TYPE (srel->r_info)))
2616                 newrel = R_RX_ABS8U;
2617               else
2618                 newrel = R_RX_DIR8U;
2619
2620               SNIP (2, 1, newrel);
2621               *again = TRUE;
2622             }
2623
2624           else if (code == 2 && ssymval <= 127 && ssymval >= -128)
2625             {
2626               unsigned int newrel = ELF32_R_TYPE(srel->r_info);
2627
2628               insn[1] &= 0xf3;
2629               insn[1] |= 0x04;
2630               newrel = next_smaller_reloc (ELF32_R_TYPE (srel->r_info));
2631               if (newrel != ELF32_R_TYPE(srel->r_info))
2632                 {
2633                   SNIP (offset, 1, newrel);
2634                   *again = TRUE;
2635                 }
2636             }
2637
2638           /* Special case UIMM4 format: MOV #uimm4,Rdst.  */
2639           else if (code == 1 && ssymval <= 15 && ssymval >= 0
2640                    /* Decodable bits.  */
2641                    && insn[0] == 0xfb
2642                    /* Decodable bits.  */
2643                    && ((insn[1] & 0x03) == 0x02))
2644             {
2645               insn[0] = 0x66;
2646               insn[1] = insn[1] >> 4;
2647
2648               /* We can't relax this new opcode.  */
2649               irel->r_addend = 0;
2650
2651               move_reloc (irel, srel, -1);
2652
2653               SNIP (2, 1, R_RX_RH_UIMM4p8);
2654               *again = TRUE;
2655             }
2656         }
2657
2658       if (irel->r_addend & RX_RELAXA_BRA)
2659         {
2660           unsigned int newrel = ELF32_R_TYPE (srel->r_info);
2661           int max_pcrel3 = 4;
2662           int alignment_glue = 0;
2663
2664           GET_RELOC;
2665
2666           /* Branches over alignment chunks are problematic, as
2667              deleting bytes here makes the branch *further* away.  We
2668              can be agressive with branches within this alignment
2669              block, but not branches outside it.  */
2670           if ((prev_alignment == NULL
2671                || symval < (bfd_vma)(sec_start + prev_alignment->r_offset))
2672               && (next_alignment == NULL
2673                   || symval > (bfd_vma)(sec_start + next_alignment->r_offset)))
2674             alignment_glue = section_alignment_glue;
2675
2676           if (ELF32_R_TYPE(srel[1].r_info) == R_RX_RH_RELAX
2677               && srel[1].r_addend & RX_RELAXA_BRA
2678               && srel[1].r_offset < irel->r_offset + pcrel)
2679             max_pcrel3 ++;
2680
2681           newrel = next_smaller_reloc (ELF32_R_TYPE (srel->r_info));
2682
2683           /* The values we compare PCREL with are not what you'd
2684              expect; they're off by a little to compensate for (1)
2685              where the reloc is relative to the insn, and (2) how much
2686              the insn is going to change when we relax it.  */
2687
2688           /* These we have to decode.  */
2689           switch (insn[0])
2690             {
2691             case 0x04: /* BRA pcdsp:24 */
2692               if (-32768 + alignment_glue <= pcrel
2693                   && pcrel <= 32765 - alignment_glue)
2694                 {
2695                   insn[0] = 0x38;
2696                   SNIP (3, 1, newrel);
2697                   *again = TRUE;
2698                 }
2699               break;
2700
2701             case 0x38: /* BRA pcdsp:16 */
2702               if (-128 + alignment_glue <= pcrel
2703                   && pcrel <= 127 - alignment_glue)
2704                 {
2705                   insn[0] = 0x2e;
2706                   SNIP (2, 1, newrel);
2707                   *again = TRUE;
2708                 }
2709               break;
2710
2711             case 0x2e: /* BRA pcdsp:8 */
2712               /* Note that there's a risk here of shortening things so
2713                  much that we no longer fit this reloc; it *should*
2714                  only happen when you branch across a branch, and that
2715                  branch also devolves into BRA.S.  "Real" code should
2716                  be OK.  */
2717               if (max_pcrel3 + alignment_glue <= pcrel
2718                   && pcrel <= 10 - alignment_glue
2719                   && allow_pcrel3)
2720                 {
2721                   insn[0] = 0x08;
2722                   SNIP (1, 1, newrel);
2723                   move_reloc (irel, srel, -1);
2724                   *again = TRUE;
2725                 }
2726               break;
2727
2728             case 0x05: /* BSR pcdsp:24 */
2729               if (-32768 + alignment_glue <= pcrel
2730                   && pcrel <= 32765 - alignment_glue)
2731                 {
2732                   insn[0] = 0x39;
2733                   SNIP (1, 1, newrel);
2734                   *again = TRUE;
2735                 }
2736               break;
2737
2738             case 0x3a: /* BEQ.W pcdsp:16 */
2739             case 0x3b: /* BNE.W pcdsp:16 */
2740               if (-128 + alignment_glue <= pcrel
2741                   && pcrel <= 127 - alignment_glue)
2742                 {
2743                   insn[0] = 0x20 | (insn[0] & 1);
2744                   SNIP (1, 1, newrel);
2745                   *again = TRUE;
2746                 }
2747               break;
2748
2749             case 0x20: /* BEQ.B pcdsp:8 */
2750             case 0x21: /* BNE.B pcdsp:8 */
2751               if (max_pcrel3 + alignment_glue <= pcrel
2752                   && pcrel - alignment_glue <= 10
2753                   && allow_pcrel3)
2754                 {
2755                   insn[0] = 0x10 | ((insn[0] & 1) << 3);
2756                   SNIP (1, 1, newrel);
2757                   move_reloc (irel, srel, -1);
2758                   *again = TRUE;
2759                 }
2760               break;
2761
2762             case 0x16: /* synthetic BNE dsp24 */
2763             case 0x1e: /* synthetic BEQ dsp24 */
2764               if (-32767 + alignment_glue <= pcrel
2765                   && pcrel <= 32766 - alignment_glue
2766                   && insn[1] == 0x04)
2767                 {
2768                   if (insn[0] == 0x16)
2769                     insn[0] = 0x3b;
2770                   else
2771                     insn[0] = 0x3a;
2772                   /* We snip out the bytes at the end else the reloc
2773                      will get moved too, and too much.  */
2774                   SNIP (3, 2, newrel);
2775                   move_reloc (irel, srel, -1);
2776                   *again = TRUE;
2777                 }
2778               break;
2779             }
2780
2781           /* Special case - synthetic conditional branches, pcrel24.
2782              Note that EQ and NE have been handled above.  */
2783           if ((insn[0] & 0xf0) == 0x20
2784               && insn[1] == 0x06
2785               && insn[2] == 0x04
2786               && srel->r_offset != irel->r_offset + 1
2787               && -32767 + alignment_glue <= pcrel
2788               && pcrel <= 32766 - alignment_glue)
2789             {
2790               insn[1] = 0x05;
2791               insn[2] = 0x38;
2792               SNIP (5, 1, newrel);
2793               *again = TRUE;
2794             }
2795
2796           /* Special case - synthetic conditional branches, pcrel16 */
2797           if ((insn[0] & 0xf0) == 0x20
2798               && insn[1] == 0x05
2799               && insn[2] == 0x38
2800               && srel->r_offset != irel->r_offset + 1
2801               && -127 + alignment_glue <= pcrel
2802               && pcrel <= 126 - alignment_glue)
2803             {
2804               int cond = (insn[0] & 0x0f) ^ 0x01;
2805
2806               insn[0] = 0x20 | cond;
2807               /* By moving the reloc first, we avoid having
2808                  delete_bytes move it also.  */
2809               move_reloc (irel, srel, -2);
2810               SNIP (2, 3, newrel);
2811               *again = TRUE;
2812             }
2813         }
2814
2815       BFD_ASSERT (nrelocs == 0);
2816
2817       /* Special case - check MOV.bwl #IMM, dsp[reg] and see if we can
2818          use MOV.bwl #uimm:8, dsp:5[r7] format.  This is tricky
2819          because it may have one or two relocations.  */
2820       if ((insn[0] & 0xfc) == 0xf8
2821           && (insn[1] & 0x80) == 0x00
2822           && (insn[0] & 0x03) != 0x03)
2823         {
2824           int dcode, icode, reg, ioff, dscale, ilen;
2825           bfd_vma disp_val = 0;
2826           long imm_val = 0;
2827           Elf_Internal_Rela * disp_rel = 0;
2828           Elf_Internal_Rela * imm_rel = 0;
2829
2830           /* Reset this.  */
2831           srel = irel;
2832
2833           dcode = insn[0] & 0x03;
2834           icode = (insn[1] >> 2) & 0x03;
2835           reg = (insn[1] >> 4) & 0x0f;
2836
2837           ioff = dcode == 1 ? 3 : dcode == 2 ? 4 : 2;
2838
2839           /* Figure out what the dispacement is.  */
2840           if (dcode == 1 || dcode == 2)
2841             {
2842               /* There's a displacement.  See if there's a reloc for it.  */
2843               if (srel[1].r_offset == irel->r_offset + 2)
2844                 {
2845                   GET_RELOC;
2846                   disp_val = symval;
2847                   disp_rel = srel;
2848                 }
2849               else
2850                 {
2851                   if (dcode == 1)
2852                     disp_val = insn[2];
2853                   else
2854                     {
2855 #if RX_OPCODE_BIG_ENDIAN
2856                       disp_val = insn[2] * 256 + insn[3];
2857 #else
2858                       disp_val = insn[2] + insn[3] * 256;
2859 #endif
2860                     }
2861                   switch (insn[1] & 3)
2862                     {
2863                     case 1:
2864                       disp_val *= 2;
2865                       scale = 2;
2866                       break;
2867                     case 2:
2868                       disp_val *= 4;
2869                       scale = 4;
2870                       break;
2871                     }
2872                 }
2873             }
2874
2875           dscale = scale;
2876
2877           /* Figure out what the immediate is.  */
2878           if (srel[1].r_offset == irel->r_offset + ioff)
2879             {
2880               GET_RELOC;
2881               imm_val = (long) symval;
2882               imm_rel = srel;
2883             }
2884           else
2885             {
2886               unsigned char * ip = insn + ioff;
2887
2888               switch (icode)
2889                 {
2890                 case 1:
2891                   /* For byte writes, we don't sign extend.  Makes the math easier later.  */
2892                   if (scale == 1)
2893                     imm_val = ip[0];
2894                   else
2895                     imm_val = (char) ip[0];
2896                   break;
2897                 case 2:
2898 #if RX_OPCODE_BIG_ENDIAN
2899                   imm_val = ((char) ip[0] << 8) | ip[1];
2900 #else
2901                   imm_val = ((char) ip[1] << 8) | ip[0];
2902 #endif
2903                   break;
2904                 case 3:
2905 #if RX_OPCODE_BIG_ENDIAN
2906                   imm_val = ((char) ip[0] << 16) | (ip[1] << 8) | ip[2];
2907 #else
2908                   imm_val = ((char) ip[2] << 16) | (ip[1] << 8) | ip[0];
2909 #endif
2910                   break;
2911                 case 0:
2912 #if RX_OPCODE_BIG_ENDIAN
2913                   imm_val = (ip[0] << 24) | (ip[1] << 16) | (ip[2] << 8) | ip[3];
2914 #else
2915                   imm_val = (ip[3] << 24) | (ip[2] << 16) | (ip[1] << 8) | ip[0];
2916 #endif
2917                   break;
2918                 }
2919             }
2920
2921           ilen = 2;
2922
2923           switch (dcode)
2924             {
2925             case 1:
2926               ilen += 1;
2927               break;
2928             case 2:
2929               ilen += 2;
2930               break;
2931             }
2932
2933           switch (icode)
2934             {
2935             case 1:
2936               ilen += 1;
2937               break;
2938             case 2:
2939               ilen += 2;
2940               break;
2941             case 3:
2942               ilen += 3;
2943               break;
2944             case 4:
2945               ilen += 4;
2946               break;
2947             }
2948
2949           /* The shortcut happens when the immediate is 0..255,
2950              register r0 to r7, and displacement (scaled) 0..31.  */
2951
2952           if (0 <= imm_val && imm_val <= 255
2953               && 0 <= reg && reg <= 7
2954               && disp_val / dscale <= 31)
2955             {
2956               insn[0] = 0x3c | (insn[1] & 0x03);
2957               insn[1] = (((disp_val / dscale) << 3) & 0x80) | (reg << 4) | ((disp_val/dscale) & 0x0f);
2958               insn[2] = imm_val;
2959
2960               if (disp_rel)
2961                 {
2962                   int newrel = R_RX_NONE;
2963
2964                   switch (dscale)
2965                     {
2966                     case 1:
2967                       newrel = R_RX_RH_ABS5p8B;
2968                       break;
2969                     case 2:
2970                       newrel = R_RX_RH_ABS5p8W;
2971                       break;
2972                     case 4:
2973                       newrel = R_RX_RH_ABS5p8L;
2974                       break;
2975                     }
2976                   disp_rel->r_info = ELF32_R_INFO (ELF32_R_SYM (disp_rel->r_info), newrel);
2977                   move_reloc (irel, disp_rel, -1);
2978                 }
2979               if (imm_rel)
2980                 {
2981                   imm_rel->r_info = ELF32_R_INFO (ELF32_R_SYM (imm_rel->r_info), R_RX_DIR8U);
2982                   move_reloc (disp_rel ? disp_rel : irel,
2983                               imm_rel,
2984                               irel->r_offset - imm_rel->r_offset + 2);
2985                 }
2986
2987               SNIPNR (3, ilen - 3);
2988               *again = TRUE;
2989
2990               /* We can't relax this new opcode.  */
2991               irel->r_addend = 0;
2992             }
2993         }
2994     }
2995
2996   /* We can't reliably relax branches to DIR3U_PCREL unless we know
2997      whatever they're branching over won't shrink any more.  If we're
2998      basically done here, do one more pass just for branches - but
2999      don't request a pass after that one!  */
3000   if (!*again && !allow_pcrel3)
3001     {
3002       bfd_boolean ignored;
3003
3004       elf32_rx_relax_section (abfd, sec, link_info, &ignored, TRUE);
3005     }
3006
3007   return TRUE;
3008
3009  error_return:
3010   if (free_contents != NULL)
3011     free (free_contents);
3012
3013   if (shndx_buf != NULL)
3014     {
3015       shndx_hdr->contents = NULL;
3016       free (shndx_buf);
3017     }
3018
3019   if (free_intsyms != NULL)
3020     free (free_intsyms);
3021
3022   return FALSE;
3023 }
3024
3025 static bfd_boolean
3026 elf32_rx_relax_section_wrapper (bfd *                  abfd,
3027                                 asection *             sec,
3028                                 struct bfd_link_info * link_info,
3029                                 bfd_boolean *          again)
3030 {
3031   return elf32_rx_relax_section (abfd, sec, link_info, again, FALSE);
3032 }
3033 \f
3034 /* Function to set the ELF flag bits.  */
3035
3036 static bfd_boolean
3037 rx_elf_set_private_flags (bfd * abfd, flagword flags)
3038 {
3039   elf_elfheader (abfd)->e_flags = flags;
3040   elf_flags_init (abfd) = TRUE;
3041   return TRUE;
3042 }
3043
3044 static bfd_boolean no_warn_mismatch = FALSE;
3045 static bfd_boolean ignore_lma = TRUE;
3046
3047 void bfd_elf32_rx_set_target_flags (bfd_boolean, bfd_boolean);
3048
3049 void
3050 bfd_elf32_rx_set_target_flags (bfd_boolean user_no_warn_mismatch,
3051                                bfd_boolean user_ignore_lma)
3052 {
3053   no_warn_mismatch = user_no_warn_mismatch;
3054   ignore_lma = user_ignore_lma;
3055 }
3056
3057 /* Converts FLAGS into a descriptive string.
3058    Returns a static pointer.  */
3059
3060 static const char *
3061 describe_flags (flagword flags)
3062 {
3063   static char buf [128];
3064
3065   buf[0] = 0;
3066
3067   if (flags & E_FLAG_RX_64BIT_DOUBLES)
3068     strcat (buf, "64-bit doubles");
3069   else
3070     strcat (buf, "32-bit doubles");
3071
3072   if (flags & E_FLAG_RX_DSP)
3073     strcat (buf, ", dsp");
3074   else
3075     strcat (buf, ", no dsp");
3076
3077   if (flags & E_FLAG_RX_PID)
3078     strcat (buf, ", pid");
3079   else
3080     strcat (buf, ", no pid");
3081
3082   if (flags & E_FLAG_RX_ABI)
3083     strcat (buf, ", RX ABI");
3084   else
3085     strcat (buf, ", GCC ABI");
3086
3087   if (flags & E_FLAG_RX_SINSNS_SET)
3088     strcat (buf, flags & E_FLAG_RX_SINSNS_YES ? ", uses String instructions" : ", bans String instructions");
3089
3090   return buf;
3091 }
3092
3093 /* Merge backend specific data from an object file to the output
3094    object file when linking.  */
3095
3096 static bfd_boolean
3097 rx_elf_merge_private_bfd_data (bfd * ibfd, struct bfd_link_info *info)
3098 {
3099   bfd *obfd = info->output_bfd;
3100   flagword old_flags;
3101   flagword new_flags;
3102   bfd_boolean error = FALSE;
3103
3104   new_flags = elf_elfheader (ibfd)->e_flags;
3105   old_flags = elf_elfheader (obfd)->e_flags;
3106
3107   if (!elf_flags_init (obfd))
3108     {
3109       /* First call, no flags set.  */
3110       elf_flags_init (obfd) = TRUE;
3111       elf_elfheader (obfd)->e_flags = new_flags;
3112     }
3113   else if (old_flags != new_flags)
3114     {
3115       flagword known_flags;
3116
3117       if (old_flags & E_FLAG_RX_SINSNS_SET)
3118         {
3119           if ((new_flags & E_FLAG_RX_SINSNS_SET) == 0)
3120             {
3121               new_flags &= ~ E_FLAG_RX_SINSNS_MASK;
3122               new_flags |= (old_flags & E_FLAG_RX_SINSNS_MASK);
3123             }
3124         }
3125       else if (new_flags & E_FLAG_RX_SINSNS_SET)
3126         {
3127           old_flags &= ~ E_FLAG_RX_SINSNS_MASK;
3128           old_flags |= (new_flags & E_FLAG_RX_SINSNS_MASK);
3129         }
3130
3131       known_flags = E_FLAG_RX_ABI | E_FLAG_RX_64BIT_DOUBLES
3132         | E_FLAG_RX_DSP | E_FLAG_RX_PID | E_FLAG_RX_SINSNS_MASK;
3133
3134       if ((old_flags ^ new_flags) & known_flags)
3135         {
3136           /* Only complain if flag bits we care about do not match.
3137              Other bits may be set, since older binaries did use some
3138              deprecated flags.  */
3139           if (no_warn_mismatch)
3140             {
3141               elf_elfheader (obfd)->e_flags = (new_flags | old_flags) & known_flags;
3142             }
3143           else
3144             {
3145               _bfd_error_handler (_("There is a conflict merging the ELF header flags from %s"),
3146                                   bfd_get_filename (ibfd));
3147               _bfd_error_handler (_("  the input  file's flags: %s"),
3148                                   describe_flags (new_flags));
3149               _bfd_error_handler (_("  the output file's flags: %s"),
3150                                   describe_flags (old_flags));
3151               error = TRUE;
3152             }
3153         }
3154       else
3155         elf_elfheader (obfd)->e_flags = new_flags & known_flags;
3156     }
3157
3158   if (error)
3159     bfd_set_error (bfd_error_bad_value);
3160
3161   return !error;
3162 }
3163 \f
3164 static bfd_boolean
3165 rx_elf_print_private_bfd_data (bfd * abfd, void * ptr)
3166 {
3167   FILE * file = (FILE *) ptr;
3168   flagword flags;
3169
3170   BFD_ASSERT (abfd != NULL && ptr != NULL);
3171
3172   /* Print normal ELF private data.  */
3173   _bfd_elf_print_private_bfd_data (abfd, ptr);
3174
3175   flags = elf_elfheader (abfd)->e_flags;
3176   fprintf (file, _("private flags = 0x%lx:"), (long) flags);
3177
3178   fprintf (file, "%s", describe_flags (flags));
3179   return TRUE;
3180 }
3181
3182 /* Return the MACH for an e_flags value.  */
3183
3184 static int
3185 elf32_rx_machine (bfd * abfd ATTRIBUTE_UNUSED)
3186 {
3187 #if 0 /* FIXME: EF_RX_CPU_MASK collides with E_FLAG_RX_...
3188          Need to sort out how these flag bits are used.
3189          For now we assume that the flags are OK.  */
3190   if ((elf_elfheader (abfd)->e_flags & EF_RX_CPU_MASK) == EF_RX_CPU_RX)
3191 #endif
3192     return bfd_mach_rx;
3193
3194   return 0;
3195 }
3196
3197 static bfd_boolean
3198 rx_elf_object_p (bfd * abfd)
3199 {
3200   int i;
3201   unsigned int u;
3202   Elf_Internal_Phdr *phdr = elf_tdata (abfd)->phdr;
3203   Elf_Internal_Ehdr *ehdr = elf_elfheader (abfd);
3204   int nphdrs = ehdr->e_phnum;
3205   sec_ptr bsec;
3206   static int saw_be = FALSE;
3207   bfd_vma end_phdroff;
3208
3209   /* We never want to automatically choose the non-swapping big-endian
3210      target.  The user can only get that explicitly, such as with -I
3211      and objcopy.  */
3212   if (abfd->xvec == &rx_elf32_be_ns_vec
3213       && abfd->target_defaulted)
3214     return FALSE;
3215
3216   /* BFD->target_defaulted is not set to TRUE when a target is chosen
3217      as a fallback, so we check for "scanning" to know when to stop
3218      using the non-swapping target.  */
3219   if (abfd->xvec == &rx_elf32_be_ns_vec
3220       && saw_be)
3221     return FALSE;
3222   if (abfd->xvec == &rx_elf32_be_vec)
3223     saw_be = TRUE;
3224
3225   bfd_default_set_arch_mach (abfd, bfd_arch_rx,
3226                              elf32_rx_machine (abfd));
3227
3228   /* For each PHDR in the object, we must find some section that
3229      corresponds (based on matching file offsets) and use its VMA
3230      information to reconstruct the p_vaddr field we clobbered when we
3231      wrote it out.  */
3232   /* If PT_LOAD headers include the ELF file header or program headers
3233      then the PT_LOAD header does not start with some section contents.
3234      Making adjustments based on the difference between sh_offset and
3235      p_offset is nonsense in such cases.  Exclude them.  Note that
3236      since standard linker scripts for RX do not use SIZEOF_HEADERS,
3237      the linker won't normally create PT_LOAD segments covering the
3238      headers so this is mainly for passing the ld testsuite.
3239      FIXME.  Why are we looking at non-PT_LOAD headers here?  */
3240   end_phdroff = ehdr->e_ehsize;
3241   if (ehdr->e_phoff != 0)
3242     end_phdroff = ehdr->e_phoff + nphdrs * ehdr->e_phentsize;
3243   for (i=0; i<nphdrs; i++)
3244     {
3245       for (u=0; u<elf_tdata(abfd)->num_elf_sections; u++)
3246         {
3247           Elf_Internal_Shdr *sec = elf_tdata(abfd)->elf_sect_ptr[u];
3248
3249           if (phdr[i].p_filesz
3250               && phdr[i].p_offset >= end_phdroff
3251               && phdr[i].p_offset <= (bfd_vma) sec->sh_offset
3252               && sec->sh_size > 0
3253               && sec->sh_type != SHT_NOBITS
3254               && (bfd_vma)sec->sh_offset <= phdr[i].p_offset + (phdr[i].p_filesz - 1))
3255             {
3256               /* Found one!  The difference between the two addresses,
3257                  plus the difference between the two file offsets, is
3258                  enough information to reconstruct the lma.  */
3259
3260               /* Example where they aren't:
3261                  PHDR[1] = lma fffc0100 offset 00002010 size 00000100
3262                  SEC[6]  = vma 00000050 offset 00002050 size 00000040
3263
3264                  The correct LMA for the section is fffc0140 + (2050-2010).
3265               */
3266
3267               phdr[i].p_vaddr = sec->sh_addr + (sec->sh_offset - phdr[i].p_offset);
3268               break;
3269             }
3270         }
3271
3272       /* We must update the bfd sections as well, so we don't stop
3273          with one match.  */
3274       bsec = abfd->sections;
3275       while (bsec)
3276         {
3277           if (phdr[i].p_filesz
3278               && phdr[i].p_vaddr <= bsec->vma
3279               && bsec->vma <= phdr[i].p_vaddr + (phdr[i].p_filesz - 1))
3280             {
3281               bsec->lma = phdr[i].p_paddr + (bsec->vma - phdr[i].p_vaddr);
3282             }
3283           bsec = bsec->next;
3284         }
3285     }
3286
3287   return TRUE;
3288 }
3289  \f
3290
3291 #ifdef DEBUG
3292 void
3293 rx_dump_symtab (bfd * abfd, void * internal_syms, void * external_syms)
3294 {
3295   size_t locsymcount;
3296   Elf_Internal_Sym * isymbuf;
3297   Elf_Internal_Sym * isymend;
3298   Elf_Internal_Sym * isym;
3299   Elf_Internal_Shdr * symtab_hdr;
3300   bfd_boolean free_internal = FALSE, free_external = FALSE;
3301   char * st_info_str;
3302   char * st_info_stb_str;
3303   char * st_other_str;
3304   char * st_shndx_str;
3305
3306   if (! internal_syms)
3307     {
3308       internal_syms = bfd_malloc (1000);
3309       free_internal = 1;
3310     }
3311   if (! external_syms)
3312     {
3313       external_syms = bfd_malloc (1000);
3314       free_external = 1;
3315     }
3316
3317   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3318   locsymcount = symtab_hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
3319   if (free_internal)
3320     isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
3321                                     symtab_hdr->sh_info, 0,
3322                                     internal_syms, external_syms, NULL);
3323   else
3324     isymbuf = internal_syms;
3325   isymend = isymbuf + locsymcount;
3326
3327   for (isym = isymbuf ; isym < isymend ; isym++)
3328     {
3329       switch (ELF_ST_TYPE (isym->st_info))
3330         {
3331         case STT_FUNC: st_info_str = "STT_FUNC"; break;
3332         case STT_SECTION: st_info_str = "STT_SECTION"; break;
3333         case STT_FILE: st_info_str = "STT_FILE"; break;
3334         case STT_OBJECT: st_info_str = "STT_OBJECT"; break;
3335         case STT_TLS: st_info_str = "STT_TLS"; break;
3336         default: st_info_str = "";
3337         }
3338       switch (ELF_ST_BIND (isym->st_info))
3339         {
3340         case STB_LOCAL: st_info_stb_str = "STB_LOCAL"; break;
3341         case STB_GLOBAL: st_info_stb_str = "STB_GLOBAL"; break;
3342         default: st_info_stb_str = "";
3343         }
3344       switch (ELF_ST_VISIBILITY (isym->st_other))
3345         {
3346         case STV_DEFAULT: st_other_str = "STV_DEFAULT"; break;
3347         case STV_INTERNAL: st_other_str = "STV_INTERNAL"; break;
3348         case STV_PROTECTED: st_other_str = "STV_PROTECTED"; break;
3349         default: st_other_str = "";
3350         }
3351       switch (isym->st_shndx)
3352         {
3353         case SHN_ABS: st_shndx_str = "SHN_ABS"; break;
3354         case SHN_COMMON: st_shndx_str = "SHN_COMMON"; break;
3355         case SHN_UNDEF: st_shndx_str = "SHN_UNDEF"; break;
3356         default: st_shndx_str = "";
3357         }
3358
3359       printf ("isym = %p st_value = %lx st_size = %lx st_name = (%lu) %s "
3360               "st_info = (%d) %s %s st_other = (%d) %s st_shndx = (%d) %s\n",
3361               isym,
3362               (unsigned long) isym->st_value,
3363               (unsigned long) isym->st_size,
3364               isym->st_name,
3365               bfd_elf_string_from_elf_section (abfd, symtab_hdr->sh_link,
3366                                                isym->st_name),
3367               isym->st_info, st_info_str, st_info_stb_str,
3368               isym->st_other, st_other_str,
3369               isym->st_shndx, st_shndx_str);
3370     }
3371   if (free_internal)
3372     free (internal_syms);
3373   if (free_external)
3374     free (external_syms);
3375 }
3376
3377 char *
3378 rx_get_reloc (long reloc)
3379 {
3380   if (0 <= reloc && reloc < R_RX_max)
3381     return rx_elf_howto_table[reloc].name;
3382   return "";
3383 }
3384 #endif /* DEBUG */
3385
3386 \f
3387 /* We must take care to keep the on-disk copy of any code sections
3388    that are fully linked swapped if the target is big endian, to match
3389    the Renesas tools.  */
3390
3391 /* The rule is: big endian object that are final-link executables,
3392    have code sections stored with 32-bit words swapped relative to
3393    what you'd get by default.  */
3394
3395 static bfd_boolean
3396 rx_get_section_contents (bfd *         abfd,
3397                          sec_ptr       section,
3398                          void *        location,
3399                          file_ptr      offset,
3400                          bfd_size_type count)
3401 {
3402   int exec = (abfd->flags & EXEC_P) ? 1 : 0;
3403   int s_code = (section->flags & SEC_CODE) ? 1 : 0;
3404   bfd_boolean rv;
3405
3406 #ifdef DJDEBUG
3407   fprintf (stderr, "dj: get %ld %ld from %s  %s e%d sc%d  %08lx:%08lx\n",
3408            (long) offset, (long) count, section->name,
3409            bfd_big_endian(abfd) ? "be" : "le",
3410            exec, s_code, (long unsigned) section->filepos,
3411            (long unsigned) offset);
3412 #endif
3413
3414   if (exec && s_code && bfd_big_endian (abfd))
3415     {
3416       char * cloc = (char *) location;
3417       bfd_size_type cnt, end_cnt;
3418
3419       rv = TRUE;
3420
3421       /* Fetch and swap unaligned bytes at the beginning.  */
3422       if (offset % 4)
3423         {
3424           char buf[4];
3425
3426           rv = _bfd_generic_get_section_contents (abfd, section, buf,
3427                                                   (offset & -4), 4);
3428           if (!rv)
3429             return FALSE;
3430
3431           bfd_putb32 (bfd_getl32 (buf), buf);
3432
3433           cnt = 4 - (offset % 4);
3434           if (cnt > count)
3435             cnt = count;
3436
3437           memcpy (location, buf + (offset % 4), cnt);
3438
3439           count -= cnt;
3440           offset += cnt;
3441           cloc += count;
3442         }
3443
3444       end_cnt = count % 4;
3445
3446       /* Fetch and swap the middle bytes.  */
3447       if (count >= 4)
3448         {
3449           rv = _bfd_generic_get_section_contents (abfd, section, cloc, offset,
3450                                                   count - end_cnt);
3451           if (!rv)
3452             return FALSE;
3453
3454           for (cnt = count; cnt >= 4; cnt -= 4, cloc += 4)
3455             bfd_putb32 (bfd_getl32 (cloc), cloc);
3456         }
3457
3458       /* Fetch and swap the end bytes.  */
3459       if (end_cnt > 0)
3460         {
3461           char buf[4];
3462
3463           /* Fetch the end bytes.  */
3464           rv = _bfd_generic_get_section_contents (abfd, section, buf,
3465                                                   offset + count - end_cnt, 4);
3466           if (!rv)
3467             return FALSE;
3468
3469           bfd_putb32 (bfd_getl32 (buf), buf);
3470           memcpy (cloc, buf, end_cnt);
3471         }
3472     }
3473   else
3474     rv = _bfd_generic_get_section_contents (abfd, section, location, offset, count);
3475
3476   return rv;
3477 }
3478
3479 #ifdef DJDEBUG
3480 static bfd_boolean
3481 rx2_set_section_contents (bfd *        abfd,
3482                          sec_ptr       section,
3483                          const void *  location,
3484                          file_ptr      offset,
3485                          bfd_size_type count)
3486 {
3487   bfd_size_type i;
3488
3489   fprintf (stderr, "   set sec %s %08x loc %p offset %#x count %#x\n",
3490            section->name, (unsigned) section->vma, location, (int) offset, (int) count);
3491   for (i = 0; i < count; i++)
3492     {
3493       if (i % 16 == 0 && i > 0)
3494         fprintf (stderr, "\n");
3495
3496       if (i % 16  && i % 4 == 0)
3497         fprintf (stderr, " ");
3498
3499       if (i % 16 == 0)
3500         fprintf (stderr, "      %08x:", (int) (section->vma + offset + i));
3501
3502       fprintf (stderr, " %02x", ((unsigned char *) location)[i]);
3503     }
3504   fprintf (stderr, "\n");
3505
3506   return _bfd_elf_set_section_contents (abfd, section, location, offset, count);
3507 }
3508 #define _bfd_elf_set_section_contents rx2_set_section_contents
3509 #endif
3510
3511 static bfd_boolean
3512 rx_set_section_contents (bfd *         abfd,
3513                          sec_ptr       section,
3514                          const void *  location,
3515                          file_ptr      offset,
3516                          bfd_size_type count)
3517 {
3518   bfd_boolean exec = (abfd->flags & EXEC_P) ? TRUE : FALSE;
3519   bfd_boolean s_code = (section->flags & SEC_CODE) ? TRUE : FALSE;
3520   bfd_boolean rv;
3521   char * swapped_data = NULL;
3522   bfd_size_type i;
3523   bfd_vma caddr = section->vma + offset;
3524   file_ptr faddr = 0;
3525   bfd_size_type scount;
3526
3527 #ifdef DJDEBUG
3528   bfd_size_type i;
3529
3530   fprintf (stderr, "\ndj: set %ld %ld to %s  %s e%d sc%d\n",
3531            (long) offset, (long) count, section->name,
3532            bfd_big_endian (abfd) ? "be" : "le",
3533            exec, s_code);
3534
3535   for (i = 0; i < count; i++)
3536     {
3537       int a = section->vma + offset + i;
3538
3539       if (a % 16 == 0 && a > 0)
3540         fprintf (stderr, "\n");
3541
3542       if (a % 16  && a % 4 == 0)
3543         fprintf (stderr, " ");
3544
3545       if (a % 16 == 0 || i == 0)
3546         fprintf (stderr, "      %08x:", (int) (section->vma + offset + i));
3547
3548       fprintf (stderr, " %02x", ((unsigned char *) location)[i]);
3549     }
3550
3551   fprintf (stderr, "\n");
3552 #endif
3553
3554   if (! exec || ! s_code || ! bfd_big_endian (abfd))
3555     return _bfd_elf_set_section_contents (abfd, section, location, offset, count);
3556
3557   while (count > 0 && caddr > 0 && caddr % 4)
3558     {
3559       switch (caddr % 4)
3560         {
3561         case 0: faddr = offset + 3; break;
3562         case 1: faddr = offset + 1; break;
3563         case 2: faddr = offset - 1; break;
3564         case 3: faddr = offset - 3; break;
3565         }
3566
3567       rv = _bfd_elf_set_section_contents (abfd, section, location, faddr, 1);
3568       if (! rv)
3569         return rv;
3570
3571       location = (bfd_byte *) location + 1;
3572       offset ++;
3573       count --;
3574       caddr ++;
3575     }
3576
3577   scount = (int)(count / 4) * 4;
3578   if (scount > 0)
3579     {
3580       char * cloc = (char *) location;
3581
3582       swapped_data = (char *) bfd_alloc (abfd, count);
3583
3584       for (i = 0; i < count; i += 4)
3585         {
3586           bfd_vma v = bfd_getl32 (cloc + i);
3587           bfd_putb32 (v, swapped_data + i);
3588         }
3589
3590       rv = _bfd_elf_set_section_contents (abfd, section, swapped_data, offset, scount);
3591
3592       if (!rv)
3593         return rv;
3594     }
3595
3596   count -= scount;
3597   location = (bfd_byte *) location + scount;
3598   offset += scount;
3599
3600   if (count > 0)
3601     {
3602       caddr = section->vma + offset;
3603       while (count > 0)
3604         {
3605           switch (caddr % 4)
3606             {
3607             case 0: faddr = offset + 3; break;
3608             case 1: faddr = offset + 1; break;
3609             case 2: faddr = offset - 1; break;
3610             case 3: faddr = offset - 3; break;
3611             }
3612           rv = _bfd_elf_set_section_contents (abfd, section, location, faddr, 1);
3613           if (! rv)
3614             return rv;
3615
3616           location = (bfd_byte *) location + 1;
3617           offset ++;
3618           count --;
3619           caddr ++;
3620         }
3621     }
3622
3623   return TRUE;
3624 }
3625
3626 static bfd_boolean
3627 rx_final_link (bfd * abfd, struct bfd_link_info * info)
3628 {
3629   asection * o;
3630
3631   for (o = abfd->sections; o != NULL; o = o->next)
3632     {
3633 #ifdef DJDEBUG
3634       fprintf (stderr, "sec %s fl %x vma %lx lma %lx size %lx raw %lx\n",
3635                o->name, o->flags, o->vma, o->lma, o->size, o->rawsize);
3636 #endif
3637       if (o->flags & SEC_CODE
3638           && bfd_big_endian (abfd)
3639           && o->size % 4)
3640         {
3641 #ifdef DJDEBUG
3642           fprintf (stderr, "adjusting...\n");
3643 #endif
3644           o->size += 4 - (o->size % 4);
3645         }
3646     }
3647
3648   return bfd_elf_final_link (abfd, info);
3649 }
3650
3651 static bfd_boolean
3652 elf32_rx_modify_program_headers (bfd * abfd ATTRIBUTE_UNUSED,
3653                                  struct bfd_link_info * info ATTRIBUTE_UNUSED)
3654 {
3655   const struct elf_backend_data * bed;
3656   struct elf_obj_tdata * tdata;
3657   Elf_Internal_Phdr * phdr;
3658   unsigned int count;
3659   unsigned int i;
3660
3661   bed = get_elf_backend_data (abfd);
3662   tdata = elf_tdata (abfd);
3663   phdr = tdata->phdr;
3664   count = elf_program_header_size (abfd) / bed->s->sizeof_phdr;
3665
3666   if (ignore_lma)
3667     for (i = count; i-- != 0;)
3668       if (phdr[i].p_type == PT_LOAD)
3669         {
3670           /* The Renesas tools expect p_paddr to be zero.  However,
3671              there is no other way to store the writable data in ROM for
3672              startup initialization.  So, we let the linker *think*
3673              we're using paddr and vaddr the "usual" way, but at the
3674              last minute we move the paddr into the vaddr (which is what
3675              the simulator uses) and zero out paddr.  Note that this
3676              does not affect the section headers, just the program
3677              headers.  We hope.  */
3678           phdr[i].p_vaddr = phdr[i].p_paddr;
3679 #if 0     /* If we zero out p_paddr, then the LMA in the section table
3680              becomes wrong.  */
3681           phdr[i].p_paddr = 0;
3682 #endif
3683         }
3684
3685   return TRUE;
3686 }
3687
3688 /* The default literal sections should always be marked as "code" (i.e.,
3689    SHF_EXECINSTR).  This is particularly important for big-endian mode
3690    when we do not want their contents byte reversed.  */
3691 static const struct bfd_elf_special_section elf32_rx_special_sections[] =
3692 {
3693   { STRING_COMMA_LEN (".init_array"),    0, SHT_INIT_ARRAY, SHF_ALLOC + SHF_EXECINSTR },
3694   { STRING_COMMA_LEN (".fini_array"),    0, SHT_FINI_ARRAY, SHF_ALLOC + SHF_EXECINSTR },
3695   { STRING_COMMA_LEN (".preinit_array"), 0, SHT_PREINIT_ARRAY, SHF_ALLOC + SHF_EXECINSTR },
3696   { NULL,                        0,      0, 0,            0 }
3697 };
3698 \f
3699 typedef struct {
3700   bfd *abfd;
3701   struct bfd_link_info *info;
3702   bfd_vma table_start;
3703   int table_size;
3704   bfd_vma *table_handlers;
3705   bfd_vma table_default_handler;
3706   struct bfd_link_hash_entry **table_entries;
3707   struct bfd_link_hash_entry *table_default_entry;
3708   FILE *mapfile;
3709 } RX_Table_Info;
3710
3711 static bfd_boolean
3712 rx_table_find (struct bfd_hash_entry *vent, void *vinfo)
3713 {
3714   RX_Table_Info *info = (RX_Table_Info *)vinfo;
3715   struct bfd_link_hash_entry *ent = (struct bfd_link_hash_entry *)vent;
3716   const char *name; /* of the symbol we've found */
3717   asection *sec;
3718   struct bfd *abfd;
3719   int idx;
3720   const char *tname; /* name of the table */
3721   bfd_vma start_addr, end_addr;
3722   char *buf;
3723   struct bfd_link_hash_entry * h;
3724
3725   /* We're looking for globally defined symbols of the form
3726      $tablestart$<NAME>.  */
3727   if (ent->type != bfd_link_hash_defined
3728       && ent->type != bfd_link_hash_defweak)
3729     return TRUE;
3730
3731   name = ent->root.string;
3732   sec = ent->u.def.section;
3733   abfd = sec->owner;
3734
3735   if (strncmp (name, "$tablestart$", 12))
3736     return TRUE;
3737
3738   sec->flags |= SEC_KEEP;
3739
3740   tname = name + 12;
3741
3742   start_addr = ent->u.def.value;
3743
3744   /* At this point, we can't build the table but we can (and must)
3745      find all the related symbols and mark their sections as SEC_KEEP
3746      so we don't garbage collect them.  */
3747
3748   buf = (char *) malloc (12 + 10 + strlen (tname));
3749
3750   sprintf (buf, "$tableend$%s", tname);
3751   h = bfd_link_hash_lookup (info->info->hash, buf, FALSE, FALSE, TRUE);
3752   if (!h || (h->type != bfd_link_hash_defined
3753              && h->type != bfd_link_hash_defweak))
3754     {
3755       /* xgettext:c-format */
3756       _bfd_error_handler (_("%B:%A: table %s missing corresponding %s"),
3757                           abfd, sec, name, buf);
3758       return TRUE;
3759     }
3760
3761   if (h->u.def.section != ent->u.def.section)
3762     {
3763       /* xgettext:c-format */
3764       _bfd_error_handler (_("%B:%A: %s and %s must be in the same input section"),
3765                           h->u.def.section->owner, h->u.def.section,
3766                           name, buf);
3767       return TRUE;
3768     }
3769
3770   end_addr = h->u.def.value;
3771
3772   sprintf (buf, "$tableentry$default$%s", tname);
3773   h = bfd_link_hash_lookup (info->info->hash, buf, FALSE, FALSE, TRUE);
3774   if (h && (h->type == bfd_link_hash_defined
3775             || h->type == bfd_link_hash_defweak))
3776     {
3777       h->u.def.section->flags |= SEC_KEEP;
3778     }
3779
3780   for (idx = 0; idx < (int) (end_addr - start_addr) / 4; idx ++)
3781     {
3782       sprintf (buf, "$tableentry$%d$%s", idx, tname);
3783       h = bfd_link_hash_lookup (info->info->hash, buf, FALSE, FALSE, TRUE);
3784       if (h && (h->type == bfd_link_hash_defined
3785                 || h->type == bfd_link_hash_defweak))
3786         {
3787           h->u.def.section->flags |= SEC_KEEP;
3788         }
3789     }
3790
3791   /* Return TRUE to keep scanning, FALSE to end the traversal.  */
3792   return TRUE;
3793 }
3794
3795 /* We need to check for table entry symbols and build the tables, and
3796    we need to do it before the linker does garbage collection.  This function is
3797    called once per input object file.  */
3798 static bfd_boolean
3799 rx_check_directives
3800     (bfd *                     abfd ATTRIBUTE_UNUSED,
3801      struct bfd_link_info *    info ATTRIBUTE_UNUSED)
3802 {
3803   RX_Table_Info stuff;
3804
3805   stuff.abfd = abfd;
3806   stuff.info = info;
3807   bfd_hash_traverse (&(info->hash->table), rx_table_find, &stuff);
3808
3809   return TRUE;
3810 }
3811
3812 \f
3813 static bfd_boolean
3814 rx_table_map_2 (struct bfd_hash_entry *vent, void *vinfo)
3815 {
3816   RX_Table_Info *info = (RX_Table_Info *)vinfo;
3817   struct bfd_link_hash_entry *ent = (struct bfd_link_hash_entry *)vent;
3818   int idx;
3819   const char *name;
3820   bfd_vma addr;
3821
3822   /* See if the symbol ENT has an address listed in the table, and
3823      isn't a debug/special symbol.  If so, put it in the table.  */
3824
3825   if (ent->type != bfd_link_hash_defined
3826       && ent->type != bfd_link_hash_defweak)
3827     return TRUE;
3828
3829   name = ent->root.string;
3830
3831   if (name[0] == '$' || name[0] == '.' || name[0] < ' ')
3832     return TRUE;
3833
3834   addr = (ent->u.def.value
3835           + ent->u.def.section->output_section->vma
3836           + ent->u.def.section->output_offset);
3837
3838   for (idx = 0; idx < info->table_size; idx ++)
3839     if (addr == info->table_handlers[idx])
3840       info->table_entries[idx] = ent;
3841
3842   if (addr == info->table_default_handler)
3843     info->table_default_entry = ent;
3844
3845   return TRUE;
3846 }
3847
3848 static bfd_boolean
3849 rx_table_map (struct bfd_hash_entry *vent, void *vinfo)
3850 {
3851   RX_Table_Info *info = (RX_Table_Info *)vinfo;
3852   struct bfd_link_hash_entry *ent = (struct bfd_link_hash_entry *)vent;
3853   const char *name; /* of the symbol we've found */
3854   int idx;
3855   const char *tname; /* name of the table */
3856   bfd_vma start_addr, end_addr;
3857   char *buf;
3858   struct bfd_link_hash_entry * h;
3859   int need_elipses;
3860
3861   /* We're looking for globally defined symbols of the form
3862      $tablestart$<NAME>.  */
3863   if (ent->type != bfd_link_hash_defined
3864       && ent->type != bfd_link_hash_defweak)
3865     return TRUE;
3866
3867   name = ent->root.string;
3868
3869   if (strncmp (name, "$tablestart$", 12))
3870     return TRUE;
3871
3872   tname = name + 12;
3873   start_addr = (ent->u.def.value
3874                 + ent->u.def.section->output_section->vma
3875                 + ent->u.def.section->output_offset);
3876
3877   buf = (char *) malloc (12 + 10 + strlen (tname));
3878
3879   sprintf (buf, "$tableend$%s", tname);
3880   end_addr = get_symbol_value_maybe (buf, info->info);
3881
3882   sprintf (buf, "$tableentry$default$%s", tname);
3883   h = bfd_link_hash_lookup (info->info->hash, buf, FALSE, FALSE, TRUE);
3884   if (h)
3885     {
3886       info->table_default_handler = (h->u.def.value
3887                                      + h->u.def.section->output_section->vma
3888                                      + h->u.def.section->output_offset);
3889     }
3890   else
3891     /* Zero is a valid handler address!  */
3892     info->table_default_handler = (bfd_vma) (-1);
3893   info->table_default_entry = NULL;
3894
3895   info->table_start = start_addr;
3896   info->table_size = (int) (end_addr - start_addr) / 4;
3897   info->table_handlers = (bfd_vma *) malloc (info->table_size * sizeof (bfd_vma));
3898   info->table_entries = (struct bfd_link_hash_entry **) malloc (info->table_size * sizeof (struct bfd_link_hash_entry));
3899
3900   for (idx = 0; idx < (int) (end_addr - start_addr) / 4; idx ++)
3901     {
3902       sprintf (buf, "$tableentry$%d$%s", idx, tname);
3903       h = bfd_link_hash_lookup (info->info->hash, buf, FALSE, FALSE, TRUE);
3904       if (h && (h->type == bfd_link_hash_defined
3905                 || h->type == bfd_link_hash_defweak))
3906         {
3907           info->table_handlers[idx] = (h->u.def.value
3908                                        + h->u.def.section->output_section->vma
3909                                        + h->u.def.section->output_offset);
3910         }
3911       else
3912         info->table_handlers[idx] = info->table_default_handler;
3913       info->table_entries[idx] = NULL;
3914     }
3915
3916   free (buf);
3917
3918   bfd_hash_traverse (&(info->info->hash->table), rx_table_map_2, info);
3919
3920   fprintf (info->mapfile, "\nRX Vector Table: %s has %d entries at 0x%08" BFD_VMA_FMT "x\n\n",
3921            tname, info->table_size, start_addr);
3922
3923   if (info->table_default_entry)
3924     fprintf (info->mapfile, "  default handler is: %s at 0x%08" BFD_VMA_FMT "x\n",
3925              info->table_default_entry->root.string,
3926              info->table_default_handler);
3927   else if (info->table_default_handler != (bfd_vma)(-1))
3928     fprintf (info->mapfile, "  default handler is at 0x%08" BFD_VMA_FMT "x\n",
3929              info->table_default_handler);
3930   else
3931     fprintf (info->mapfile, "  no default handler\n");
3932
3933   need_elipses = 1;
3934   for (idx = 0; idx < info->table_size; idx ++)
3935     {
3936       if (info->table_handlers[idx] == info->table_default_handler)
3937         {
3938           if (need_elipses)
3939             fprintf (info->mapfile, "  . . .\n");
3940           need_elipses = 0;
3941           continue;
3942         }
3943       need_elipses = 1;
3944
3945       fprintf (info->mapfile, "  0x%08" BFD_VMA_FMT "x [%3d] ", start_addr + 4 * idx, idx);
3946
3947       if (info->table_handlers[idx] == (bfd_vma) (-1))
3948         fprintf (info->mapfile, "(no handler found)\n");
3949
3950       else if (info->table_handlers[idx] == info->table_default_handler)
3951         {
3952           if (info->table_default_entry)
3953             fprintf (info->mapfile, "(default)\n");
3954           else
3955             fprintf (info->mapfile, "(default)\n");
3956         }
3957
3958       else if (info->table_entries[idx])
3959         {
3960           fprintf (info->mapfile, "0x%08" BFD_VMA_FMT "x %s\n", info->table_handlers[idx], info->table_entries[idx]->root.string);
3961         }
3962
3963       else
3964         {
3965           fprintf (info->mapfile, "0x%08" BFD_VMA_FMT "x ???\n", info->table_handlers[idx]);
3966         }
3967     }
3968   if (need_elipses)
3969     fprintf (info->mapfile, "  . . .\n");
3970
3971   return TRUE;
3972 }
3973
3974 void
3975 rx_additional_link_map_text (bfd *obfd, struct bfd_link_info *info, FILE *mapfile)
3976 {
3977   /* We scan the symbol table looking for $tableentry$'s, and for
3978      each, try to deduce which handlers go with which entries.  */
3979
3980   RX_Table_Info stuff;
3981
3982   stuff.abfd = obfd;
3983   stuff.info = info;
3984   stuff.mapfile = mapfile;
3985   bfd_hash_traverse (&(info->hash->table), rx_table_map, &stuff);
3986 }
3987
3988 \f
3989 #define ELF_ARCH                bfd_arch_rx
3990 #define ELF_MACHINE_CODE        EM_RX
3991 #define ELF_MAXPAGESIZE         0x1000
3992
3993 #define TARGET_BIG_SYM          rx_elf32_be_vec
3994 #define TARGET_BIG_NAME         "elf32-rx-be"
3995
3996 #define TARGET_LITTLE_SYM       rx_elf32_le_vec
3997 #define TARGET_LITTLE_NAME      "elf32-rx-le"
3998
3999 #define elf_info_to_howto_rel                   NULL
4000 #define elf_info_to_howto                       rx_info_to_howto_rela
4001 #define elf_backend_object_p                    rx_elf_object_p
4002 #define elf_backend_relocate_section            rx_elf_relocate_section
4003 #define elf_symbol_leading_char                 ('_')
4004 #define elf_backend_can_gc_sections             1
4005 #define elf_backend_modify_program_headers      elf32_rx_modify_program_headers
4006
4007 #define bfd_elf32_bfd_reloc_type_lookup         rx_reloc_type_lookup
4008 #define bfd_elf32_bfd_reloc_name_lookup         rx_reloc_name_lookup
4009 #define bfd_elf32_bfd_set_private_flags         rx_elf_set_private_flags
4010 #define bfd_elf32_bfd_merge_private_bfd_data    rx_elf_merge_private_bfd_data
4011 #define bfd_elf32_bfd_print_private_bfd_data    rx_elf_print_private_bfd_data
4012 #define bfd_elf32_get_section_contents          rx_get_section_contents
4013 #define bfd_elf32_set_section_contents          rx_set_section_contents
4014 #define bfd_elf32_bfd_final_link                rx_final_link
4015 #define bfd_elf32_bfd_relax_section             elf32_rx_relax_section_wrapper
4016 #define elf_backend_special_sections            elf32_rx_special_sections
4017 #define elf_backend_check_directives            rx_check_directives
4018
4019 #include "elf32-target.h"
4020
4021 /* We define a second big-endian target that doesn't have the custom
4022    section get/set hooks, for times when we want to preserve the
4023    pre-swapped .text sections (like objcopy).  */
4024
4025 #undef  TARGET_BIG_SYM
4026 #define TARGET_BIG_SYM          rx_elf32_be_ns_vec
4027 #undef  TARGET_BIG_NAME
4028 #define TARGET_BIG_NAME         "elf32-rx-be-ns"
4029 #undef  TARGET_LITTLE_SYM
4030
4031 #undef bfd_elf32_get_section_contents
4032 #undef bfd_elf32_set_section_contents
4033
4034 #undef  elf32_bed
4035 #define elf32_bed                               elf32_rx_be_ns_bed
4036
4037 #include "elf32-target.h"