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