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