bfd/elf32-rx.c

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