bfd/elf32-rx.c

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