bfd/elf32-rx.c

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