bfd/elf32-rx.c

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