bfd/elf32-rx.c

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