bfd/elf32-rx.c

   1 /* Renesas RX specific support for 32-bit ELF.
   2    Copyright (C) 2008-2016 Free Software Foundation, Inc.
   3
   4    This file is part of BFD, the Binary File Descriptor library.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  19
  20 #include "sysdep.h"
  21 #include "bfd.h"
  22 #include "bfd_stdint.h"
  23 #include "libbfd.h"
  24 #include "elf-bfd.h"
  25 #include "elf/rx.h"
  26 #include "libiberty.h"
  27 #include "elf32-rx.h"
  28
  29 #define RX_OPCODE_BIG_ENDIAN 0
  30
  31 /* This is a meta-target that's used only with objcopy, to avoid the
  32    endian-swap we would otherwise get.  We check for this in
  33    rx_elf_object_p().  */
  34 const bfd_target rx_elf32_be_ns_vec;
  35 const bfd_target rx_elf32_be_vec;
  36
  37 #ifdef DEBUG
  38 char * rx_get_reloc (long);
  39 void rx_dump_symtab (bfd *, void *, void *);
  40 #endif
  41
  42 #define RXREL(n,sz,bit,shift,complain,pcrel)                                 \
  43   HOWTO (R_RX_##n, shift, sz, bit, pcrel, 0, complain_overflow_ ## complain, \
  44          bfd_elf_generic_reloc, "R_RX_" #n, FALSE, 0, ~0, FALSE)
  45
  46 /* Note that the relocations around 0x7f are internal to this file;
  47    feel free to move them as needed to avoid conflicts with published
  48    relocation numbers.  */
  49
  50 static reloc_howto_type rx_elf_howto_table [] =
  51 {
  52   RXREL (NONE,         3,  0, 0, dont,     FALSE),
  53   RXREL (DIR32,        2, 32, 0, signed,   FALSE),
  54   RXREL (DIR24S,       2, 24, 0, signed,   FALSE),
  55   RXREL (DIR16,        1, 16, 0, dont,     FALSE),
  56   RXREL (DIR16U,       1, 16, 0, unsigned, FALSE),
  57   RXREL (DIR16S,       1, 16, 0, signed,   FALSE),
  58   RXREL (DIR8,         0,  8, 0, dont,     FALSE),
  59   RXREL (DIR8U,        0,  8, 0, unsigned, FALSE),
  60   RXREL (DIR8S,        0,  8, 0, signed,   FALSE),
  61   RXREL (DIR24S_PCREL, 2, 24, 0, signed,   TRUE),
  62   RXREL (DIR16S_PCREL, 1, 16, 0, signed,   TRUE),
  63   RXREL (DIR8S_PCREL,  0,  8, 0, signed,   TRUE),
  64   RXREL (DIR16UL,      1, 16, 2, unsigned, FALSE),
  65   RXREL (DIR16UW,      1, 16, 1, unsigned, FALSE),
  66   RXREL (DIR8UL,       0,  8, 2, unsigned, FALSE),
  67   RXREL (DIR8UW,       0,  8, 1, unsigned, FALSE),
  68   RXREL (DIR32_REV,    1, 16, 0, dont,     FALSE),
  69   RXREL (DIR16_REV,    1, 16, 0, dont,     FALSE),
  70   RXREL (DIR3U_PCREL,  0,  3, 0, dont,     TRUE),
  71
  72   EMPTY_HOWTO (0x13),
  73   EMPTY_HOWTO (0x14),
  74   EMPTY_HOWTO (0x15),
  75   EMPTY_HOWTO (0x16),
  76   EMPTY_HOWTO (0x17),
  77   EMPTY_HOWTO (0x18),
  78   EMPTY_HOWTO (0x19),
  79   EMPTY_HOWTO (0x1a),
  80   EMPTY_HOWTO (0x1b),
  81   EMPTY_HOWTO (0x1c),
  82   EMPTY_HOWTO (0x1d),
  83   EMPTY_HOWTO (0x1e),
  84   EMPTY_HOWTO (0x1f),
  85
  86   RXREL (RH_3_PCREL, 0,  3, 0, signed,   TRUE),
  87   RXREL (RH_16_OP,   1, 16, 0, signed,   FALSE),
  88   RXREL (RH_24_OP,   2, 24, 0, signed,   FALSE),
  89   RXREL (RH_32_OP,   2, 32, 0, signed,   FALSE),
  90   RXREL (RH_24_UNS,  2, 24, 0, unsigned, FALSE),
  91   RXREL (RH_8_NEG,   0,  8, 0, signed,   FALSE),
  92   RXREL (RH_16_NEG,  1, 16, 0, signed,   FALSE),
  93   RXREL (RH_24_NEG,  2, 24, 0, signed,   FALSE),
  94   RXREL (RH_32_NEG,  2, 32, 0, signed,   FALSE),
  95   RXREL (RH_DIFF,    2, 32, 0, signed,   FALSE),
  96   RXREL (RH_GPRELB,  1, 16, 0, unsigned, FALSE),
  97   RXREL (RH_GPRELW,  1, 16, 0, unsigned, FALSE),
  98   RXREL (RH_GPRELL,  1, 16, 0, unsigned, FALSE),
  99   RXREL (RH_RELAX,   0,  0, 0, dont,     FALSE),
 100
 101   EMPTY_HOWTO (0x2e),
 102   EMPTY_HOWTO (0x2f),
 103   EMPTY_HOWTO (0x30),
 104   EMPTY_HOWTO (0x31),
 105   EMPTY_HOWTO (0x32),
 106   EMPTY_HOWTO (0x33),
 107   EMPTY_HOWTO (0x34),
 108   EMPTY_HOWTO (0x35),
 109   EMPTY_HOWTO (0x36),
 110   EMPTY_HOWTO (0x37),
 111   EMPTY_HOWTO (0x38),
 112   EMPTY_HOWTO (0x39),
 113   EMPTY_HOWTO (0x3a),
 114   EMPTY_HOWTO (0x3b),
 115   EMPTY_HOWTO (0x3c),
 116   EMPTY_HOWTO (0x3d),
 117   EMPTY_HOWTO (0x3e),
 118   EMPTY_HOWTO (0x3f),
 119   EMPTY_HOWTO (0x40),
 120
 121   RXREL (ABS32,        2, 32, 0, dont,     FALSE),
 122   RXREL (ABS24S,       2, 24, 0, signed,   FALSE),
 123   RXREL (ABS16,        1, 16, 0, dont,     FALSE),
 124   RXREL (ABS16U,       1, 16, 0, unsigned, FALSE),
 125   RXREL (ABS16S,       1, 16, 0, signed,   FALSE),
 126   RXREL (ABS8,         0,  8, 0, dont,     FALSE),
 127   RXREL (ABS8U,        0,  8, 0, unsigned, FALSE),
 128   RXREL (ABS8S,        0,  8, 0, signed,   FALSE),
 129   RXREL (ABS24S_PCREL, 2, 24, 0, signed,   TRUE),
 130   RXREL (ABS16S_PCREL, 1, 16, 0, signed,   TRUE),
 131   RXREL (ABS8S_PCREL,  0,  8, 0, signed,   TRUE),
 132   RXREL (ABS16UL,      1, 16, 0, unsigned, FALSE),
 133   RXREL (ABS16UW,      1, 16, 0, unsigned, FALSE),
 134   RXREL (ABS8UL,       0,  8, 0, unsigned, FALSE),
 135   RXREL (ABS8UW,       0,  8, 0, unsigned, FALSE),
 136   RXREL (ABS32_REV,    2, 32, 0, dont,     FALSE),
 137   RXREL (ABS16_REV,    1, 16, 0, dont,     FALSE),
 138
 139 #define STACK_REL_P(x) ((x) <= R_RX_ABS16_REV && (x) >= R_RX_ABS32)
 140
 141   EMPTY_HOWTO (0x52),
 142   EMPTY_HOWTO (0x53),
 143   EMPTY_HOWTO (0x54),
 144   EMPTY_HOWTO (0x55),
 145   EMPTY_HOWTO (0x56),
 146   EMPTY_HOWTO (0x57),
 147   EMPTY_HOWTO (0x58),
 148   EMPTY_HOWTO (0x59),
 149   EMPTY_HOWTO (0x5a),
 150   EMPTY_HOWTO (0x5b),
 151   EMPTY_HOWTO (0x5c),
 152   EMPTY_HOWTO (0x5d),
 153   EMPTY_HOWTO (0x5e),
 154   EMPTY_HOWTO (0x5f),
 155   EMPTY_HOWTO (0x60),
 156   EMPTY_HOWTO (0x61),
 157   EMPTY_HOWTO (0x62),
 158   EMPTY_HOWTO (0x63),
 159   EMPTY_HOWTO (0x64),
 160   EMPTY_HOWTO (0x65),
 161   EMPTY_HOWTO (0x66),
 162   EMPTY_HOWTO (0x67),
 163   EMPTY_HOWTO (0x68),
 164   EMPTY_HOWTO (0x69),
 165   EMPTY_HOWTO (0x6a),
 166   EMPTY_HOWTO (0x6b),
 167   EMPTY_HOWTO (0x6c),
 168   EMPTY_HOWTO (0x6d),
 169   EMPTY_HOWTO (0x6e),
 170   EMPTY_HOWTO (0x6f),
 171   EMPTY_HOWTO (0x70),
 172   EMPTY_HOWTO (0x71),
 173   EMPTY_HOWTO (0x72),
 174   EMPTY_HOWTO (0x73),
 175   EMPTY_HOWTO (0x74),
 176   EMPTY_HOWTO (0x75),
 177   EMPTY_HOWTO (0x76),
 178   EMPTY_HOWTO (0x77),
 179
 180   /* These are internal.  */
 181   /* A 5-bit unsigned displacement to a B/W/L address, at bit position 8/12.  */
 182   /* ---- ----   4--- 3210.  */
 183 #define R_RX_RH_ABS5p8B 0x78
 184   RXREL (RH_ABS5p8B,   0,  0, 0, dont,     FALSE),
 185 #define R_RX_RH_ABS5p8W 0x79
 186   RXREL (RH_ABS5p8W,   0,  0, 0, dont,     FALSE),
 187 #define R_RX_RH_ABS5p8L 0x7a
 188   RXREL (RH_ABS5p8L,   0,  0, 0, dont,     FALSE),
 189   /* A 5-bit unsigned displacement to a B/W/L address, at bit position 5/12.  */
 190   /* ---- -432   1--- 0---.  */
 191 #define R_RX_RH_ABS5p5B 0x7b
 192   RXREL (RH_ABS5p5B,   0,  0, 0, dont,     FALSE),
 193 #define R_RX_RH_ABS5p5W 0x7c
 194   RXREL (RH_ABS5p5W,   0,  0, 0, dont,     FALSE),
 195 #define R_RX_RH_ABS5p5L 0x7d
 196   RXREL (RH_ABS5p5L,   0,  0, 0, dont,     FALSE),
 197   /* A 4-bit unsigned immediate at bit position 8.  */
 198 #define R_RX_RH_UIMM4p8 0x7e
 199   RXREL (RH_UIMM4p8,   0,  0, 0, dont,     FALSE),
 200   /* A 4-bit negative unsigned immediate at bit position 8.  */
 201 #define R_RX_RH_UNEG4p8 0x7f
 202   RXREL (RH_UNEG4p8,   0,  0, 0, dont,     FALSE),
 203   /* End of internal relocs.  */
 204
 205   RXREL (SYM,       2, 32, 0, dont, FALSE),
 206   RXREL (OPneg,     2, 32, 0, dont, FALSE),
 207   RXREL (OPadd,     2, 32, 0, dont, FALSE),
 208   RXREL (OPsub,     2, 32, 0, dont, FALSE),
 209   RXREL (OPmul,     2, 32, 0, dont, FALSE),
 210   RXREL (OPdiv,     2, 32, 0, dont, FALSE),
 211   RXREL (OPshla,    2, 32, 0, dont, FALSE),
 212   RXREL (OPshra,    2, 32, 0, dont, FALSE),
 213   RXREL (OPsctsize, 2, 32, 0, dont, FALSE),
 214   RXREL (OPscttop,  2, 32, 0, dont, FALSE),
 215   RXREL (OPand,     2, 32, 0, dont, FALSE),
 216   RXREL (OPor,      2, 32, 0, dont, FALSE),
 217   RXREL (OPxor,     2, 32, 0, dont, FALSE),
 218   RXREL (OPnot,     2, 32, 0, dont, FALSE),
 219   RXREL (OPmod,     2, 32, 0, dont, FALSE),
 220   RXREL (OPromtop,  2, 32, 0, dont, FALSE),
 221   RXREL (OPramtop,  2, 32, 0, dont, FALSE)
 222 };
 223 \f
 224 /* Map BFD reloc types to RX ELF reloc types.  */
 225
 226 struct rx_reloc_map
 227 {
 228   bfd_reloc_code_real_type  bfd_reloc_val;
 229   unsigned int              rx_reloc_val;
 230 };
 231
 232 static const struct rx_reloc_map rx_reloc_map [] =
 233 {
 234   { BFD_RELOC_NONE,             R_RX_NONE },
 235   { BFD_RELOC_8,                R_RX_DIR8S },
 236   { BFD_RELOC_16,               R_RX_DIR16S },
 237   { BFD_RELOC_24,               R_RX_DIR24S },
 238   { BFD_RELOC_32,               R_RX_DIR32 },
 239   { BFD_RELOC_RX_16_OP,         R_RX_DIR16 },
 240   { BFD_RELOC_RX_DIR3U_PCREL,   R_RX_DIR3U_PCREL },
 241   { BFD_RELOC_8_PCREL,          R_RX_DIR8S_PCREL },
 242   { BFD_RELOC_16_PCREL,         R_RX_DIR16S_PCREL },
 243   { BFD_RELOC_24_PCREL,         R_RX_DIR24S_PCREL },
 244   { BFD_RELOC_RX_8U,            R_RX_DIR8U },
 245   { BFD_RELOC_RX_16U,           R_RX_DIR16U },
 246   { BFD_RELOC_RX_24U,           R_RX_RH_24_UNS },
 247   { BFD_RELOC_RX_NEG8,          R_RX_RH_8_NEG },
 248   { BFD_RELOC_RX_NEG16,         R_RX_RH_16_NEG },
 249   { BFD_RELOC_RX_NEG24,         R_RX_RH_24_NEG },
 250   { BFD_RELOC_RX_NEG32,         R_RX_RH_32_NEG },
 251   { BFD_RELOC_RX_DIFF,          R_RX_RH_DIFF },
 252   { BFD_RELOC_RX_GPRELB,        R_RX_RH_GPRELB },
 253   { BFD_RELOC_RX_GPRELW,        R_RX_RH_GPRELW },
 254   { BFD_RELOC_RX_GPRELL,        R_RX_RH_GPRELL },
 255   { BFD_RELOC_RX_RELAX,         R_RX_RH_RELAX },
 256   { BFD_RELOC_RX_SYM,           R_RX_SYM },
 257   { BFD_RELOC_RX_OP_SUBTRACT,   R_RX_OPsub },
 258   { BFD_RELOC_RX_OP_NEG,        R_RX_OPneg },
 259   { BFD_RELOC_RX_ABS8,          R_RX_ABS8 },
 260   { BFD_RELOC_RX_ABS16,         R_RX_ABS16 },
 261   { BFD_RELOC_RX_ABS16_REV,     R_RX_ABS16_REV },
 262   { BFD_RELOC_RX_ABS32,         R_RX_ABS32 },
 263   { BFD_RELOC_RX_ABS32_REV,     R_RX_ABS32_REV },
 264   { BFD_RELOC_RX_ABS16UL,       R_RX_ABS16UL },
 265   { BFD_RELOC_RX_ABS16UW,       R_RX_ABS16UW },
 266   { BFD_RELOC_RX_ABS16U,        R_RX_ABS16U }
 267 };
 268
 269 #define BIGE(abfd)       ((abfd)->xvec->byteorder == BFD_ENDIAN_BIG)
 270
 271 static reloc_howto_type *
 272 rx_reloc_type_lookup (bfd *                    abfd ATTRIBUTE_UNUSED,
 273                       bfd_reloc_code_real_type code)
 274 {
 275   unsigned int i;
 276
 277   if (code == BFD_RELOC_RX_32_OP)
 278     return rx_elf_howto_table + R_RX_DIR32;
 279
 280   for (i = ARRAY_SIZE (rx_reloc_map); i--;)
 281     if (rx_reloc_map [i].bfd_reloc_val == code)
 282       return rx_elf_howto_table + rx_reloc_map[i].rx_reloc_val;
 283
 284   return NULL;
 285 }
 286
 287 static reloc_howto_type *
 288 rx_reloc_name_lookup (bfd * abfd ATTRIBUTE_UNUSED, const char * r_name)
 289 {
 290   unsigned int i;
 291
 292   for (i = 0; i < ARRAY_SIZE (rx_elf_howto_table); i++)
 293     if (rx_elf_howto_table[i].name != NULL
 294         && strcasecmp (rx_elf_howto_table[i].name, r_name) == 0)
 295       return rx_elf_howto_table + i;
 296
 297   return NULL;
 298 }
 299
 300 /* Set the howto pointer for an RX ELF reloc.  */
 301
 302 static void
 303 rx_info_to_howto_rela (bfd *               abfd ATTRIBUTE_UNUSED,
 304                        arelent *           cache_ptr,
 305                        Elf_Internal_Rela * dst)
 306 {
 307   unsigned int r_type;
 308
 309   r_type = ELF32_R_TYPE (dst->r_info);
 310   if (r_type >= (unsigned int) R_RX_max)
 311     {
 312       _bfd_error_handler (_("%B: invalid RX reloc number: %d"), abfd, r_type);
 313       r_type = 0;
 314     }
 315   cache_ptr->howto = rx_elf_howto_table + r_type;
 316 }
 317 \f
 318 static bfd_vma
 319 get_symbol_value (const char *            name,
 320                   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                              Elf_Internal_Rela *irelstart)
1536 {
1537   Elf_Internal_Shdr * symtab_hdr;
1538   unsigned int        sec_shndx;
1539   bfd_byte *          contents;
1540   Elf_Internal_Rela * irel;
1541   Elf_Internal_Rela * irelend;
1542   Elf_Internal_Sym *  isym;
1543   Elf_Internal_Sym *  isymend;
1544   bfd_vma             toaddr;
1545   unsigned int        symcount;
1546   struct elf_link_hash_entry ** sym_hashes;
1547   struct elf_link_hash_entry ** end_hashes;
1548
1549   if (!alignment_rel)
1550     force_snip = 1;
1551
1552   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1553
1554   contents = elf_section_data (sec)->this_hdr.contents;
1555
1556   /* The deletion must stop at the next alignment boundary, if
1557      ALIGNMENT_REL is non-NULL.  */
1558   toaddr = sec->size;
1559   if (alignment_rel)
1560     toaddr = alignment_rel->r_offset;
1561
1562   BFD_ASSERT (toaddr > addr);
1563
1564   /* Actually delete the bytes.  */
1565   memmove (contents + addr, contents + addr + count,
1566            (size_t) (toaddr - addr - count));
1567
1568   /* If we don't have an alignment marker to worry about, we can just
1569      shrink the section.  Otherwise, we have to fill in the newly
1570      created gap with NOP insns (0x03).  */
1571   if (force_snip)
1572     sec->size -= count;
1573   else
1574     memset (contents + toaddr - count, 0x03, count);
1575
1576   irel = irelstart;
1577   BFD_ASSERT (irel != NULL || sec->reloc_count == 0);
1578   irelend = irel + sec->reloc_count;
1579
1580   /* Adjust all the relocs.  */
1581   for (; irel < irelend; irel++)
1582     {
1583       /* Get the new reloc address.  */
1584       if (irel->r_offset > addr
1585           && (irel->r_offset < toaddr
1586               || (force_snip && irel->r_offset == toaddr)))
1587         irel->r_offset -= count;
1588
1589       /* If we see an ALIGN marker at the end of the gap, we move it
1590          to the beginning of the gap, since marking these gaps is what
1591          they're for.  */
1592       if (irel->r_offset == toaddr
1593           && ELF32_R_TYPE (irel->r_info) == R_RX_RH_RELAX
1594           && irel->r_addend & RX_RELAXA_ALIGN)
1595         irel->r_offset -= count;
1596     }
1597
1598   /* Adjust the local symbols defined in this section.  */
1599   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1600   isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1601   isymend = isym + symtab_hdr->sh_info;
1602
1603   for (; isym < isymend; isym++)
1604     {
1605       /* If the symbol is in the range of memory we just moved, we
1606          have to adjust its value.  */
1607       if (isym->st_shndx == sec_shndx
1608           && isym->st_value > addr
1609           && isym->st_value < toaddr)
1610         isym->st_value -= count;
1611
1612       /* If the symbol *spans* the bytes we just deleted (i.e. it's
1613          *end* is in the moved bytes but it's *start* isn't), then we
1614          must adjust its size.  */
1615       if (isym->st_shndx == sec_shndx
1616           && isym->st_value < addr
1617           && isym->st_value + isym->st_size > addr
1618           && isym->st_value + isym->st_size < toaddr)
1619         isym->st_size -= count;
1620     }
1621
1622   /* Now adjust the global symbols defined in this section.  */
1623   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1624               - symtab_hdr->sh_info);
1625   sym_hashes = elf_sym_hashes (abfd);
1626   end_hashes = sym_hashes + symcount;
1627
1628   for (; sym_hashes < end_hashes; sym_hashes++)
1629     {
1630       struct elf_link_hash_entry *sym_hash = *sym_hashes;
1631
1632       if ((sym_hash->root.type == bfd_link_hash_defined
1633            || sym_hash->root.type == bfd_link_hash_defweak)
1634           && sym_hash->root.u.def.section == sec)
1635         {
1636           /* As above, adjust the value if needed.  */
1637           if (sym_hash->root.u.def.value > addr
1638               && sym_hash->root.u.def.value < toaddr)
1639             sym_hash->root.u.def.value -= count;
1640
1641           /* As above, adjust the size if needed.  */
1642           if (sym_hash->root.u.def.value < addr
1643               && sym_hash->root.u.def.value + sym_hash->size > addr
1644               && sym_hash->root.u.def.value + sym_hash->size < toaddr)
1645             sym_hash->size -= count;
1646         }
1647     }
1648
1649   return TRUE;
1650 }
1651
1652 /* Used to sort relocs by address.  If relocs have the same address,
1653    we maintain their relative order, except that R_RX_RH_RELAX
1654    alignment relocs must be the first reloc for any given address.  */
1655
1656 static void
1657 reloc_bubblesort (Elf_Internal_Rela * r, int count)
1658 {
1659   int i;
1660   bfd_boolean again;
1661   bfd_boolean swappit;
1662
1663   /* This is almost a classic bubblesort.  It's the slowest sort, but
1664      we're taking advantage of the fact that the relocations are
1665      mostly in order already (the assembler emits them that way) and
1666      we need relocs with the same address to remain in the same
1667      relative order.  */
1668   again = TRUE;
1669   while (again)
1670     {
1671       again = FALSE;
1672       for (i = 0; i < count - 1; i ++)
1673         {
1674           if (r[i].r_offset > r[i + 1].r_offset)
1675             swappit = TRUE;
1676           else if (r[i].r_offset < r[i + 1].r_offset)
1677             swappit = FALSE;
1678           else if (ELF32_R_TYPE (r[i + 1].r_info) == R_RX_RH_RELAX
1679                    && (r[i + 1].r_addend & RX_RELAXA_ALIGN))
1680             swappit = TRUE;
1681           else if (ELF32_R_TYPE (r[i + 1].r_info) == R_RX_RH_RELAX
1682                    && (r[i + 1].r_addend & RX_RELAXA_ELIGN)
1683                    && !(ELF32_R_TYPE (r[i].r_info) == R_RX_RH_RELAX
1684                         && (r[i].r_addend & RX_RELAXA_ALIGN)))
1685             swappit = TRUE;
1686           else
1687             swappit = FALSE;
1688
1689           if (swappit)
1690             {
1691               Elf_Internal_Rela tmp;
1692
1693               tmp = r[i];
1694               r[i] = r[i + 1];
1695               r[i + 1] = tmp;
1696               /* If we do move a reloc back, re-scan to see if it
1697                  needs to be moved even further back.  This avoids
1698                  most of the O(n^2) behavior for our cases.  */
1699               if (i > 0)
1700                 i -= 2;
1701               again = TRUE;
1702             }
1703         }
1704     }
1705 }
1706
1707
1708 #define OFFSET_FOR_RELOC(rel, lrel, scale) \
1709   rx_offset_for_reloc (abfd, rel + 1, symtab_hdr, shndx_buf, intsyms, \
1710                        lrel, abfd, sec, link_info, scale)
1711
1712 static bfd_vma
1713 rx_offset_for_reloc (bfd *                    abfd,
1714                      Elf_Internal_Rela *      rel,
1715                      Elf_Internal_Shdr *      symtab_hdr,
1716                      Elf_External_Sym_Shndx * shndx_buf ATTRIBUTE_UNUSED,
1717                      Elf_Internal_Sym *       intsyms,
1718                      Elf_Internal_Rela **     lrel,
1719                      bfd *                    input_bfd,
1720                      asection *               input_section,
1721                      struct bfd_link_info *   info,
1722                      int *                    scale)
1723 {
1724   bfd_vma symval;
1725   bfd_reloc_status_type r;
1726
1727   *scale = 1;
1728
1729   /* REL is the first of 1..N relocations.  We compute the symbol
1730      value for each relocation, then combine them if needed.  LREL
1731      gets a pointer to the last relocation used.  */
1732   while (1)
1733     {
1734       int32_t tmp1, tmp2;
1735
1736       /* Get the value of the symbol referred to by the reloc.  */
1737       if (ELF32_R_SYM (rel->r_info) < symtab_hdr->sh_info)
1738         {
1739           /* A local symbol.  */
1740           Elf_Internal_Sym *isym;
1741           asection *ssec;
1742
1743           isym = intsyms + ELF32_R_SYM (rel->r_info);
1744
1745           if (isym->st_shndx == SHN_UNDEF)
1746             ssec = bfd_und_section_ptr;
1747           else if (isym->st_shndx == SHN_ABS)
1748             ssec = bfd_abs_section_ptr;
1749           else if (isym->st_shndx == SHN_COMMON)
1750             ssec = bfd_com_section_ptr;
1751           else
1752             ssec = bfd_section_from_elf_index (abfd,
1753                                                isym->st_shndx);
1754
1755           /* Initial symbol value.  */
1756           symval = isym->st_value;
1757
1758           /* GAS may have made this symbol relative to a section, in
1759              which case, we have to add the addend to find the
1760              symbol.  */
1761           if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
1762             symval += rel->r_addend;
1763
1764           if (ssec)
1765             {
1766               if ((ssec->flags & SEC_MERGE)
1767                   && ssec->sec_info_type == SEC_INFO_TYPE_MERGE)
1768                 symval = _bfd_merged_section_offset (abfd, & ssec,
1769                                                      elf_section_data (ssec)->sec_info,
1770                                                      symval);
1771             }
1772
1773           /* Now make the offset relative to where the linker is putting it.  */
1774           if (ssec)
1775             symval +=
1776               ssec->output_section->vma + ssec->output_offset;
1777
1778           symval += rel->r_addend;
1779         }
1780       else
1781         {
1782           unsigned long indx;
1783           struct elf_link_hash_entry * h;
1784
1785           /* An external symbol.  */
1786           indx = ELF32_R_SYM (rel->r_info) - symtab_hdr->sh_info;
1787           h = elf_sym_hashes (abfd)[indx];
1788           BFD_ASSERT (h != NULL);
1789
1790           if (h->root.type != bfd_link_hash_defined
1791               && h->root.type != bfd_link_hash_defweak)
1792             {
1793               /* This appears to be a reference to an undefined
1794                  symbol.  Just ignore it--it will be caught by the
1795                  regular reloc processing.  */
1796               if (lrel)
1797                 *lrel = rel;
1798               return 0;
1799             }
1800
1801           symval = (h->root.u.def.value
1802                     + h->root.u.def.section->output_section->vma
1803                     + h->root.u.def.section->output_offset);
1804
1805           symval += rel->r_addend;
1806         }
1807
1808       switch (ELF32_R_TYPE (rel->r_info))
1809         {
1810         case R_RX_SYM:
1811           RX_STACK_PUSH (symval);
1812           break;
1813
1814         case R_RX_OPneg:
1815           RX_STACK_POP (tmp1);
1816           tmp1 = - tmp1;
1817           RX_STACK_PUSH (tmp1);
1818           break;
1819
1820         case R_RX_OPadd:
1821           RX_STACK_POP (tmp1);
1822           RX_STACK_POP (tmp2);
1823           tmp1 += tmp2;
1824           RX_STACK_PUSH (tmp1);
1825           break;
1826
1827         case R_RX_OPsub:
1828           RX_STACK_POP (tmp1);
1829           RX_STACK_POP (tmp2);
1830           tmp2 -= tmp1;
1831           RX_STACK_PUSH (tmp2);
1832           break;
1833
1834         case R_RX_OPmul:
1835           RX_STACK_POP (tmp1);
1836           RX_STACK_POP (tmp2);
1837           tmp1 *= tmp2;
1838           RX_STACK_PUSH (tmp1);
1839           break;
1840
1841         case R_RX_OPdiv:
1842           RX_STACK_POP (tmp1);
1843           RX_STACK_POP (tmp2);
1844           tmp1 /= tmp2;
1845           RX_STACK_PUSH (tmp1);
1846           break;
1847
1848         case R_RX_OPshla:
1849           RX_STACK_POP (tmp1);
1850           RX_STACK_POP (tmp2);
1851           tmp1 <<= tmp2;
1852           RX_STACK_PUSH (tmp1);
1853           break;
1854
1855         case R_RX_OPshra:
1856           RX_STACK_POP (tmp1);
1857           RX_STACK_POP (tmp2);
1858           tmp1 >>= tmp2;
1859           RX_STACK_PUSH (tmp1);
1860           break;
1861
1862         case R_RX_OPsctsize:
1863           RX_STACK_PUSH (input_section->size);
1864           break;
1865
1866         case R_RX_OPscttop:
1867           RX_STACK_PUSH (input_section->output_section->vma);
1868           break;
1869
1870         case R_RX_OPand:
1871           RX_STACK_POP (tmp1);
1872           RX_STACK_POP (tmp2);
1873           tmp1 &= tmp2;
1874           RX_STACK_PUSH (tmp1);
1875           break;
1876
1877         case R_RX_OPor:
1878           RX_STACK_POP (tmp1);
1879           RX_STACK_POP (tmp2);
1880           tmp1 |= tmp2;
1881           RX_STACK_PUSH (tmp1);
1882           break;
1883
1884         case R_RX_OPxor:
1885           RX_STACK_POP (tmp1);
1886           RX_STACK_POP (tmp2);
1887           tmp1 ^= tmp2;
1888           RX_STACK_PUSH (tmp1);
1889           break;
1890
1891         case R_RX_OPnot:
1892           RX_STACK_POP (tmp1);
1893           tmp1 = ~ tmp1;
1894           RX_STACK_PUSH (tmp1);
1895           break;
1896
1897         case R_RX_OPmod:
1898           RX_STACK_POP (tmp1);
1899           RX_STACK_POP (tmp2);
1900           tmp1 %= tmp2;
1901           RX_STACK_PUSH (tmp1);
1902           break;
1903
1904         case R_RX_OPromtop:
1905           RX_STACK_PUSH (get_romstart (&r, info, input_bfd, input_section, rel->r_offset));
1906           break;
1907
1908         case R_RX_OPramtop:
1909           RX_STACK_PUSH (get_ramstart (&r, info, input_bfd, input_section, rel->r_offset));
1910           break;
1911
1912         case R_RX_DIR16UL:
1913         case R_RX_DIR8UL:
1914         case R_RX_ABS16UL:
1915         case R_RX_ABS8UL:
1916           if (rx_stack_top)
1917             RX_STACK_POP (symval);
1918           if (lrel)
1919             *lrel = rel;
1920           *scale = 4;
1921           return symval;
1922
1923         case R_RX_DIR16UW:
1924         case R_RX_DIR8UW:
1925         case R_RX_ABS16UW:
1926         case R_RX_ABS8UW:
1927           if (rx_stack_top)
1928             RX_STACK_POP (symval);
1929           if (lrel)
1930             *lrel = rel;
1931           *scale = 2;
1932           return symval;
1933
1934         default:
1935           if (rx_stack_top)
1936             RX_STACK_POP (symval);
1937           if (lrel)
1938             *lrel = rel;
1939           return symval;
1940         }
1941
1942       rel ++;
1943     }
1944 }
1945
1946 static void
1947 move_reloc (Elf_Internal_Rela * irel, Elf_Internal_Rela * srel, int delta)
1948 {
1949   bfd_vma old_offset = srel->r_offset;
1950
1951   irel ++;
1952   while (irel <= srel)
1953     {
1954       if (irel->r_offset == old_offset)
1955         irel->r_offset += delta;
1956       irel ++;
1957     }
1958 }
1959
1960 /* Relax one section.  */
1961
1962 static bfd_boolean
1963 elf32_rx_relax_section (bfd *                  abfd,
1964                         asection *             sec,
1965                         struct bfd_link_info * link_info,
1966                         bfd_boolean *          again,
1967                         bfd_boolean            allow_pcrel3)
1968 {
1969   Elf_Internal_Shdr * symtab_hdr;
1970   Elf_Internal_Shdr * shndx_hdr;
1971   Elf_Internal_Rela * internal_relocs;
1972   Elf_Internal_Rela * irel;
1973   Elf_Internal_Rela * srel;
1974   Elf_Internal_Rela * irelend;
1975   Elf_Internal_Rela * next_alignment;
1976   Elf_Internal_Rela * prev_alignment;
1977   bfd_byte *          contents = NULL;
1978   bfd_byte *          free_contents = NULL;
1979   Elf_Internal_Sym *  intsyms = NULL;
1980   Elf_Internal_Sym *  free_intsyms = NULL;
1981   Elf_External_Sym_Shndx * shndx_buf = NULL;
1982   bfd_vma pc;
1983   bfd_vma sec_start;
1984   bfd_vma symval = 0;
1985   int pcrel = 0;
1986   int code = 0;
1987   int section_alignment_glue;
1988   /* how much to scale the relocation by - 1, 2, or 4.  */
1989   int scale;
1990
1991   /* Assume nothing changes.  */
1992   *again = FALSE;
1993
1994   /* We don't have to do anything for a relocatable link, if
1995      this section does not have relocs, or if this is not a
1996      code section.  */
1997   if (bfd_link_relocatable (link_info)
1998       || (sec->flags & SEC_RELOC) == 0
1999       || sec->reloc_count == 0
2000       || (sec->flags & SEC_CODE) == 0)
2001     return TRUE;
2002
2003   symtab_hdr = & elf_symtab_hdr (abfd);
2004   if (elf_symtab_shndx_list (abfd))
2005     shndx_hdr = & elf_symtab_shndx_list (abfd)->hdr;
2006   else
2007     shndx_hdr = NULL;
2008
2009   sec_start = sec->output_section->vma + sec->output_offset;
2010
2011   /* Get the section contents.  */
2012   if (elf_section_data (sec)->this_hdr.contents != NULL)
2013     contents = elf_section_data (sec)->this_hdr.contents;
2014   /* Go get them off disk.  */
2015   else
2016     {
2017       if (! bfd_malloc_and_get_section (abfd, sec, &contents))
2018         goto error_return;
2019       elf_section_data (sec)->this_hdr.contents = contents;
2020     }
2021
2022   /* Read this BFD's symbols.  */
2023   /* Get cached copy if it exists.  */
2024   if (symtab_hdr->contents != NULL)
2025     intsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
2026   else
2027     {
2028       intsyms = bfd_elf_get_elf_syms (abfd, symtab_hdr, symtab_hdr->sh_info, 0, NULL, NULL, NULL);
2029       symtab_hdr->contents = (bfd_byte *) intsyms;
2030     }
2031
2032   if (shndx_hdr && shndx_hdr->sh_size != 0)
2033     {
2034       bfd_size_type amt;
2035
2036       amt = symtab_hdr->sh_info;
2037       amt *= sizeof (Elf_External_Sym_Shndx);
2038       shndx_buf = (Elf_External_Sym_Shndx *) bfd_malloc (amt);
2039       if (shndx_buf == NULL)
2040         goto error_return;
2041       if (bfd_seek (abfd, shndx_hdr->sh_offset, SEEK_SET) != 0
2042           || bfd_bread (shndx_buf, amt, abfd) != amt)
2043         goto error_return;
2044       shndx_hdr->contents = (bfd_byte *) shndx_buf;
2045     }
2046
2047   /* Get a copy of the native relocations.  */
2048   /* Note - we ignore the setting of link_info->keep_memory when reading
2049      in these relocs.  We have to maintain a permanent copy of the relocs
2050      because we are going to walk over them multiple times, adjusting them
2051      as bytes are deleted from the section, and with this relaxation
2052      function itself being called multiple times on the same section...  */
2053   internal_relocs = _bfd_elf_link_read_relocs
2054     (abfd, sec, NULL, (Elf_Internal_Rela *) NULL, TRUE);
2055   if (internal_relocs == NULL)
2056     goto error_return;
2057
2058   /* The RL_ relocs must be just before the operand relocs they go
2059      with, so we must sort them to guarantee this.  We use bubblesort
2060      instead of qsort so we can guarantee that relocs with the same
2061      address remain in the same relative order.  */
2062   reloc_bubblesort (internal_relocs, sec->reloc_count);
2063
2064   /* Walk through them looking for relaxing opportunities.  */
2065   irelend = internal_relocs + sec->reloc_count;
2066
2067   /* This will either be NULL or a pointer to the next alignment
2068      relocation.  */
2069   next_alignment = internal_relocs;
2070   /* This will be the previous alignment, although at first it points
2071      to the first real relocation.  */
2072   prev_alignment = internal_relocs;
2073
2074   /* We calculate worst case shrinkage caused by alignment directives.
2075      No fool-proof, but better than either ignoring the problem or
2076      doing heavy duty analysis of all the alignment markers in all
2077      input sections.  */
2078   section_alignment_glue = 0;
2079   for (irel = internal_relocs; irel < irelend; irel++)
2080       if (ELF32_R_TYPE (irel->r_info) == R_RX_RH_RELAX
2081           && irel->r_addend & RX_RELAXA_ALIGN)
2082         {
2083           int this_glue = 1 << (irel->r_addend & RX_RELAXA_ANUM);
2084
2085           if (section_alignment_glue < this_glue)
2086             section_alignment_glue = this_glue;
2087         }
2088   /* Worst case is all 0..N alignments, in order, causing 2*N-1 byte
2089      shrinkage.  */
2090   section_alignment_glue *= 2;
2091
2092   for (irel = internal_relocs; irel < irelend; irel++)
2093     {
2094       unsigned char *insn;
2095       int nrelocs;
2096
2097       /* The insns we care about are all marked with one of these.  */
2098       if (ELF32_R_TYPE (irel->r_info) != R_RX_RH_RELAX)
2099         continue;
2100
2101       if (irel->r_addend & RX_RELAXA_ALIGN
2102           || next_alignment == internal_relocs)
2103         {
2104           /* When we delete bytes, we need to maintain all the alignments
2105              indicated.  In addition, we need to be careful about relaxing
2106              jumps across alignment boundaries - these displacements
2107              *grow* when we delete bytes.  For now, don't shrink
2108              displacements across an alignment boundary, just in case.
2109              Note that this only affects relocations to the same
2110              section.  */
2111           prev_alignment = next_alignment;
2112           next_alignment += 2;
2113           while (next_alignment < irelend
2114                  && (ELF32_R_TYPE (next_alignment->r_info) != R_RX_RH_RELAX
2115                      || !(next_alignment->r_addend & RX_RELAXA_ELIGN)))
2116             next_alignment ++;
2117           if (next_alignment >= irelend || next_alignment->r_offset == 0)
2118             next_alignment = NULL;
2119         }
2120
2121       /* When we hit alignment markers, see if we've shrunk enough
2122          before them to reduce the gap without violating the alignment
2123          requirements.  */
2124       if (irel->r_addend & RX_RELAXA_ALIGN)
2125         {
2126           /* At this point, the next relocation *should* be the ELIGN
2127              end marker.  */
2128           Elf_Internal_Rela *erel = irel + 1;
2129           unsigned int alignment, nbytes;
2130
2131           if (ELF32_R_TYPE (erel->r_info) != R_RX_RH_RELAX)
2132             continue;
2133           if (!(erel->r_addend & RX_RELAXA_ELIGN))
2134             continue;
2135
2136           alignment = 1 << (irel->r_addend & RX_RELAXA_ANUM);
2137
2138           if (erel->r_offset - irel->r_offset < alignment)
2139             continue;
2140
2141           nbytes = erel->r_offset - irel->r_offset;
2142           nbytes /= alignment;
2143           nbytes *= alignment;
2144
2145           elf32_rx_relax_delete_bytes (abfd, sec, erel->r_offset-nbytes, nbytes, next_alignment,
2146                                        erel->r_offset == sec->size, internal_relocs);
2147           *again = TRUE;
2148
2149           continue;
2150         }
2151
2152       if (irel->r_addend & RX_RELAXA_ELIGN)
2153           continue;
2154
2155       insn = contents + irel->r_offset;
2156
2157       nrelocs = irel->r_addend & RX_RELAXA_RNUM;
2158
2159       /* At this point, we have an insn that is a candidate for linker
2160          relaxation.  There are NRELOCS relocs following that may be
2161          relaxed, although each reloc may be made of more than one
2162          reloc entry (such as gp-rel symbols).  */
2163
2164       /* Get the value of the symbol referred to by the reloc.  Just
2165          in case this is the last reloc in the list, use the RL's
2166          addend to choose between this reloc (no addend) or the next
2167          (yes addend, which means at least one following reloc).  */
2168
2169       /* srel points to the "current" reloction for this insn -
2170          actually the last reloc for a given operand, which is the one
2171          we need to update.  We check the relaxations in the same
2172          order that the relocations happen, so we'll just push it
2173          along as we go.  */
2174       srel = irel;
2175
2176       pc = sec->output_section->vma + sec->output_offset
2177         + srel->r_offset;
2178
2179 #define GET_RELOC \
2180       symval = OFFSET_FOR_RELOC (srel, &srel, &scale); \
2181       pcrel = symval - pc + srel->r_addend; \
2182       nrelocs --;
2183
2184 #define SNIPNR(offset, nbytes) \
2185       elf32_rx_relax_delete_bytes (abfd, sec, (insn - contents) + offset, nbytes, next_alignment, 0, internal_relocs);
2186 #define SNIP(offset, nbytes, newtype) \
2187         SNIPNR (offset, nbytes);                                                \
2188         srel->r_info = ELF32_R_INFO (ELF32_R_SYM (srel->r_info), newtype)
2189
2190       /* The order of these bit tests must match the order that the
2191          relocs appear in.  Since we sorted those by offset, we can
2192          predict them.  */
2193
2194       /* Note that the numbers in, say, DSP6 are the bit offsets of
2195          the code fields that describe the operand.  Bits number 0 for
2196          the MSB of insn[0].  */
2197
2198       /* DSP* codes:
2199            0  00  [reg]
2200            1  01  dsp:8[reg]
2201            2  10  dsp:16[reg]
2202            3  11  reg  */
2203       if (irel->r_addend & RX_RELAXA_DSP6)
2204         {
2205           GET_RELOC;
2206
2207           code = insn[0] & 3;
2208           if (code == 2 && symval/scale <= 255)
2209             {
2210               unsigned int newrel = ELF32_R_TYPE (srel->r_info);
2211               insn[0] &= 0xfc;
2212               insn[0] |= 0x01;
2213               newrel = next_smaller_reloc (ELF32_R_TYPE (srel->r_info));
2214               if (newrel != ELF32_R_TYPE (srel->r_info))
2215                 {
2216                   SNIP (3, 1, newrel);
2217                   *again = TRUE;
2218                 }
2219             }
2220
2221           else if (code == 1 && symval == 0)
2222             {
2223               insn[0] &= 0xfc;
2224               SNIP (2, 1, R_RX_NONE);
2225               *again = TRUE;
2226             }
2227
2228           /* Special case DSP:5 format: MOV.bwl dsp:5[Rsrc],Rdst.  */
2229           else if (code == 1 && symval/scale <= 31
2230                    /* Decodable bits.  */
2231                    && (insn[0] & 0xcc) == 0xcc
2232                    /* Width.  */
2233                    && (insn[0] & 0x30) != 0x30
2234                    /* Register MSBs.  */
2235                    && (insn[1] & 0x88)  == 0x00)
2236             {
2237               int newrel = 0;
2238
2239               insn[0] = 0x88 | (insn[0] & 0x30);
2240               /* The register fields are in the right place already.  */
2241
2242               /* We can't relax this new opcode.  */
2243               irel->r_addend = 0;
2244
2245               switch ((insn[0] & 0x30) >> 4)
2246                 {
2247                 case 0:
2248                   newrel = R_RX_RH_ABS5p5B;
2249                   break;
2250                 case 1:
2251                   newrel = R_RX_RH_ABS5p5W;
2252                   break;
2253                 case 2:
2254                   newrel = R_RX_RH_ABS5p5L;
2255                   break;
2256                 }
2257
2258               move_reloc (irel, srel, -2);
2259               SNIP (2, 1, newrel);
2260             }
2261
2262           /* Special case DSP:5 format: MOVU.bw dsp:5[Rsrc],Rdst.  */
2263           else if (code == 1 && symval/scale <= 31
2264                    /* Decodable bits.  */
2265                    && (insn[0] & 0xf8) == 0x58
2266                    /* Register MSBs.  */
2267                    && (insn[1] & 0x88)  == 0x00)
2268             {
2269               int newrel = 0;
2270
2271               insn[0] = 0xb0 | ((insn[0] & 0x04) << 1);
2272               /* The register fields are in the right place already.  */
2273
2274               /* We can't relax this new opcode.  */
2275               irel->r_addend = 0;
2276
2277               switch ((insn[0] & 0x08) >> 3)
2278                 {
2279                 case 0:
2280                   newrel = R_RX_RH_ABS5p5B;
2281                   break;
2282                 case 1:
2283                   newrel = R_RX_RH_ABS5p5W;
2284                   break;
2285                 }
2286
2287               move_reloc (irel, srel, -2);
2288               SNIP (2, 1, newrel);
2289             }
2290         }
2291
2292       /* A DSP4 operand always follows a DSP6 operand, even if there's
2293          no relocation for it.  We have to read the code out of the
2294          opcode to calculate the offset of the operand.  */
2295       if (irel->r_addend & RX_RELAXA_DSP4)
2296         {
2297           int code6, offset = 0;
2298
2299           GET_RELOC;
2300
2301           code6 = insn[0] & 0x03;
2302           switch (code6)
2303             {
2304             case 0: offset = 2; break;
2305             case 1: offset = 3; break;
2306             case 2: offset = 4; break;
2307             case 3: offset = 2; break;
2308             }
2309
2310           code = (insn[0] & 0x0c) >> 2;
2311
2312           if (code == 2 && symval / scale <= 255)
2313             {
2314               unsigned int newrel = ELF32_R_TYPE (srel->r_info);
2315
2316               insn[0] &= 0xf3;
2317               insn[0] |= 0x04;
2318               newrel = next_smaller_reloc (ELF32_R_TYPE (srel->r_info));
2319               if (newrel != ELF32_R_TYPE (srel->r_info))
2320                 {
2321                   SNIP (offset+1, 1, newrel);
2322                   *again = TRUE;
2323                 }
2324             }
2325
2326           else if (code == 1 && symval == 0)
2327             {
2328               insn[0] &= 0xf3;
2329               SNIP (offset, 1, R_RX_NONE);
2330               *again = TRUE;
2331             }
2332           /* Special case DSP:5 format: MOV.bwl Rsrc,dsp:5[Rdst] */
2333           else if (code == 1 && symval/scale <= 31
2334                    /* Decodable bits.  */
2335                    && (insn[0] & 0xc3) == 0xc3
2336                    /* Width.  */
2337                    && (insn[0] & 0x30) != 0x30
2338                    /* Register MSBs.  */
2339                    && (insn[1] & 0x88)  == 0x00)
2340             {
2341               int newrel = 0;
2342
2343               insn[0] = 0x80 | (insn[0] & 0x30);
2344               /* The register fields are in the right place already.  */
2345
2346               /* We can't relax this new opcode.  */
2347               irel->r_addend = 0;
2348
2349               switch ((insn[0] & 0x30) >> 4)
2350                 {
2351                 case 0:
2352                   newrel = R_RX_RH_ABS5p5B;
2353                   break;
2354                 case 1:
2355                   newrel = R_RX_RH_ABS5p5W;
2356                   break;
2357                 case 2:
2358                   newrel = R_RX_RH_ABS5p5L;
2359                   break;
2360                 }
2361
2362               move_reloc (irel, srel, -2);
2363               SNIP (2, 1, newrel);
2364             }
2365         }
2366
2367       /* These always occur alone, but the offset depends on whether
2368          it's a MEMEX opcode (0x06) or not.  */
2369       if (irel->r_addend & RX_RELAXA_DSP14)
2370         {
2371           int offset;
2372           GET_RELOC;
2373
2374           if (insn[0] == 0x06)
2375             offset = 3;
2376           else
2377             offset = 4;
2378
2379           code = insn[1] & 3;
2380
2381           if (code == 2 && symval / scale <= 255)
2382             {
2383               unsigned int newrel = ELF32_R_TYPE (srel->r_info);
2384
2385               insn[1] &= 0xfc;
2386               insn[1] |= 0x01;
2387               newrel = next_smaller_reloc (ELF32_R_TYPE (srel->r_info));
2388               if (newrel != ELF32_R_TYPE (srel->r_info))
2389                 {
2390                   SNIP (offset, 1, newrel);
2391                   *again = TRUE;
2392                 }
2393             }
2394           else if (code == 1 && symval == 0)
2395             {
2396               insn[1] &= 0xfc;
2397               SNIP (offset, 1, R_RX_NONE);
2398               *again = TRUE;
2399             }
2400         }
2401
2402       /* IMM* codes:
2403            0  00  imm:32
2404            1  01  simm:8
2405            2  10  simm:16
2406            3  11  simm:24.  */
2407
2408       /* These always occur alone.  */
2409       if (irel->r_addend & RX_RELAXA_IMM6)
2410         {
2411           long ssymval;
2412
2413           GET_RELOC;
2414
2415           /* These relocations sign-extend, so we must do signed compares.  */
2416           ssymval = (long) symval;
2417
2418           code = insn[0] & 0x03;
2419
2420           if (code == 0 && ssymval <= 8388607 && ssymval >= -8388608)
2421             {
2422               unsigned int newrel = ELF32_R_TYPE (srel->r_info);
2423
2424               insn[0] &= 0xfc;
2425               insn[0] |= 0x03;
2426               newrel = next_smaller_reloc (ELF32_R_TYPE (srel->r_info));
2427               if (newrel != ELF32_R_TYPE (srel->r_info))
2428                 {
2429                   SNIP (2, 1, newrel);
2430                   *again = TRUE;
2431                 }
2432             }
2433
2434           else if (code == 3 && ssymval <= 32767 && ssymval >= -32768)
2435             {
2436               unsigned int newrel = ELF32_R_TYPE (srel->r_info);
2437
2438               insn[0] &= 0xfc;
2439               insn[0] |= 0x02;
2440               newrel = next_smaller_reloc (ELF32_R_TYPE (srel->r_info));
2441               if (newrel != ELF32_R_TYPE (srel->r_info))
2442                 {
2443                   SNIP (2, 1, newrel);
2444                   *again = TRUE;
2445                 }
2446             }
2447
2448           /* Special case UIMM8 format: CMP #uimm8,Rdst.  */
2449           else if (code == 2 && ssymval <= 255 && ssymval >= 16
2450                    /* Decodable bits.  */
2451                    && (insn[0] & 0xfc) == 0x74
2452                    /* Decodable bits.  */
2453                    && ((insn[1] & 0xf0) == 0x00))
2454             {
2455               int newrel;
2456
2457               insn[0] = 0x75;
2458               insn[1] = 0x50 | (insn[1] & 0x0f);
2459
2460               /* We can't relax this new opcode.  */
2461               irel->r_addend = 0;
2462
2463               if (STACK_REL_P (ELF32_R_TYPE (srel->r_info)))
2464                 newrel = R_RX_ABS8U;
2465               else
2466                 newrel = R_RX_DIR8U;
2467
2468               SNIP (2, 1, newrel);
2469               *again = TRUE;
2470             }
2471
2472           else if (code == 2 && ssymval <= 127 && ssymval >= -128)
2473             {
2474               unsigned int newrel = ELF32_R_TYPE (srel->r_info);
2475
2476               insn[0] &= 0xfc;
2477               insn[0] |= 0x01;
2478               newrel = next_smaller_reloc (ELF32_R_TYPE (srel->r_info));
2479               if (newrel != ELF32_R_TYPE (srel->r_info))
2480                 {
2481                   SNIP (2, 1, newrel);
2482                   *again = TRUE;
2483                 }
2484             }
2485
2486           /* Special case UIMM4 format: CMP, MUL, AND, OR.  */
2487           else if (code == 1 && ssymval <= 15 && ssymval >= 0
2488                    /* Decodable bits and immediate type.  */
2489                    && insn[0] == 0x75
2490                    /* Decodable bits.  */
2491                    && (insn[1] & 0xc0)  == 0x00)
2492             {
2493               static const int newop[4] = { 1, 3, 4, 5 };
2494
2495               insn[0] = 0x60 | newop[insn[1] >> 4];
2496               /* The register number doesn't move.  */
2497
2498               /* We can't relax this new opcode.  */
2499               irel->r_addend = 0;
2500
2501               move_reloc (irel, srel, -1);
2502
2503               SNIP (2, 1, R_RX_RH_UIMM4p8);
2504               *again = TRUE;
2505             }
2506
2507           /* Special case UIMM4 format: ADD -> ADD/SUB.  */
2508           else if (code == 1 && ssymval <= 15 && ssymval >= -15
2509                    /* Decodable bits and immediate type.  */
2510                    && insn[0] == 0x71
2511                    /* Same register for source and destination.  */
2512                    && ((insn[1] >> 4) == (insn[1] & 0x0f)))
2513             {
2514               int newrel;
2515
2516               /* Note that we can't turn "add $0,Rs" into a NOP
2517                  because the flags need to be set right.  */
2518
2519               if (ssymval < 0)
2520                 {
2521                   insn[0] = 0x60; /* Subtract.  */
2522                   newrel = R_RX_RH_UNEG4p8;
2523                 }
2524               else
2525                 {
2526                   insn[0] = 0x62; /* Add.  */
2527                   newrel = R_RX_RH_UIMM4p8;
2528                 }
2529
2530               /* The register number is in the right place.  */
2531
2532               /* We can't relax this new opcode.  */
2533               irel->r_addend = 0;
2534
2535               move_reloc (irel, srel, -1);
2536
2537               SNIP (2, 1, newrel);
2538               *again = TRUE;
2539             }
2540         }
2541
2542       /* These are either matched with a DSP6 (2-byte base) or an id24
2543          (3-byte base).  */
2544       if (irel->r_addend & RX_RELAXA_IMM12)
2545         {
2546           int dspcode, offset = 0;
2547           long ssymval;
2548
2549           GET_RELOC;
2550
2551           if ((insn[0] & 0xfc) == 0xfc)
2552             dspcode = 1; /* Just something with one byte operand.  */
2553           else
2554             dspcode = insn[0] & 3;
2555           switch (dspcode)
2556             {
2557             case 0: offset = 2; break;
2558             case 1: offset = 3; break;
2559             case 2: offset = 4; break;
2560             case 3: offset = 2; break;
2561             }
2562
2563           /* These relocations sign-extend, so we must do signed compares.  */
2564           ssymval = (long) symval;
2565
2566           code = (insn[1] >> 2) & 3;
2567           if (code == 0 && ssymval <= 8388607 && ssymval >= -8388608)
2568             {
2569               unsigned int newrel = ELF32_R_TYPE (srel->r_info);
2570
2571               insn[1] &= 0xf3;
2572               insn[1] |= 0x0c;
2573               newrel = next_smaller_reloc (ELF32_R_TYPE (srel->r_info));
2574               if (newrel != ELF32_R_TYPE (srel->r_info))
2575                 {
2576                   SNIP (offset, 1, newrel);
2577                   *again = TRUE;
2578                 }
2579             }
2580
2581           else if (code == 3 && ssymval <= 32767 && ssymval >= -32768)
2582             {
2583               unsigned int newrel = ELF32_R_TYPE (srel->r_info);
2584
2585               insn[1] &= 0xf3;
2586               insn[1] |= 0x08;
2587               newrel = next_smaller_reloc (ELF32_R_TYPE (srel->r_info));
2588               if (newrel != ELF32_R_TYPE (srel->r_info))
2589                 {
2590                   SNIP (offset, 1, newrel);
2591                   *again = TRUE;
2592                 }
2593             }
2594
2595           /* Special case UIMM8 format: MOV #uimm8,Rdst.  */
2596           else if (code == 2 && ssymval <= 255 && ssymval >= 16
2597                    /* Decodable bits.  */
2598                    && insn[0] == 0xfb
2599                    /* Decodable bits.  */
2600                    && ((insn[1] & 0x03) == 0x02))
2601             {
2602               int newrel;
2603
2604               insn[0] = 0x75;
2605               insn[1] = 0x40 | (insn[1] >> 4);
2606
2607               /* We can't relax this new opcode.  */
2608               irel->r_addend = 0;
2609
2610               if (STACK_REL_P (ELF32_R_TYPE (srel->r_info)))
2611                 newrel = R_RX_ABS8U;
2612               else
2613                 newrel = R_RX_DIR8U;
2614
2615               SNIP (2, 1, newrel);
2616               *again = TRUE;
2617             }
2618
2619           else if (code == 2 && ssymval <= 127 && ssymval >= -128)
2620             {
2621               unsigned int newrel = ELF32_R_TYPE(srel->r_info);
2622
2623               insn[1] &= 0xf3;
2624               insn[1] |= 0x04;
2625               newrel = next_smaller_reloc (ELF32_R_TYPE (srel->r_info));
2626               if (newrel != ELF32_R_TYPE(srel->r_info))
2627                 {
2628                   SNIP (offset, 1, newrel);
2629                   *again = TRUE;
2630                 }
2631             }
2632
2633           /* Special case UIMM4 format: MOV #uimm4,Rdst.  */
2634           else if (code == 1 && ssymval <= 15 && ssymval >= 0
2635                    /* Decodable bits.  */
2636                    && insn[0] == 0xfb
2637                    /* Decodable bits.  */
2638                    && ((insn[1] & 0x03) == 0x02))
2639             {
2640               insn[0] = 0x66;
2641               insn[1] = insn[1] >> 4;
2642
2643               /* We can't relax this new opcode.  */
2644               irel->r_addend = 0;
2645
2646               move_reloc (irel, srel, -1);
2647
2648               SNIP (2, 1, R_RX_RH_UIMM4p8);
2649               *again = TRUE;
2650             }
2651         }
2652
2653       if (irel->r_addend & RX_RELAXA_BRA)
2654         {
2655           unsigned int newrel = ELF32_R_TYPE (srel->r_info);
2656           int max_pcrel3 = 4;
2657           int alignment_glue = 0;
2658
2659           GET_RELOC;
2660
2661           /* Branches over alignment chunks are problematic, as
2662              deleting bytes here makes the branch *further* away.  We
2663              can be agressive with branches within this alignment
2664              block, but not branches outside it.  */
2665           if ((prev_alignment == NULL
2666                || symval < (bfd_vma)(sec_start + prev_alignment->r_offset))
2667               && (next_alignment == NULL
2668                   || symval > (bfd_vma)(sec_start + next_alignment->r_offset)))
2669             alignment_glue = section_alignment_glue;
2670
2671           if (ELF32_R_TYPE(srel[1].r_info) == R_RX_RH_RELAX
2672               && srel[1].r_addend & RX_RELAXA_BRA
2673               && srel[1].r_offset < irel->r_offset + pcrel)
2674             max_pcrel3 ++;
2675
2676           newrel = next_smaller_reloc (ELF32_R_TYPE (srel->r_info));
2677
2678           /* The values we compare PCREL with are not what you'd
2679              expect; they're off by a little to compensate for (1)
2680              where the reloc is relative to the insn, and (2) how much
2681              the insn is going to change when we relax it.  */
2682
2683           /* These we have to decode.  */
2684           switch (insn[0])
2685             {
2686             case 0x04: /* BRA pcdsp:24 */
2687               if (-32768 + alignment_glue <= pcrel
2688                   && pcrel <= 32765 - alignment_glue)
2689                 {
2690                   insn[0] = 0x38;
2691                   SNIP (3, 1, newrel);
2692                   *again = TRUE;
2693                 }
2694               break;
2695
2696             case 0x38: /* BRA pcdsp:16 */
2697               if (-128 + alignment_glue <= pcrel
2698                   && pcrel <= 127 - alignment_glue)
2699                 {
2700                   insn[0] = 0x2e;
2701                   SNIP (2, 1, newrel);
2702                   *again = TRUE;
2703                 }
2704               break;
2705
2706             case 0x2e: /* BRA pcdsp:8 */
2707               /* Note that there's a risk here of shortening things so
2708                  much that we no longer fit this reloc; it *should*
2709                  only happen when you branch across a branch, and that
2710                  branch also devolves into BRA.S.  "Real" code should
2711                  be OK.  */
2712               if (max_pcrel3 + alignment_glue <= pcrel
2713                   && pcrel <= 10 - alignment_glue
2714                   && allow_pcrel3)
2715                 {
2716                   insn[0] = 0x08;
2717                   SNIP (1, 1, newrel);
2718                   move_reloc (irel, srel, -1);
2719                   *again = TRUE;
2720                 }
2721               break;
2722
2723             case 0x05: /* BSR pcdsp:24 */
2724               if (-32768 + alignment_glue <= pcrel
2725                   && pcrel <= 32765 - alignment_glue)
2726                 {
2727                   insn[0] = 0x39;
2728                   SNIP (1, 1, newrel);
2729                   *again = TRUE;
2730                 }
2731               break;
2732
2733             case 0x3a: /* BEQ.W pcdsp:16 */
2734             case 0x3b: /* BNE.W pcdsp:16 */
2735               if (-128 + alignment_glue <= pcrel
2736                   && pcrel <= 127 - alignment_glue)
2737                 {
2738                   insn[0] = 0x20 | (insn[0] & 1);
2739                   SNIP (1, 1, newrel);
2740                   *again = TRUE;
2741                 }
2742               break;
2743
2744             case 0x20: /* BEQ.B pcdsp:8 */
2745             case 0x21: /* BNE.B pcdsp:8 */
2746               if (max_pcrel3 + alignment_glue <= pcrel
2747                   && pcrel - alignment_glue <= 10
2748                   && allow_pcrel3)
2749                 {
2750                   insn[0] = 0x10 | ((insn[0] & 1) << 3);
2751                   SNIP (1, 1, newrel);
2752                   move_reloc (irel, srel, -1);
2753                   *again = TRUE;
2754                 }
2755               break;
2756
2757             case 0x16: /* synthetic BNE dsp24 */
2758             case 0x1e: /* synthetic BEQ dsp24 */
2759               if (-32767 + alignment_glue <= pcrel
2760                   && pcrel <= 32766 - alignment_glue
2761                   && insn[1] == 0x04)
2762                 {
2763                   if (insn[0] == 0x16)
2764                     insn[0] = 0x3b;
2765                   else
2766                     insn[0] = 0x3a;
2767                   /* We snip out the bytes at the end else the reloc
2768                      will get moved too, and too much.  */
2769                   SNIP (3, 2, newrel);
2770                   move_reloc (irel, srel, -1);
2771                   *again = TRUE;
2772                 }
2773               break;
2774             }
2775
2776           /* Special case - synthetic conditional branches, pcrel24.
2777              Note that EQ and NE have been handled above.  */
2778           if ((insn[0] & 0xf0) == 0x20
2779               && insn[1] == 0x06
2780               && insn[2] == 0x04
2781               && srel->r_offset != irel->r_offset + 1
2782               && -32767 + alignment_glue <= pcrel
2783               && pcrel <= 32766 - alignment_glue)
2784             {
2785               insn[1] = 0x05;
2786               insn[2] = 0x38;
2787               SNIP (5, 1, newrel);
2788               *again = TRUE;
2789             }
2790
2791           /* Special case - synthetic conditional branches, pcrel16 */
2792           if ((insn[0] & 0xf0) == 0x20
2793               && insn[1] == 0x05
2794               && insn[2] == 0x38
2795               && srel->r_offset != irel->r_offset + 1
2796               && -127 + alignment_glue <= pcrel
2797               && pcrel <= 126 - alignment_glue)
2798             {
2799               int cond = (insn[0] & 0x0f) ^ 0x01;
2800
2801               insn[0] = 0x20 | cond;
2802               /* By moving the reloc first, we avoid having
2803                  delete_bytes move it also.  */
2804               move_reloc (irel, srel, -2);
2805               SNIP (2, 3, newrel);
2806               *again = TRUE;
2807             }
2808         }
2809
2810       BFD_ASSERT (nrelocs == 0);
2811
2812       /* Special case - check MOV.bwl #IMM, dsp[reg] and see if we can
2813          use MOV.bwl #uimm:8, dsp:5[r7] format.  This is tricky
2814          because it may have one or two relocations.  */
2815       if ((insn[0] & 0xfc) == 0xf8
2816           && (insn[1] & 0x80) == 0x00
2817           && (insn[0] & 0x03) != 0x03)
2818         {
2819           int dcode, icode, reg, ioff, dscale, ilen;
2820           bfd_vma disp_val = 0;
2821           long imm_val = 0;
2822           Elf_Internal_Rela * disp_rel = 0;
2823           Elf_Internal_Rela * imm_rel = 0;
2824
2825           /* Reset this.  */
2826           srel = irel;
2827
2828           dcode = insn[0] & 0x03;
2829           icode = (insn[1] >> 2) & 0x03;
2830           reg = (insn[1] >> 4) & 0x0f;
2831
2832           ioff = dcode == 1 ? 3 : dcode == 2 ? 4 : 2;
2833
2834           /* Figure out what the dispacement is.  */
2835           if (dcode == 1 || dcode == 2)
2836             {
2837               /* There's a displacement.  See if there's a reloc for it.  */
2838               if (srel[1].r_offset == irel->r_offset + 2)
2839                 {
2840                   GET_RELOC;
2841                   disp_val = symval;
2842                   disp_rel = srel;
2843                 }
2844               else
2845                 {
2846                   if (dcode == 1)
2847                     disp_val = insn[2];
2848                   else
2849                     {
2850 #if RX_OPCODE_BIG_ENDIAN
2851                       disp_val = insn[2] * 256 + insn[3];
2852 #else
2853                       disp_val = insn[2] + insn[3] * 256;
2854 #endif
2855                     }
2856                   switch (insn[1] & 3)
2857                     {
2858                     case 1:
2859                       disp_val *= 2;
2860                       scale = 2;
2861                       break;
2862                     case 2:
2863                       disp_val *= 4;
2864                       scale = 4;
2865                       break;
2866                     }
2867                 }
2868             }
2869
2870           dscale = scale;
2871
2872           /* Figure out what the immediate is.  */
2873           if (srel[1].r_offset == irel->r_offset + ioff)
2874             {
2875               GET_RELOC;
2876               imm_val = (long) symval;
2877               imm_rel = srel;
2878             }
2879           else
2880             {
2881               unsigned char * ip = insn + ioff;
2882
2883               switch (icode)
2884                 {
2885                 case 1:
2886                   /* For byte writes, we don't sign extend.  Makes the math easier later.  */
2887                   if (scale == 1)
2888                     imm_val = ip[0];
2889                   else
2890                     imm_val = (char) ip[0];
2891                   break;
2892                 case 2:
2893 #if RX_OPCODE_BIG_ENDIAN
2894                   imm_val = ((char) ip[0] << 8) | ip[1];
2895 #else
2896                   imm_val = ((char) ip[1] << 8) | ip[0];
2897 #endif
2898                   break;
2899                 case 3:
2900 #if RX_OPCODE_BIG_ENDIAN
2901                   imm_val = ((char) ip[0] << 16) | (ip[1] << 8) | ip[2];
2902 #else
2903                   imm_val = ((char) ip[2] << 16) | (ip[1] << 8) | ip[0];
2904 #endif
2905                   break;
2906                 case 0:
2907 #if RX_OPCODE_BIG_ENDIAN
2908                   imm_val = (ip[0] << 24) | (ip[1] << 16) | (ip[2] << 8) | ip[3];
2909 #else
2910                   imm_val = (ip[3] << 24) | (ip[2] << 16) | (ip[1] << 8) | ip[0];
2911 #endif
2912                   break;
2913                 }
2914             }
2915
2916           ilen = 2;
2917
2918           switch (dcode)
2919             {
2920             case 1:
2921               ilen += 1;
2922               break;
2923             case 2:
2924               ilen += 2;
2925               break;
2926             }
2927
2928           switch (icode)
2929             {
2930             case 1:
2931               ilen += 1;
2932               break;
2933             case 2:
2934               ilen += 2;
2935               break;
2936             case 3:
2937               ilen += 3;
2938               break;
2939             case 4:
2940               ilen += 4;
2941               break;
2942             }
2943
2944           /* The shortcut happens when the immediate is 0..255,
2945              register r0 to r7, and displacement (scaled) 0..31.  */
2946
2947           if (0 <= imm_val && imm_val <= 255
2948               && 0 <= reg && reg <= 7
2949               && disp_val / dscale <= 31)
2950             {
2951               insn[0] = 0x3c | (insn[1] & 0x03);
2952               insn[1] = (((disp_val / dscale) << 3) & 0x80) | (reg << 4) | ((disp_val/dscale) & 0x0f);
2953               insn[2] = imm_val;
2954
2955               if (disp_rel)
2956                 {
2957                   int newrel = R_RX_NONE;
2958
2959                   switch (dscale)
2960                     {
2961                     case 1:
2962                       newrel = R_RX_RH_ABS5p8B;
2963                       break;
2964                     case 2:
2965                       newrel = R_RX_RH_ABS5p8W;
2966                       break;
2967                     case 4:
2968                       newrel = R_RX_RH_ABS5p8L;
2969                       break;
2970                     }
2971                   disp_rel->r_info = ELF32_R_INFO (ELF32_R_SYM (disp_rel->r_info), newrel);
2972                   move_reloc (irel, disp_rel, -1);
2973                 }
2974               if (imm_rel)
2975                 {
2976                   imm_rel->r_info = ELF32_R_INFO (ELF32_R_SYM (imm_rel->r_info), R_RX_DIR8U);
2977                   move_reloc (disp_rel ? disp_rel : irel,
2978                               imm_rel,
2979                               irel->r_offset - imm_rel->r_offset + 2);
2980                 }
2981
2982               SNIPNR (3, ilen - 3);
2983               *again = TRUE;
2984
2985               /* We can't relax this new opcode.  */
2986               irel->r_addend = 0;
2987             }
2988         }
2989     }
2990
2991   /* We can't reliably relax branches to DIR3U_PCREL unless we know
2992      whatever they're branching over won't shrink any more.  If we're
2993      basically done here, do one more pass just for branches - but
2994      don't request a pass after that one!  */
2995   if (!*again && !allow_pcrel3)
2996     {
2997       bfd_boolean ignored;
2998
2999       elf32_rx_relax_section (abfd, sec, link_info, &ignored, TRUE);
3000     }
3001
3002   return TRUE;
3003
3004  error_return:
3005   if (free_contents != NULL)
3006     free (free_contents);
3007
3008   if (shndx_buf != NULL)
3009     {
3010       shndx_hdr->contents = NULL;
3011       free (shndx_buf);
3012     }
3013
3014   if (free_intsyms != NULL)
3015     free (free_intsyms);
3016
3017   return FALSE;
3018 }
3019
3020 static bfd_boolean
3021 elf32_rx_relax_section_wrapper (bfd *                  abfd,
3022                                 asection *             sec,
3023                                 struct bfd_link_info * link_info,
3024                                 bfd_boolean *          again)
3025 {
3026   return elf32_rx_relax_section (abfd, sec, link_info, again, FALSE);
3027 }
3028 \f
3029 /* Function to set the ELF flag bits.  */
3030
3031 static bfd_boolean
3032 rx_elf_set_private_flags (bfd * abfd, flagword flags)
3033 {
3034   elf_elfheader (abfd)->e_flags = flags;
3035   elf_flags_init (abfd) = TRUE;
3036   return TRUE;
3037 }
3038
3039 static bfd_boolean no_warn_mismatch = FALSE;
3040 static bfd_boolean ignore_lma = TRUE;
3041
3042 void bfd_elf32_rx_set_target_flags (bfd_boolean, bfd_boolean);
3043
3044 void
3045 bfd_elf32_rx_set_target_flags (bfd_boolean user_no_warn_mismatch,
3046                                bfd_boolean user_ignore_lma)
3047 {
3048   no_warn_mismatch = user_no_warn_mismatch;
3049   ignore_lma = user_ignore_lma;
3050 }
3051
3052 /* Converts FLAGS into a descriptive string.
3053    Returns a static pointer.  */
3054
3055 static const char *
3056 describe_flags (flagword flags)
3057 {
3058   static char buf [128];
3059
3060   buf[0] = 0;
3061
3062   if (flags & E_FLAG_RX_64BIT_DOUBLES)
3063     strcat (buf, "64-bit doubles");
3064   else
3065     strcat (buf, "32-bit doubles");
3066
3067   if (flags & E_FLAG_RX_DSP)
3068     strcat (buf, ", dsp");
3069   else
3070     strcat (buf, ", no dsp");
3071
3072   if (flags & E_FLAG_RX_PID)
3073     strcat (buf, ", pid");
3074   else
3075     strcat (buf, ", no pid");
3076
3077   if (flags & E_FLAG_RX_ABI)
3078     strcat (buf, ", RX ABI");
3079   else
3080     strcat (buf, ", GCC ABI");
3081
3082   if (flags & E_FLAG_RX_SINSNS_SET)
3083     strcat (buf, flags & E_FLAG_RX_SINSNS_YES ? ", uses String instructions" : ", bans String instructions");
3084
3085   return buf;
3086 }
3087
3088 /* Merge backend specific data from an object file to the output
3089    object file when linking.  */
3090
3091 static bfd_boolean
3092 rx_elf_merge_private_bfd_data (bfd * ibfd, bfd * obfd)
3093 {
3094   flagword old_flags;
3095   flagword new_flags;
3096   bfd_boolean error = FALSE;
3097
3098   new_flags = elf_elfheader (ibfd)->e_flags;
3099   old_flags = elf_elfheader (obfd)->e_flags;
3100
3101   if (!elf_flags_init (obfd))
3102     {
3103       /* First call, no flags set.  */
3104       elf_flags_init (obfd) = TRUE;
3105       elf_elfheader (obfd)->e_flags = new_flags;
3106     }
3107   else if (old_flags != new_flags)
3108     {
3109       flagword known_flags;
3110
3111       if (old_flags & E_FLAG_RX_SINSNS_SET)
3112         {
3113           if ((new_flags & E_FLAG_RX_SINSNS_SET) == 0)
3114             {
3115               new_flags &= ~ E_FLAG_RX_SINSNS_MASK;
3116               new_flags |= (old_flags & E_FLAG_RX_SINSNS_MASK);
3117             }
3118         }
3119       else if (new_flags & E_FLAG_RX_SINSNS_SET)
3120         {
3121           old_flags &= ~ E_FLAG_RX_SINSNS_MASK;
3122           old_flags |= (new_flags & E_FLAG_RX_SINSNS_MASK);
3123         }
3124
3125       known_flags = E_FLAG_RX_ABI | E_FLAG_RX_64BIT_DOUBLES
3126         | E_FLAG_RX_DSP | E_FLAG_RX_PID | E_FLAG_RX_SINSNS_MASK;
3127
3128       if ((old_flags ^ new_flags) & known_flags)
3129         {
3130           /* Only complain if flag bits we care about do not match.
3131              Other bits may be set, since older binaries did use some
3132              deprecated flags.  */
3133           if (no_warn_mismatch)
3134             {
3135               elf_elfheader (obfd)->e_flags = (new_flags | old_flags) & known_flags;
3136             }
3137           else
3138             {
3139               _bfd_error_handler ("There is a conflict merging the ELF header flags from %s",
3140                                   bfd_get_filename (ibfd));
3141               _bfd_error_handler ("  the input  file's flags: %s",
3142                                   describe_flags (new_flags));
3143               _bfd_error_handler ("  the output file's flags: %s",
3144                                   describe_flags (old_flags));
3145               error = TRUE;
3146             }
3147         }
3148       else
3149         elf_elfheader (obfd)->e_flags = new_flags & known_flags;
3150     }
3151
3152   if (error)
3153     bfd_set_error (bfd_error_bad_value);
3154
3155   return !error;
3156 }
3157 \f
3158 static bfd_boolean
3159 rx_elf_print_private_bfd_data (bfd * abfd, void * ptr)
3160 {
3161   FILE * file = (FILE *) ptr;
3162   flagword flags;
3163
3164   BFD_ASSERT (abfd != NULL && ptr != NULL);
3165
3166   /* Print normal ELF private data.  */
3167   _bfd_elf_print_private_bfd_data (abfd, ptr);
3168
3169   flags = elf_elfheader (abfd)->e_flags;
3170   fprintf (file, _("private flags = 0x%lx:"), (long) flags);
3171
3172   fprintf (file, "%s", describe_flags (flags));
3173   return TRUE;
3174 }
3175
3176 /* Return the MACH for an e_flags value.  */
3177
3178 static int
3179 elf32_rx_machine (bfd * abfd ATTRIBUTE_UNUSED)
3180 {
3181 #if 0 /* FIXME: EF_RX_CPU_MASK collides with E_FLAG_RX_...
3182          Need to sort out how these flag bits are used.
3183          For now we assume that the flags are OK.  */
3184   if ((elf_elfheader (abfd)->e_flags & EF_RX_CPU_MASK) == EF_RX_CPU_RX)
3185 #endif
3186     return bfd_mach_rx;
3187
3188   return 0;
3189 }
3190
3191 static bfd_boolean
3192 rx_elf_object_p (bfd * abfd)
3193 {
3194   int i;
3195   unsigned int u;
3196   Elf_Internal_Phdr *phdr = elf_tdata (abfd)->phdr;
3197   int nphdrs = elf_elfheader (abfd)->e_phnum;
3198   sec_ptr bsec;
3199   static int saw_be = FALSE;
3200
3201   /* We never want to automatically choose the non-swapping big-endian
3202      target.  The user can only get that explicitly, such as with -I
3203      and objcopy.  */
3204   if (abfd->xvec == &rx_elf32_be_ns_vec
3205       && abfd->target_defaulted)
3206     return FALSE;
3207
3208   /* BFD->target_defaulted is not set to TRUE when a target is chosen
3209      as a fallback, so we check for "scanning" to know when to stop
3210      using the non-swapping target.  */
3211   if (abfd->xvec == &rx_elf32_be_ns_vec
3212       && saw_be)
3213     return FALSE;
3214   if (abfd->xvec == &rx_elf32_be_vec)
3215     saw_be = TRUE;
3216
3217   bfd_default_set_arch_mach (abfd, bfd_arch_rx,
3218                              elf32_rx_machine (abfd));
3219
3220   /* For each PHDR in the object, we must find some section that
3221      corresponds (based on matching file offsets) and use its VMA
3222      information to reconstruct the p_vaddr field we clobbered when we
3223      wrote it out.  */
3224   for (i=0; i<nphdrs; i++)
3225     {
3226       for (u=0; u<elf_tdata(abfd)->num_elf_sections; u++)
3227         {
3228           Elf_Internal_Shdr *sec = elf_tdata(abfd)->elf_sect_ptr[u];
3229
3230           if (phdr[i].p_filesz
3231               && phdr[i].p_offset <= (bfd_vma) sec->sh_offset
3232               && sec->sh_size > 0
3233               && sec->sh_type != SHT_NOBITS
3234               && (bfd_vma)sec->sh_offset <= phdr[i].p_offset + (phdr[i].p_filesz - 1))
3235             {
3236               /* Found one!  The difference between the two addresses,
3237                  plus the difference between the two file offsets, is
3238                  enough information to reconstruct the lma.  */
3239
3240               /* Example where they aren't:
3241                  PHDR[1] = lma fffc0100 offset 00002010 size 00000100
3242                  SEC[6]  = vma 00000050 offset 00002050 size 00000040
3243
3244                  The correct LMA for the section is fffc0140 + (2050-2010).
3245               */
3246
3247               phdr[i].p_vaddr = sec->sh_addr + (sec->sh_offset - phdr[i].p_offset);
3248               break;
3249             }
3250         }
3251
3252       /* We must update the bfd sections as well, so we don't stop
3253          with one match.  */
3254       bsec = abfd->sections;
3255       while (bsec)
3256         {
3257           if (phdr[i].p_filesz
3258               && phdr[i].p_vaddr <= bsec->vma
3259               && bsec->vma <= phdr[i].p_vaddr + (phdr[i].p_filesz - 1))
3260             {
3261               bsec->lma = phdr[i].p_paddr + (bsec->vma - phdr[i].p_vaddr);
3262             }
3263           bsec = bsec->next;
3264         }
3265     }
3266
3267   return TRUE;
3268 }
3269  \f
3270
3271 #ifdef DEBUG
3272 void
3273 rx_dump_symtab (bfd * abfd, void * internal_syms, void * external_syms)
3274 {
3275   size_t locsymcount;
3276   Elf_Internal_Sym * isymbuf;
3277   Elf_Internal_Sym * isymend;
3278   Elf_Internal_Sym * isym;
3279   Elf_Internal_Shdr * symtab_hdr;
3280   bfd_boolean free_internal = FALSE, free_external = FALSE;
3281   char * st_info_str;
3282   char * st_info_stb_str;
3283   char * st_other_str;
3284   char * st_shndx_str;
3285
3286   if (! internal_syms)
3287     {
3288       internal_syms = bfd_malloc (1000);
3289       free_internal = 1;
3290     }
3291   if (! external_syms)
3292     {
3293       external_syms = bfd_malloc (1000);
3294       free_external = 1;
3295     }
3296
3297   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3298   locsymcount = symtab_hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
3299   if (free_internal)
3300     isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
3301                                     symtab_hdr->sh_info, 0,
3302                                     internal_syms, external_syms, NULL);
3303   else
3304     isymbuf = internal_syms;
3305   isymend = isymbuf + locsymcount;
3306
3307   for (isym = isymbuf ; isym < isymend ; isym++)
3308     {
3309       switch (ELF_ST_TYPE (isym->st_info))
3310         {
3311         case STT_FUNC: st_info_str = "STT_FUNC"; break;
3312         case STT_SECTION: st_info_str = "STT_SECTION"; break;
3313         case STT_FILE: st_info_str = "STT_FILE"; break;
3314         case STT_OBJECT: st_info_str = "STT_OBJECT"; break;
3315         case STT_TLS: st_info_str = "STT_TLS"; break;
3316         default: st_info_str = "";
3317         }
3318       switch (ELF_ST_BIND (isym->st_info))
3319         {
3320         case STB_LOCAL: st_info_stb_str = "STB_LOCAL"; break;
3321         case STB_GLOBAL: st_info_stb_str = "STB_GLOBAL"; break;
3322         default: st_info_stb_str = "";
3323         }
3324       switch (ELF_ST_VISIBILITY (isym->st_other))
3325         {
3326         case STV_DEFAULT: st_other_str = "STV_DEFAULT"; break;
3327         case STV_INTERNAL: st_other_str = "STV_INTERNAL"; break;
3328         case STV_PROTECTED: st_other_str = "STV_PROTECTED"; break;
3329         default: st_other_str = "";
3330         }
3331       switch (isym->st_shndx)
3332         {
3333         case SHN_ABS: st_shndx_str = "SHN_ABS"; break;
3334         case SHN_COMMON: st_shndx_str = "SHN_COMMON"; break;
3335         case SHN_UNDEF: st_shndx_str = "SHN_UNDEF"; break;
3336         default: st_shndx_str = "";
3337         }
3338
3339       printf ("isym = %p st_value = %lx st_size = %lx st_name = (%lu) %s "
3340               "st_info = (%d) %s %s st_other = (%d) %s st_shndx = (%d) %s\n",
3341               isym,
3342               (unsigned long) isym->st_value,
3343               (unsigned long) isym->st_size,
3344               isym->st_name,
3345               bfd_elf_string_from_elf_section (abfd, symtab_hdr->sh_link,
3346                                                isym->st_name),
3347               isym->st_info, st_info_str, st_info_stb_str,
3348               isym->st_other, st_other_str,
3349               isym->st_shndx, st_shndx_str);
3350     }
3351   if (free_internal)
3352     free (internal_syms);
3353   if (free_external)
3354     free (external_syms);
3355 }
3356
3357 char *
3358 rx_get_reloc (long reloc)
3359 {
3360   if (0 <= reloc && reloc < R_RX_max)
3361     return rx_elf_howto_table[reloc].name;
3362   return "";
3363 }
3364 #endif /* DEBUG */
3365
3366 \f
3367 /* We must take care to keep the on-disk copy of any code sections
3368    that are fully linked swapped if the target is big endian, to match
3369    the Renesas tools.  */
3370
3371 /* The rule is: big endian object that are final-link executables,
3372    have code sections stored with 32-bit words swapped relative to
3373    what you'd get by default.  */
3374
3375 static bfd_boolean
3376 rx_get_section_contents (bfd *         abfd,
3377                          sec_ptr       section,
3378                          void *        location,
3379                          file_ptr      offset,
3380                          bfd_size_type count)
3381 {
3382   int exec = (abfd->flags & EXEC_P) ? 1 : 0;
3383   int s_code = (section->flags & SEC_CODE) ? 1 : 0;
3384   bfd_boolean rv;
3385
3386 #ifdef DJDEBUG
3387   fprintf (stderr, "dj: get %ld %ld from %s  %s e%d sc%d  %08lx:%08lx\n",
3388            (long) offset, (long) count, section->name,
3389            bfd_big_endian(abfd) ? "be" : "le",
3390            exec, s_code, (long unsigned) section->filepos,
3391            (long unsigned) offset);
3392 #endif
3393
3394   if (exec && s_code && bfd_big_endian (abfd))
3395     {
3396       char * cloc = (char *) location;
3397       bfd_size_type cnt, end_cnt;
3398
3399       rv = TRUE;
3400
3401       /* Fetch and swap unaligned bytes at the beginning.  */
3402       if (offset % 4)
3403         {
3404           char buf[4];
3405
3406           rv = _bfd_generic_get_section_contents (abfd, section, buf,
3407                                                   (offset & -4), 4);
3408           if (!rv)
3409             return FALSE;
3410
3411           bfd_putb32 (bfd_getl32 (buf), buf);
3412
3413           cnt = 4 - (offset % 4);
3414           if (cnt > count)
3415             cnt = count;
3416
3417           memcpy (location, buf + (offset % 4), cnt);
3418
3419           count -= cnt;
3420           offset += cnt;
3421           cloc += count;
3422         }
3423
3424       end_cnt = count % 4;
3425
3426       /* Fetch and swap the middle bytes.  */
3427       if (count >= 4)
3428         {
3429           rv = _bfd_generic_get_section_contents (abfd, section, cloc, offset,
3430                                                   count - end_cnt);
3431           if (!rv)
3432             return FALSE;
3433
3434           for (cnt = count; cnt >= 4; cnt -= 4, cloc += 4)
3435             bfd_putb32 (bfd_getl32 (cloc), cloc);
3436         }
3437
3438       /* Fetch and swap the end bytes.  */
3439       if (end_cnt > 0)
3440         {
3441           char buf[4];
3442
3443           /* Fetch the end bytes.  */
3444           rv = _bfd_generic_get_section_contents (abfd, section, buf,
3445                                                   offset + count - end_cnt, 4);
3446           if (!rv)
3447             return FALSE;
3448
3449           bfd_putb32 (bfd_getl32 (buf), buf);
3450           memcpy (cloc, buf, end_cnt);
3451         }
3452     }
3453   else
3454     rv = _bfd_generic_get_section_contents (abfd, section, location, offset, count);
3455
3456   return rv;
3457 }
3458
3459 #ifdef DJDEBUG
3460 static bfd_boolean
3461 rx2_set_section_contents (bfd *        abfd,
3462                          sec_ptr       section,
3463                          const void *  location,
3464                          file_ptr      offset,
3465                          bfd_size_type count)
3466 {
3467   bfd_size_type i;
3468
3469   fprintf (stderr, "   set sec %s %08x loc %p offset %#x count %#x\n",
3470            section->name, (unsigned) section->vma, location, (int) offset, (int) count);
3471   for (i = 0; i < count; i++)
3472     {
3473       if (i % 16 == 0 && i > 0)
3474         fprintf (stderr, "\n");
3475
3476       if (i % 16  && i % 4 == 0)
3477         fprintf (stderr, " ");
3478
3479       if (i % 16 == 0)
3480         fprintf (stderr, "      %08x:", (int) (section->vma + offset + i));
3481
3482       fprintf (stderr, " %02x", ((unsigned char *) location)[i]);
3483     }
3484   fprintf (stderr, "\n");
3485
3486   return _bfd_elf_set_section_contents (abfd, section, location, offset, count);
3487 }
3488 #define _bfd_elf_set_section_contents rx2_set_section_contents
3489 #endif
3490
3491 static bfd_boolean
3492 rx_set_section_contents (bfd *         abfd,
3493                          sec_ptr       section,
3494                          const void *  location,
3495                          file_ptr      offset,
3496                          bfd_size_type count)
3497 {
3498   bfd_boolean exec = (abfd->flags & EXEC_P) ? TRUE : FALSE;
3499   bfd_boolean s_code = (section->flags & SEC_CODE) ? TRUE : FALSE;
3500   bfd_boolean rv;
3501   char * swapped_data = NULL;
3502   bfd_size_type i;
3503   bfd_vma caddr = section->vma + offset;
3504   file_ptr faddr = 0;
3505   bfd_size_type scount;
3506
3507 #ifdef DJDEBUG
3508   bfd_size_type i;
3509
3510   fprintf (stderr, "\ndj: set %ld %ld to %s  %s e%d sc%d\n",
3511            (long) offset, (long) count, section->name,
3512            bfd_big_endian (abfd) ? "be" : "le",
3513            exec, s_code);
3514
3515   for (i = 0; i < count; i++)
3516     {
3517       int a = section->vma + offset + i;
3518
3519       if (a % 16 == 0 && a > 0)
3520         fprintf (stderr, "\n");
3521
3522       if (a % 16  && a % 4 == 0)
3523         fprintf (stderr, " ");
3524
3525       if (a % 16 == 0 || i == 0)
3526         fprintf (stderr, "      %08x:", (int) (section->vma + offset + i));
3527
3528       fprintf (stderr, " %02x", ((unsigned char *) location)[i]);
3529     }
3530
3531   fprintf (stderr, "\n");
3532 #endif
3533
3534   if (! exec || ! s_code || ! bfd_big_endian (abfd))
3535     return _bfd_elf_set_section_contents (abfd, section, location, offset, count);
3536
3537   while (count > 0 && caddr > 0 && caddr % 4)
3538     {
3539       switch (caddr % 4)
3540         {
3541         case 0: faddr = offset + 3; break;
3542         case 1: faddr = offset + 1; break;
3543         case 2: faddr = offset - 1; break;
3544         case 3: faddr = offset - 3; break;
3545         }
3546
3547       rv = _bfd_elf_set_section_contents (abfd, section, location, faddr, 1);
3548       if (! rv)
3549         return rv;
3550
3551       location ++;
3552       offset ++;
3553       count --;
3554       caddr ++;
3555     }
3556
3557   scount = (int)(count / 4) * 4;
3558   if (scount > 0)
3559     {
3560       char * cloc = (char *) location;
3561
3562       swapped_data = (char *) bfd_alloc (abfd, count);
3563
3564       for (i = 0; i < count; i += 4)
3565         {
3566           bfd_vma v = bfd_getl32 (cloc + i);
3567           bfd_putb32 (v, swapped_data + i);
3568         }
3569
3570       rv = _bfd_elf_set_section_contents (abfd, section, swapped_data, offset, scount);
3571
3572       if (!rv)
3573         return rv;
3574     }
3575
3576   count -= scount;
3577   location += scount;
3578   offset += scount;
3579
3580   if (count > 0)
3581     {
3582       caddr = section->vma + offset;
3583       while (count > 0)
3584         {
3585           switch (caddr % 4)
3586             {
3587             case 0: faddr = offset + 3; break;
3588             case 1: faddr = offset + 1; break;
3589             case 2: faddr = offset - 1; break;
3590             case 3: faddr = offset - 3; break;
3591             }
3592           rv = _bfd_elf_set_section_contents (abfd, section, location, faddr, 1);
3593           if (! rv)
3594             return rv;
3595
3596           location ++;
3597           offset ++;
3598           count --;
3599           caddr ++;
3600         }
3601     }
3602
3603   return TRUE;
3604 }
3605
3606 static bfd_boolean
3607 rx_final_link (bfd * abfd, struct bfd_link_info * info)
3608 {
3609   asection * o;
3610
3611   for (o = abfd->sections; o != NULL; o = o->next)
3612     {
3613 #ifdef DJDEBUG
3614       fprintf (stderr, "sec %s fl %x vma %lx lma %lx size %lx raw %lx\n",
3615                o->name, o->flags, o->vma, o->lma, o->size, o->rawsize);
3616 #endif
3617       if (o->flags & SEC_CODE
3618           && bfd_big_endian (abfd)
3619           && o->size % 4)
3620         {
3621 #ifdef DJDEBUG
3622           fprintf (stderr, "adjusting...\n");
3623 #endif
3624           o->size += 4 - (o->size % 4);
3625         }
3626     }
3627
3628   return bfd_elf_final_link (abfd, info);
3629 }
3630
3631 static bfd_boolean
3632 elf32_rx_modify_program_headers (bfd * abfd ATTRIBUTE_UNUSED,
3633                                  struct bfd_link_info * info ATTRIBUTE_UNUSED)
3634 {
3635   const struct elf_backend_data * bed;
3636   struct elf_obj_tdata * tdata;
3637   Elf_Internal_Phdr * phdr;
3638   unsigned int count;
3639   unsigned int i;
3640
3641   bed = get_elf_backend_data (abfd);
3642   tdata = elf_tdata (abfd);
3643   phdr = tdata->phdr;
3644   count = elf_program_header_size (abfd) / bed->s->sizeof_phdr;
3645
3646   if (ignore_lma)
3647     for (i = count; i-- != 0;)
3648       if (phdr[i].p_type == PT_LOAD)
3649         {
3650           /* The Renesas tools expect p_paddr to be zero.  However,
3651              there is no other way to store the writable data in ROM for
3652              startup initialization.  So, we let the linker *think*
3653              we're using paddr and vaddr the "usual" way, but at the
3654              last minute we move the paddr into the vaddr (which is what
3655              the simulator uses) and zero out paddr.  Note that this
3656              does not affect the section headers, just the program
3657              headers.  We hope.  */
3658           phdr[i].p_vaddr = phdr[i].p_paddr;
3659 #if 0     /* If we zero out p_paddr, then the LMA in the section table
3660              becomes wrong.  */
3661           phdr[i].p_paddr = 0;
3662 #endif
3663         }
3664
3665   return TRUE;
3666 }
3667
3668 /* The default literal sections should always be marked as "code" (i.e.,
3669    SHF_EXECINSTR).  This is particularly important for big-endian mode
3670    when we do not want their contents byte reversed.  */
3671 static const struct bfd_elf_special_section elf32_rx_special_sections[] =
3672 {
3673   { STRING_COMMA_LEN (".init_array"),    0, SHT_INIT_ARRAY, SHF_ALLOC + SHF_EXECINSTR },
3674   { STRING_COMMA_LEN (".fini_array"),    0, SHT_FINI_ARRAY, SHF_ALLOC + SHF_EXECINSTR },
3675   { STRING_COMMA_LEN (".preinit_array"), 0, SHT_PREINIT_ARRAY, SHF_ALLOC + SHF_EXECINSTR },
3676   { NULL,                        0,      0, 0,            0 }
3677 };
3678 \f
3679 typedef struct {
3680   bfd *abfd;
3681   struct bfd_link_info *info;
3682   bfd_vma table_start;
3683   int table_size;
3684   bfd_vma *table_handlers;
3685   bfd_vma table_default_handler;
3686   struct bfd_link_hash_entry **table_entries;
3687   struct bfd_link_hash_entry *table_default_entry;
3688   FILE *mapfile;
3689 } RX_Table_Info;
3690
3691 static bfd_boolean
3692 rx_table_find (struct bfd_hash_entry *vent, void *vinfo)
3693 {
3694   RX_Table_Info *info = (RX_Table_Info *)vinfo;
3695   struct bfd_link_hash_entry *ent = (struct bfd_link_hash_entry *)vent;
3696   const char *name; /* of the symbol we've found */
3697   asection *sec;
3698   struct bfd *abfd;
3699   int idx;
3700   const char *tname; /* name of the table */
3701   bfd_vma start_addr, end_addr;
3702   char *buf;
3703   struct bfd_link_hash_entry * h;
3704
3705   /* We're looking for globally defined symbols of the form
3706      $tablestart$<NAME>.  */
3707   if (ent->type != bfd_link_hash_defined
3708       && ent->type != bfd_link_hash_defweak)
3709     return TRUE;
3710
3711   name = ent->root.string;
3712   sec = ent->u.def.section;
3713   abfd = sec->owner;
3714
3715   if (strncmp (name, "$tablestart$", 12))
3716     return TRUE;
3717
3718   sec->flags |= SEC_KEEP;
3719
3720   tname = name + 12;
3721
3722   start_addr = ent->u.def.value;
3723
3724   /* At this point, we can't build the table but we can (and must)
3725      find all the related symbols and mark their sections as SEC_KEEP
3726      so we don't garbage collect them.  */
3727
3728   buf = (char *) malloc (12 + 10 + strlen (tname));
3729
3730   sprintf (buf, "$tableend$%s", tname);
3731   h = bfd_link_hash_lookup (info->info->hash, buf, FALSE, FALSE, TRUE);
3732   if (!h || (h->type != bfd_link_hash_defined
3733              && h->type != bfd_link_hash_defweak))
3734     {
3735       _bfd_error_handler (_("%B:%A: table %s missing corresponding %s"),
3736                           abfd, sec, name, buf);
3737       return TRUE;
3738     }
3739
3740   if (h->u.def.section != ent->u.def.section)
3741     {
3742       _bfd_error_handler (_("%B:%A: %s and %s must be in the same input section"),
3743                           h->u.def.section->owner, h->u.def.section,
3744                           name, buf);
3745       return TRUE;
3746     }
3747
3748   end_addr = h->u.def.value;
3749
3750   sprintf (buf, "$tableentry$default$%s", tname);
3751   h = bfd_link_hash_lookup (info->info->hash, buf, FALSE, FALSE, TRUE);
3752   if (h && (h->type == bfd_link_hash_defined
3753             || h->type == bfd_link_hash_defweak))
3754     {
3755       h->u.def.section->flags |= SEC_KEEP;
3756     }
3757
3758   for (idx = 0; idx < (int) (end_addr - start_addr) / 4; idx ++)
3759     {
3760       sprintf (buf, "$tableentry$%d$%s", idx, tname);
3761       h = bfd_link_hash_lookup (info->info->hash, buf, FALSE, FALSE, TRUE);
3762       if (h && (h->type == bfd_link_hash_defined
3763                 || h->type == bfd_link_hash_defweak))
3764         {
3765           h->u.def.section->flags |= SEC_KEEP;
3766         }
3767     }
3768
3769   /* Return TRUE to keep scanning, FALSE to end the traversal.  */
3770   return TRUE;
3771 }
3772
3773 /* We need to check for table entry symbols and build the tables, and
3774    we need to do it before the linker does garbage collection.  This function is
3775    called once per input object file.  */
3776 static bfd_boolean
3777 rx_check_directives
3778     (bfd *                     abfd ATTRIBUTE_UNUSED,
3779      struct bfd_link_info *    info ATTRIBUTE_UNUSED)
3780 {
3781   RX_Table_Info stuff;
3782
3783   stuff.abfd = abfd;
3784   stuff.info = info;
3785   bfd_hash_traverse (&(info->hash->table), rx_table_find, &stuff);
3786
3787   return TRUE;
3788 }
3789
3790 \f
3791 static bfd_boolean
3792 rx_table_map_2 (struct bfd_hash_entry *vent, void *vinfo)
3793 {
3794   RX_Table_Info *info = (RX_Table_Info *)vinfo;
3795   struct bfd_link_hash_entry *ent = (struct bfd_link_hash_entry *)vent;
3796   int idx;
3797   const char *name;
3798   bfd_vma addr;
3799
3800   /* See if the symbol ENT has an address listed in the table, and
3801      isn't a debug/special symbol.  If so, put it in the table.  */
3802
3803   if (ent->type != bfd_link_hash_defined
3804       && ent->type != bfd_link_hash_defweak)
3805     return TRUE;
3806
3807   name = ent->root.string;
3808
3809   if (name[0] == '$' || name[0] == '.' || name[0] < ' ')
3810     return TRUE;
3811
3812   addr = (ent->u.def.value
3813           + ent->u.def.section->output_section->vma
3814           + ent->u.def.section->output_offset);
3815
3816   for (idx = 0; idx < info->table_size; idx ++)
3817     if (addr == info->table_handlers[idx])
3818       info->table_entries[idx] = ent;
3819
3820   if (addr == info->table_default_handler)
3821     info->table_default_entry = ent;
3822
3823   return TRUE;
3824 }
3825
3826 static bfd_boolean
3827 rx_table_map (struct bfd_hash_entry *vent, void *vinfo)
3828 {
3829   RX_Table_Info *info = (RX_Table_Info *)vinfo;
3830   struct bfd_link_hash_entry *ent = (struct bfd_link_hash_entry *)vent;
3831   const char *name; /* of the symbol we've found */
3832   int idx;
3833   const char *tname; /* name of the table */
3834   bfd_vma start_addr, end_addr;
3835   char *buf;
3836   struct bfd_link_hash_entry * h;
3837   int need_elipses;
3838
3839   /* We're looking for globally defined symbols of the form
3840      $tablestart$<NAME>.  */
3841   if (ent->type != bfd_link_hash_defined
3842       && ent->type != bfd_link_hash_defweak)
3843     return TRUE;
3844
3845   name = ent->root.string;
3846
3847   if (strncmp (name, "$tablestart$", 12))
3848     return TRUE;
3849
3850   tname = name + 12;
3851   start_addr = (ent->u.def.value
3852                 + ent->u.def.section->output_section->vma
3853                 + ent->u.def.section->output_offset);
3854
3855   buf = (char *) malloc (12 + 10 + strlen (tname));
3856
3857   sprintf (buf, "$tableend$%s", tname);
3858   end_addr = get_symbol_value_maybe (buf, info->info);
3859
3860   sprintf (buf, "$tableentry$default$%s", tname);
3861   h = bfd_link_hash_lookup (info->info->hash, buf, FALSE, FALSE, TRUE);
3862   if (h)
3863     {
3864       info->table_default_handler = (h->u.def.value
3865                                      + h->u.def.section->output_section->vma
3866                                      + h->u.def.section->output_offset);
3867     }
3868   else
3869     /* Zero is a valid handler address!  */
3870     info->table_default_handler = (bfd_vma) (-1);
3871   info->table_default_entry = NULL;
3872
3873   info->table_start = start_addr;
3874   info->table_size = (int) (end_addr - start_addr) / 4;
3875   info->table_handlers = (bfd_vma *) malloc (info->table_size * sizeof (bfd_vma));
3876   info->table_entries = (struct bfd_link_hash_entry **) malloc (info->table_size * sizeof (struct bfd_link_hash_entry));
3877
3878   for (idx = 0; idx < (int) (end_addr - start_addr) / 4; idx ++)
3879     {
3880       sprintf (buf, "$tableentry$%d$%s", idx, tname);
3881       h = bfd_link_hash_lookup (info->info->hash, buf, FALSE, FALSE, TRUE);
3882       if (h && (h->type == bfd_link_hash_defined
3883                 || h->type == bfd_link_hash_defweak))
3884         {
3885           info->table_handlers[idx] = (h->u.def.value
3886                                        + h->u.def.section->output_section->vma
3887                                        + h->u.def.section->output_offset);
3888         }
3889       else
3890         info->table_handlers[idx] = info->table_default_handler;
3891       info->table_entries[idx] = NULL;
3892     }
3893
3894   free (buf);
3895
3896   bfd_hash_traverse (&(info->info->hash->table), rx_table_map_2, info);
3897
3898   fprintf (info->mapfile, "\nRX Vector Table: %s has %d entries at 0x%08" BFD_VMA_FMT "x\n\n",
3899            tname, info->table_size, start_addr);
3900
3901   if (info->table_default_entry)
3902     fprintf (info->mapfile, "  default handler is: %s at 0x%08" BFD_VMA_FMT "x\n",
3903              info->table_default_entry->root.string,
3904              info->table_default_handler);
3905   else if (info->table_default_handler != (bfd_vma)(-1))
3906     fprintf (info->mapfile, "  default handler is at 0x%08" BFD_VMA_FMT "x\n",
3907              info->table_default_handler);
3908   else
3909     fprintf (info->mapfile, "  no default handler\n");
3910
3911   need_elipses = 1;
3912   for (idx = 0; idx < info->table_size; idx ++)
3913     {
3914       if (info->table_handlers[idx] == info->table_default_handler)
3915         {
3916           if (need_elipses)
3917             fprintf (info->mapfile, "  . . .\n");
3918           need_elipses = 0;
3919           continue;
3920         }
3921       need_elipses = 1;
3922
3923       fprintf (info->mapfile, "  0x%08" BFD_VMA_FMT "x [%3d] ", start_addr + 4 * idx, idx);
3924
3925       if (info->table_handlers[idx] == (bfd_vma) (-1))
3926         fprintf (info->mapfile, "(no handler found)\n");
3927
3928       else if (info->table_handlers[idx] == info->table_default_handler)
3929         {
3930           if (info->table_default_entry)
3931             fprintf (info->mapfile, "(default)\n");
3932           else
3933             fprintf (info->mapfile, "(default)\n");
3934         }
3935
3936       else if (info->table_entries[idx])
3937         {
3938           fprintf (info->mapfile, "0x%08" BFD_VMA_FMT "x %s\n", info->table_handlers[idx], info->table_entries[idx]->root.string);
3939         }
3940
3941       else
3942         {
3943           fprintf (info->mapfile, "0x%08" BFD_VMA_FMT "x ???\n", info->table_handlers[idx]);
3944         }
3945     }
3946   if (need_elipses)
3947     fprintf (info->mapfile, "  . . .\n");
3948
3949   return TRUE;
3950 }
3951
3952 void
3953 rx_additional_link_map_text (bfd *obfd, struct bfd_link_info *info, FILE *mapfile)
3954 {
3955   /* We scan the symbol table looking for $tableentry$'s, and for
3956      each, try to deduce which handlers go with which entries.  */
3957
3958   RX_Table_Info stuff;
3959
3960   stuff.abfd = obfd;
3961   stuff.info = info;
3962   stuff.mapfile = mapfile;
3963   bfd_hash_traverse (&(info->hash->table), rx_table_map, &stuff);
3964 }
3965
3966 \f
3967 #define ELF_ARCH                bfd_arch_rx
3968 #define ELF_MACHINE_CODE        EM_RX
3969 #define ELF_MAXPAGESIZE         0x1000
3970
3971 #define TARGET_BIG_SYM          rx_elf32_be_vec
3972 #define TARGET_BIG_NAME         "elf32-rx-be"
3973
3974 #define TARGET_LITTLE_SYM       rx_elf32_le_vec
3975 #define TARGET_LITTLE_NAME      "elf32-rx-le"
3976
3977 #define elf_info_to_howto_rel                   NULL
3978 #define elf_info_to_howto                       rx_info_to_howto_rela
3979 #define elf_backend_object_p                    rx_elf_object_p
3980 #define elf_backend_relocate_section            rx_elf_relocate_section
3981 #define elf_symbol_leading_char                 ('_')
3982 #define elf_backend_can_gc_sections             1
3983 #define elf_backend_modify_program_headers      elf32_rx_modify_program_headers
3984
3985 #define bfd_elf32_bfd_reloc_type_lookup         rx_reloc_type_lookup
3986 #define bfd_elf32_bfd_reloc_name_lookup         rx_reloc_name_lookup
3987 #define bfd_elf32_bfd_set_private_flags         rx_elf_set_private_flags
3988 #define bfd_elf32_bfd_merge_private_bfd_data    rx_elf_merge_private_bfd_data
3989 #define bfd_elf32_bfd_print_private_bfd_data    rx_elf_print_private_bfd_data
3990 #define bfd_elf32_get_section_contents          rx_get_section_contents
3991 #define bfd_elf32_set_section_contents          rx_set_section_contents
3992 #define bfd_elf32_bfd_final_link                rx_final_link
3993 #define bfd_elf32_bfd_relax_section             elf32_rx_relax_section_wrapper
3994 #define elf_backend_special_sections            elf32_rx_special_sections
3995 #define elf_backend_check_directives            rx_check_directives
3996
3997 #include "elf32-target.h"
3998
3999 /* We define a second big-endian target that doesn't have the custom
4000    section get/set hooks, for times when we want to preserve the
4001    pre-swapped .text sections (like objcopy).  */
4002
4003 #undef  TARGET_BIG_SYM
4004 #define TARGET_BIG_SYM          rx_elf32_be_ns_vec
4005 #undef  TARGET_BIG_NAME
4006 #define TARGET_BIG_NAME         "elf32-rx-be-ns"
4007 #undef  TARGET_LITTLE_SYM
4008
4009 #undef bfd_elf32_get_section_contents
4010 #undef bfd_elf32_set_section_contents
4011
4012 #undef  elf32_bed
4013 #define elf32_bed                               elf32_rx_be_ns_bed
4014
4015 #include "elf32-target.h"