?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
opcodes: handle mach-o for thumb/arm disambiguation.
[binutils-gdb.git] / bfd / elf32-rx.c
blobc58c184fd197986cdf31e0da4109ee568761eb56
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 (bfd_link_relocatable (info))
636 {
637 /* This is a relocatable link. We don't have to change
638 anything, unless the reloc is against a section symbol,
639 in which case we have to adjust according to where the
640 section symbol winds up in the output section. */
641 if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
642 rel->r_addend += sec->output_offset;
643 continue;
644 }
645
646 if (h != NULL && h->root.type == bfd_link_hash_undefweak)
647 /* If the symbol is undefined and weak
648 then the relocation resolves to zero. */
649 relocation = 0;
650 else
651 {
652 if (howto->pc_relative)
653 {
654 relocation -= (input_section->output_section->vma
655 + input_section->output_offset
656 + rel->r_offset);
657 if (r_type != R_RX_RH_3_PCREL
658 && r_type != R_RX_DIR3U_PCREL)
659 relocation ++;
660 }
661
662 relocation += rel->r_addend;
663 }
664
665 r = bfd_reloc_ok;
666
667 #define RANGE(a,b) if (a > (long) relocation || (long) relocation > b) r = bfd_reloc_overflow
668 #define ALIGN(m) if (relocation & m) r = bfd_reloc_other;
669 #define OP(i) (contents[rel->r_offset + (i)])
670 #define WARN_REDHAT(type) \
671 _bfd_error_handler (_("%B:%A: Warning: deprecated Red Hat reloc " type " detected against: %s."), \
672 input_bfd, input_section, name)
673
674 /* Check for unsafe relocs in PID mode. These are any relocs where
675 an absolute address is being computed. There are special cases
676 for relocs against symbols that are known to be referenced in
677 crt0.o before the PID base address register has been initialised. */
678 #define UNSAFE_FOR_PID \
679 do \
680 { \
681 if (pid_mode \
682 && sec != NULL \
683 && sec->flags & SEC_READONLY \
684 && !(input_section->flags & SEC_DEBUGGING) \
685 && strcmp (name, "__pid_base") != 0 \
686 && strcmp (name, "__gp") != 0 \
687 && strcmp (name, "__romdatastart") != 0 \
688 && !saw_subtract) \
689 _bfd_error_handler (_("%B(%A): unsafe PID relocation %s at 0x%08lx (against %s in %s)"), \
690 input_bfd, input_section, howto->name, \
691 input_section->output_section->vma + input_section->output_offset + rel->r_offset, \
692 name, sec->name); \
693 } \
694 while (0)
695
696 /* Opcode relocs are always big endian. Data relocs are bi-endian. */
697 switch (r_type)
698 {
699 case R_RX_NONE:
700 break;
701
702 case R_RX_RH_RELAX:
703 break;
704
705 case R_RX_RH_3_PCREL:
706 WARN_REDHAT ("RX_RH_3_PCREL");
707 RANGE (3, 10);
708 OP (0) &= 0xf8;
709 OP (0) |= relocation & 0x07;
710 break;
711
712 case R_RX_RH_8_NEG:
713 WARN_REDHAT ("RX_RH_8_NEG");
714 relocation = - relocation;
715 case R_RX_DIR8S_PCREL:
716 UNSAFE_FOR_PID;
717 RANGE (-128, 127);
718 OP (0) = relocation;
719 break;
720
721 case R_RX_DIR8S:
722 UNSAFE_FOR_PID;
723 RANGE (-128, 255);
724 OP (0) = relocation;
725 break;
726
727 case R_RX_DIR8U:
728 UNSAFE_FOR_PID;
729 RANGE (0, 255);
730 OP (0) = relocation;
731 break;
732
733 case R_RX_RH_16_NEG:
734 WARN_REDHAT ("RX_RH_16_NEG");
735 relocation = - relocation;
736 case R_RX_DIR16S_PCREL:
737 UNSAFE_FOR_PID;
738 RANGE (-32768, 32767);
739 #if RX_OPCODE_BIG_ENDIAN
740 #else
741 OP (0) = relocation;
742 OP (1) = relocation >> 8;
743 #endif
744 break;
745
746 case R_RX_RH_16_OP:
747 WARN_REDHAT ("RX_RH_16_OP");
748 UNSAFE_FOR_PID;
749 RANGE (-32768, 32767);
750 #if RX_OPCODE_BIG_ENDIAN
751 OP (1) = relocation;
752 OP (0) = relocation >> 8;
753 #else
754 OP (0) = relocation;
755 OP (1) = relocation >> 8;
756 #endif
757 break;
758
759 case R_RX_DIR16S:
760 UNSAFE_FOR_PID;
761 RANGE (-32768, 65535);
762 if (BIGE (output_bfd) && !(input_section->flags & SEC_CODE))
763 {
764 OP (1) = relocation;
765 OP (0) = relocation >> 8;
766 }
767 else
768 {
769 OP (0) = relocation;
770 OP (1) = relocation >> 8;
771 }
772 break;
773
774 case R_RX_DIR16U:
775 UNSAFE_FOR_PID;
776 RANGE (0, 65536);
777 #if RX_OPCODE_BIG_ENDIAN
778 OP (1) = relocation;
779 OP (0) = relocation >> 8;
780 #else
781 OP (0) = relocation;
782 OP (1) = relocation >> 8;
783 #endif
784 break;
785
786 case R_RX_DIR16:
787 UNSAFE_FOR_PID;
788 RANGE (-32768, 65536);
789 #if RX_OPCODE_BIG_ENDIAN
790 OP (1) = relocation;
791 OP (0) = relocation >> 8;
792 #else
793 OP (0) = relocation;
794 OP (1) = relocation >> 8;
795 #endif
796 break;
797
798 case R_RX_DIR16_REV:
799 UNSAFE_FOR_PID;
800 RANGE (-32768, 65536);
801 #if RX_OPCODE_BIG_ENDIAN
802 OP (0) = relocation;
803 OP (1) = relocation >> 8;
804 #else
805 OP (1) = relocation;
806 OP (0) = relocation >> 8;
807 #endif
808 break;
809
810 case R_RX_DIR3U_PCREL:
811 RANGE (3, 10);
812 OP (0) &= 0xf8;
813 OP (0) |= relocation & 0x07;
814 break;
815
816 case R_RX_RH_24_NEG:
817 UNSAFE_FOR_PID;
818 WARN_REDHAT ("RX_RH_24_NEG");
819 relocation = - relocation;
820 case R_RX_DIR24S_PCREL:
821 RANGE (-0x800000, 0x7fffff);
822 #if RX_OPCODE_BIG_ENDIAN
823 OP (2) = relocation;
824 OP (1) = relocation >> 8;
825 OP (0) = relocation >> 16;
826 #else
827 OP (0) = relocation;
828 OP (1) = relocation >> 8;
829 OP (2) = relocation >> 16;
830 #endif
831 break;
832
833 case R_RX_RH_24_OP:
834 UNSAFE_FOR_PID;
835 WARN_REDHAT ("RX_RH_24_OP");
836 RANGE (-0x800000, 0x7fffff);
837 #if RX_OPCODE_BIG_ENDIAN
838 OP (2) = relocation;
839 OP (1) = relocation >> 8;
840 OP (0) = relocation >> 16;
841 #else
842 OP (0) = relocation;
843 OP (1) = relocation >> 8;
844 OP (2) = relocation >> 16;
845 #endif
846 break;
847
848 case R_RX_DIR24S:
849 UNSAFE_FOR_PID;
850 RANGE (-0x800000, 0x7fffff);
851 if (BIGE (output_bfd) && !(input_section->flags & SEC_CODE))
852 {
853 OP (2) = relocation;
854 OP (1) = relocation >> 8;
855 OP (0) = relocation >> 16;
856 }
857 else
858 {
859 OP (0) = relocation;
860 OP (1) = relocation >> 8;
861 OP (2) = relocation >> 16;
862 }
863 break;
864
865 case R_RX_RH_24_UNS:
866 UNSAFE_FOR_PID;
867 WARN_REDHAT ("RX_RH_24_UNS");
868 RANGE (0, 0xffffff);
869 #if RX_OPCODE_BIG_ENDIAN
870 OP (2) = relocation;
871 OP (1) = relocation >> 8;
872 OP (0) = relocation >> 16;
873 #else
874 OP (0) = relocation;
875 OP (1) = relocation >> 8;
876 OP (2) = relocation >> 16;
877 #endif
878 break;
879
880 case R_RX_RH_32_NEG:
881 UNSAFE_FOR_PID;
882 WARN_REDHAT ("RX_RH_32_NEG");
883 relocation = - relocation;
884 #if RX_OPCODE_BIG_ENDIAN
885 OP (3) = relocation;
886 OP (2) = relocation >> 8;
887 OP (1) = relocation >> 16;
888 OP (0) = relocation >> 24;
889 #else
890 OP (0) = relocation;
891 OP (1) = relocation >> 8;
892 OP (2) = relocation >> 16;
893 OP (3) = relocation >> 24;
894 #endif
895 break;
896
897 case R_RX_RH_32_OP:
898 UNSAFE_FOR_PID;
899 WARN_REDHAT ("RX_RH_32_OP");
900 #if RX_OPCODE_BIG_ENDIAN
901 OP (3) = relocation;
902 OP (2) = relocation >> 8;
903 OP (1) = relocation >> 16;
904 OP (0) = relocation >> 24;
905 #else
906 OP (0) = relocation;
907 OP (1) = relocation >> 8;
908 OP (2) = relocation >> 16;
909 OP (3) = relocation >> 24;
910 #endif
911 break;
912
913 case R_RX_DIR32:
914 if (BIGE (output_bfd) && !(input_section->flags & SEC_CODE))
915 {
916 OP (3) = relocation;
917 OP (2) = relocation >> 8;
918 OP (1) = relocation >> 16;
919 OP (0) = relocation >> 24;
920 }
921 else
922 {
923 OP (0) = relocation;
924 OP (1) = relocation >> 8;
925 OP (2) = relocation >> 16;
926 OP (3) = relocation >> 24;
927 }
928 break;
929
930 case R_RX_DIR32_REV:
931 if (BIGE (output_bfd))
932 {
933 OP (0) = relocation;
934 OP (1) = relocation >> 8;
935 OP (2) = relocation >> 16;
936 OP (3) = relocation >> 24;
937 }
938 else
939 {
940 OP (3) = relocation;
941 OP (2) = relocation >> 8;
942 OP (1) = relocation >> 16;
943 OP (0) = relocation >> 24;
944 }
945 break;
946
947 case R_RX_RH_DIFF:
948 {
949 bfd_vma val;
950 WARN_REDHAT ("RX_RH_DIFF");
951 val = bfd_get_32 (output_bfd, & OP (0));
952 val -= relocation;
953 bfd_put_32 (output_bfd, val, & OP (0));
954 }
955 break;
956
957 case R_RX_RH_GPRELB:
958 WARN_REDHAT ("RX_RH_GPRELB");
959 relocation -= get_gp (&r, info, input_bfd, input_section, rel->r_offset);
960 RANGE (0, 65535);
961 #if RX_OPCODE_BIG_ENDIAN
962 OP (1) = relocation;
963 OP (0) = relocation >> 8;
964 #else
965 OP (0) = relocation;
966 OP (1) = relocation >> 8;
967 #endif
968 break;
969
970 case R_RX_RH_GPRELW:
971 WARN_REDHAT ("RX_RH_GPRELW");
972 relocation -= get_gp (&r, info, input_bfd, input_section, rel->r_offset);
973 ALIGN (1);
974 relocation >>= 1;
975 RANGE (0, 65535);
976 #if RX_OPCODE_BIG_ENDIAN
977 OP (1) = relocation;
978 OP (0) = relocation >> 8;
979 #else
980 OP (0) = relocation;
981 OP (1) = relocation >> 8;
982 #endif
983 break;
984
985 case R_RX_RH_GPRELL:
986 WARN_REDHAT ("RX_RH_GPRELL");
987 relocation -= get_gp (&r, info, input_bfd, input_section, rel->r_offset);
988 ALIGN (3);
989 relocation >>= 2;
990 RANGE (0, 65535);
991 #if RX_OPCODE_BIG_ENDIAN
992 OP (1) = relocation;
993 OP (0) = relocation >> 8;
994 #else
995 OP (0) = relocation;
996 OP (1) = relocation >> 8;
997 #endif
998 break;
999
1000 /* Internal relocations just for relaxation: */
1001 case R_RX_RH_ABS5p5B:
1002 RX_STACK_POP (relocation);
1003 RANGE (0, 31);
1004 OP (0) &= 0xf8;
1005 OP (0) |= relocation >> 2;
1006 OP (1) &= 0x77;
1007 OP (1) |= (relocation << 6) & 0x80;
1008 OP (1) |= (relocation << 3) & 0x08;
1009 break;
1010
1011 case R_RX_RH_ABS5p5W:
1012 RX_STACK_POP (relocation);
1013 RANGE (0, 62);
1014 ALIGN (1);
1015 relocation >>= 1;
1016 OP (0) &= 0xf8;
1017 OP (0) |= relocation >> 2;
1018 OP (1) &= 0x77;
1019 OP (1) |= (relocation << 6) & 0x80;
1020 OP (1) |= (relocation << 3) & 0x08;
1021 break;
1022
1023 case R_RX_RH_ABS5p5L:
1024 RX_STACK_POP (relocation);
1025 RANGE (0, 124);
1026 ALIGN (3);
1027 relocation >>= 2;
1028 OP (0) &= 0xf8;
1029 OP (0) |= relocation >> 2;
1030 OP (1) &= 0x77;
1031 OP (1) |= (relocation << 6) & 0x80;
1032 OP (1) |= (relocation << 3) & 0x08;
1033 break;
1034
1035 case R_RX_RH_ABS5p8B:
1036 RX_STACK_POP (relocation);
1037 RANGE (0, 31);
1038 OP (0) &= 0x70;
1039 OP (0) |= (relocation << 3) & 0x80;
1040 OP (0) |= relocation & 0x0f;
1041 break;
1042
1043 case R_RX_RH_ABS5p8W:
1044 RX_STACK_POP (relocation);
1045 RANGE (0, 62);
1046 ALIGN (1);
1047 relocation >>= 1;
1048 OP (0) &= 0x70;
1049 OP (0) |= (relocation << 3) & 0x80;
1050 OP (0) |= relocation & 0x0f;
1051 break;
1052
1053 case R_RX_RH_ABS5p8L:
1054 RX_STACK_POP (relocation);
1055 RANGE (0, 124);
1056 ALIGN (3);
1057 relocation >>= 2;
1058 OP (0) &= 0x70;
1059 OP (0) |= (relocation << 3) & 0x80;
1060 OP (0) |= relocation & 0x0f;
1061 break;
1062
1063 case R_RX_RH_UIMM4p8:
1064 RANGE (0, 15);
1065 OP (0) &= 0x0f;
1066 OP (0) |= relocation << 4;
1067 break;
1068
1069 case R_RX_RH_UNEG4p8:
1070 RANGE (-15, 0);
1071 OP (0) &= 0x0f;
1072 OP (0) |= (-relocation) << 4;
1073 break;
1074
1075 /* Complex reloc handling: */
1076
1077 case R_RX_ABS32:
1078 UNSAFE_FOR_PID;
1079 RX_STACK_POP (relocation);
1080 #if RX_OPCODE_BIG_ENDIAN
1081 OP (3) = relocation;
1082 OP (2) = relocation >> 8;
1083 OP (1) = relocation >> 16;
1084 OP (0) = relocation >> 24;
1085 #else
1086 OP (0) = relocation;
1087 OP (1) = relocation >> 8;
1088 OP (2) = relocation >> 16;
1089 OP (3) = relocation >> 24;
1090 #endif
1091 break;
1092
1093 case R_RX_ABS32_REV:
1094 UNSAFE_FOR_PID;
1095 RX_STACK_POP (relocation);
1096 #if RX_OPCODE_BIG_ENDIAN
1097 OP (0) = relocation;
1098 OP (1) = relocation >> 8;
1099 OP (2) = relocation >> 16;
1100 OP (3) = relocation >> 24;
1101 #else
1102 OP (3) = relocation;
1103 OP (2) = relocation >> 8;
1104 OP (1) = relocation >> 16;
1105 OP (0) = relocation >> 24;
1106 #endif
1107 break;
1108
1109 case R_RX_ABS24S_PCREL:
1110 case R_RX_ABS24S:
1111 UNSAFE_FOR_PID;
1112 RX_STACK_POP (relocation);
1113 RANGE (-0x800000, 0x7fffff);
1114 if (BIGE (output_bfd) && !(input_section->flags & SEC_CODE))
1115 {
1116 OP (2) = relocation;
1117 OP (1) = relocation >> 8;
1118 OP (0) = relocation >> 16;
1119 }
1120 else
1121 {
1122 OP (0) = relocation;
1123 OP (1) = relocation >> 8;
1124 OP (2) = relocation >> 16;
1125 }
1126 break;
1127
1128 case R_RX_ABS16:
1129 UNSAFE_FOR_PID;
1130 RX_STACK_POP (relocation);
1131 RANGE (-32768, 65535);
1132 #if RX_OPCODE_BIG_ENDIAN
1133 OP (1) = relocation;
1134 OP (0) = relocation >> 8;
1135 #else
1136 OP (0) = relocation;
1137 OP (1) = relocation >> 8;
1138 #endif
1139 break;
1140
1141 case R_RX_ABS16_REV:
1142 UNSAFE_FOR_PID;
1143 RX_STACK_POP (relocation);
1144 RANGE (-32768, 65535);
1145 #if RX_OPCODE_BIG_ENDIAN
1146 OP (0) = relocation;
1147 OP (1) = relocation >> 8;
1148 #else
1149 OP (1) = relocation;
1150 OP (0) = relocation >> 8;
1151 #endif
1152 break;
1153
1154 case R_RX_ABS16S_PCREL:
1155 case R_RX_ABS16S:
1156 RX_STACK_POP (relocation);
1157 RANGE (-32768, 32767);
1158 if (BIGE (output_bfd) && !(input_section->flags & SEC_CODE))
1159 {
1160 OP (1) = relocation;
1161 OP (0) = relocation >> 8;
1162 }
1163 else
1164 {
1165 OP (0) = relocation;
1166 OP (1) = relocation >> 8;
1167 }
1168 break;
1169
1170 case R_RX_ABS16U:
1171 UNSAFE_FOR_PID;
1172 RX_STACK_POP (relocation);
1173 RANGE (0, 65536);
1174 #if RX_OPCODE_BIG_ENDIAN
1175 OP (1) = relocation;
1176 OP (0) = relocation >> 8;
1177 #else
1178 OP (0) = relocation;
1179 OP (1) = relocation >> 8;
1180 #endif
1181 break;
1182
1183 case R_RX_ABS16UL:
1184 UNSAFE_FOR_PID;
1185 RX_STACK_POP (relocation);
1186 relocation >>= 2;
1187 RANGE (0, 65536);
1188 #if RX_OPCODE_BIG_ENDIAN
1189 OP (1) = relocation;
1190 OP (0) = relocation >> 8;
1191 #else
1192 OP (0) = relocation;
1193 OP (1) = relocation >> 8;
1194 #endif
1195 break;
1196
1197 case R_RX_ABS16UW:
1198 UNSAFE_FOR_PID;
1199 RX_STACK_POP (relocation);
1200 relocation >>= 1;
1201 RANGE (0, 65536);
1202 #if RX_OPCODE_BIG_ENDIAN
1203 OP (1) = relocation;
1204 OP (0) = relocation >> 8;
1205 #else
1206 OP (0) = relocation;
1207 OP (1) = relocation >> 8;
1208 #endif
1209 break;
1210
1211 case R_RX_ABS8:
1212 UNSAFE_FOR_PID;
1213 RX_STACK_POP (relocation);
1214 RANGE (-128, 255);
1215 OP (0) = relocation;
1216 break;
1217
1218 case R_RX_ABS8U:
1219 UNSAFE_FOR_PID;
1220 RX_STACK_POP (relocation);
1221 RANGE (0, 255);
1222 OP (0) = relocation;
1223 break;
1224
1225 case R_RX_ABS8UL:
1226 UNSAFE_FOR_PID;
1227 RX_STACK_POP (relocation);
1228 relocation >>= 2;
1229 RANGE (0, 255);
1230 OP (0) = relocation;
1231 break;
1232
1233 case R_RX_ABS8UW:
1234 UNSAFE_FOR_PID;
1235 RX_STACK_POP (relocation);
1236 relocation >>= 1;
1237 RANGE (0, 255);
1238 OP (0) = relocation;
1239 break;
1240
1241 case R_RX_ABS8S:
1242 UNSAFE_FOR_PID;
1243 case R_RX_ABS8S_PCREL:
1244 RX_STACK_POP (relocation);
1245 RANGE (-128, 127);
1246 OP (0) = relocation;
1247 break;
1248
1249 case R_RX_SYM:
1250 if (r_symndx < symtab_hdr->sh_info)
1251 RX_STACK_PUSH (sec->output_section->vma
1252 + sec->output_offset
1253 + sym->st_value
1254 + rel->r_addend);
1255 else
1256 {
1257 if (h != NULL
1258 && (h->root.type == bfd_link_hash_defined
1259 || h->root.type == bfd_link_hash_defweak))
1260 RX_STACK_PUSH (h->root.u.def.value
1261 + sec->output_section->vma
1262 + sec->output_offset
1263 + rel->r_addend);
1264 else
1265 _bfd_error_handler (_("Warning: RX_SYM reloc with an unknown symbol"));
1266 }
1267 break;
1268
1269 case R_RX_OPneg:
1270 {
1271 int32_t tmp;
1272
1273 saw_subtract = TRUE;
1274 RX_STACK_POP (tmp);
1275 tmp = - tmp;
1276 RX_STACK_PUSH (tmp);
1277 }
1278 break;
1279
1280 case R_RX_OPadd:
1281 {
1282 int32_t tmp1, tmp2;
1283
1284 RX_STACK_POP (tmp1);
1285 RX_STACK_POP (tmp2);
1286 tmp1 += tmp2;
1287 RX_STACK_PUSH (tmp1);
1288 }
1289 break;
1290
1291 case R_RX_OPsub:
1292 {
1293 int32_t tmp1, tmp2;
1294
1295 saw_subtract = TRUE;
1296 RX_STACK_POP (tmp1);
1297 RX_STACK_POP (tmp2);
1298 tmp2 -= tmp1;
1299 RX_STACK_PUSH (tmp2);
1300 }
1301 break;
1302
1303 case R_RX_OPmul:
1304 {
1305 int32_t tmp1, tmp2;
1306
1307 RX_STACK_POP (tmp1);
1308 RX_STACK_POP (tmp2);
1309 tmp1 *= tmp2;
1310 RX_STACK_PUSH (tmp1);
1311 }
1312 break;
1313
1314 case R_RX_OPdiv:
1315 {
1316 int32_t tmp1, tmp2;
1317
1318 RX_STACK_POP (tmp1);
1319 RX_STACK_POP (tmp2);
1320 tmp1 /= tmp2;
1321 RX_STACK_PUSH (tmp1);
1322 }
1323 break;
1324
1325 case R_RX_OPshla:
1326 {
1327 int32_t tmp1, tmp2;
1328
1329 RX_STACK_POP (tmp1);
1330 RX_STACK_POP (tmp2);
1331 tmp1 <<= tmp2;
1332 RX_STACK_PUSH (tmp1);
1333 }
1334 break;
1335
1336 case R_RX_OPshra:
1337 {
1338 int32_t tmp1, tmp2;
1339
1340 RX_STACK_POP (tmp1);
1341 RX_STACK_POP (tmp2);
1342 tmp1 >>= tmp2;
1343 RX_STACK_PUSH (tmp1);
1344 }
1345 break;
1346
1347 case R_RX_OPsctsize:
1348 RX_STACK_PUSH (input_section->size);
1349 break;
1350
1351 case R_RX_OPscttop:
1352 RX_STACK_PUSH (input_section->output_section->vma);
1353 break;
1354
1355 case R_RX_OPand:
1356 {
1357 int32_t tmp1, tmp2;
1358
1359 RX_STACK_POP (tmp1);
1360 RX_STACK_POP (tmp2);
1361 tmp1 &= tmp2;
1362 RX_STACK_PUSH (tmp1);
1363 }
1364 break;
1365
1366 case R_RX_OPor:
1367 {
1368 int32_t tmp1, tmp2;
1369
1370 RX_STACK_POP (tmp1);
1371 RX_STACK_POP (tmp2);
1372 tmp1 |= tmp2;
1373 RX_STACK_PUSH (tmp1);
1374 }
1375 break;
1376
1377 case R_RX_OPxor:
1378 {
1379 int32_t tmp1, tmp2;
1380
1381 RX_STACK_POP (tmp1);
1382 RX_STACK_POP (tmp2);
1383 tmp1 ^= tmp2;
1384 RX_STACK_PUSH (tmp1);
1385 }
1386 break;
1387
1388 case R_RX_OPnot:
1389 {
1390 int32_t tmp;
1391
1392 RX_STACK_POP (tmp);
1393 tmp = ~ tmp;
1394 RX_STACK_PUSH (tmp);
1395 }
1396 break;
1397
1398 case R_RX_OPmod:
1399 {
1400 int32_t tmp1, tmp2;
1401
1402 RX_STACK_POP (tmp1);
1403 RX_STACK_POP (tmp2);
1404 tmp1 %= tmp2;
1405 RX_STACK_PUSH (tmp1);
1406 }
1407 break;
1408
1409 case R_RX_OPromtop:
1410 RX_STACK_PUSH (get_romstart (&r, info, input_bfd, input_section, rel->r_offset));
1411 break;
1412
1413 case R_RX_OPramtop:
1414 RX_STACK_PUSH (get_ramstart (&r, info, input_bfd, input_section, rel->r_offset));
1415 break;
1416
1417 default:
1418 r = bfd_reloc_notsupported;
1419 break;
1420 }
1421
1422 if (r != bfd_reloc_ok)
1423 {
1424 const char * msg = NULL;
1425
1426 switch (r)
1427 {
1428 case bfd_reloc_overflow:
1429 /* Catch the case of a missing function declaration
1430 and emit a more helpful error message. */
1431 if (r_type == R_RX_DIR24S_PCREL)
1432 msg = _("%B(%A): error: call to undefined function '%s'");
1433 else
1434 r = info->callbacks->reloc_overflow
1435 (info, (h ? &h->root : NULL), name, howto->name, (bfd_vma) 0,
1436 input_bfd, input_section, rel->r_offset);
1437 break;
1438
1439 case bfd_reloc_undefined:
1440 r = info->callbacks->undefined_symbol
1441 (info, name, input_bfd, input_section, rel->r_offset,
1442 TRUE);
1443 break;
1444
1445 case bfd_reloc_other:
1446 msg = _("%B(%A): warning: unaligned access to symbol '%s' in the small data area");
1447 break;
1448
1449 case bfd_reloc_outofrange:
1450 msg = _("%B(%A): internal error: out of range error");
1451 break;
1452
1453 case bfd_reloc_notsupported:
1454 msg = _("%B(%A): internal error: unsupported relocation error");
1455 break;
1456
1457 case bfd_reloc_dangerous:
1458 msg = _("%B(%A): internal error: dangerous relocation");
1459 break;
1460
1461 default:
1462 msg = _("%B(%A): internal error: unknown error");
1463 break;
1464 }
1465
1466 if (msg)
1467 _bfd_error_handler (msg, input_bfd, input_section, name);
1468
1469 if (! r)
1470 return FALSE;
1471 }
1472 }
1473
1474 return TRUE;
1475 }
1476 \f
1477 /* Relaxation Support. */
1478
1479 /* Progression of relocations from largest operand size to smallest
1480 operand size. */
1481
1482 static int
1483 next_smaller_reloc (int r)
1484 {
1485 switch (r)
1486 {
1487 case R_RX_DIR32: return R_RX_DIR24S;
1488 case R_RX_DIR24S: return R_RX_DIR16S;
1489 case R_RX_DIR16S: return R_RX_DIR8S;
1490 case R_RX_DIR8S: return R_RX_NONE;
1491
1492 case R_RX_DIR16: return R_RX_DIR8;
1493 case R_RX_DIR8: return R_RX_NONE;
1494
1495 case R_RX_DIR16U: return R_RX_DIR8U;
1496 case R_RX_DIR8U: return R_RX_NONE;
1497
1498 case R_RX_DIR24S_PCREL: return R_RX_DIR16S_PCREL;
1499 case R_RX_DIR16S_PCREL: return R_RX_DIR8S_PCREL;
1500 case R_RX_DIR8S_PCREL: return R_RX_DIR3U_PCREL;
1501
1502 case R_RX_DIR16UL: return R_RX_DIR8UL;
1503 case R_RX_DIR8UL: return R_RX_NONE;
1504 case R_RX_DIR16UW: return R_RX_DIR8UW;
1505 case R_RX_DIR8UW: return R_RX_NONE;
1506
1507 case R_RX_RH_32_OP: return R_RX_RH_24_OP;
1508 case R_RX_RH_24_OP: return R_RX_RH_16_OP;
1509 case R_RX_RH_16_OP: return R_RX_DIR8;
1510
1511 case R_RX_ABS32: return R_RX_ABS24S;
1512 case R_RX_ABS24S: return R_RX_ABS16S;
1513 case R_RX_ABS16: return R_RX_ABS8;
1514 case R_RX_ABS16U: return R_RX_ABS8U;
1515 case R_RX_ABS16S: return R_RX_ABS8S;
1516 case R_RX_ABS8: return R_RX_NONE;
1517 case R_RX_ABS8U: return R_RX_NONE;
1518 case R_RX_ABS8S: return R_RX_NONE;
1519 case R_RX_ABS24S_PCREL: return R_RX_ABS16S_PCREL;
1520 case R_RX_ABS16S_PCREL: return R_RX_ABS8S_PCREL;
1521 case R_RX_ABS8S_PCREL: return R_RX_NONE;
1522 case R_RX_ABS16UL: return R_RX_ABS8UL;
1523 case R_RX_ABS16UW: return R_RX_ABS8UW;
1524 case R_RX_ABS8UL: return R_RX_NONE;
1525 case R_RX_ABS8UW: return R_RX_NONE;
1526 }
1527 return r;
1528 };
1529
1530 /* Delete some bytes from a section while relaxing. */
1531
1532 static bfd_boolean
1533 elf32_rx_relax_delete_bytes (bfd *abfd, asection *sec, bfd_vma addr, int count,
1534 Elf_Internal_Rela *alignment_rel, int force_snip)
1535 {
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 (bfd_link_relocatable (link_info)
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_symtab_hdr (abfd);
2013 if (elf_symtab_shndx_list (abfd))
2014 shndx_hdr = & elf_symtab_shndx_list (abfd)->hdr;
2015 else
2016 shndx_hdr = NULL;
2017
2018 sec_start = sec->output_section->vma + sec->output_offset;
2019
2020 /* Get the section contents. */
2021 if (elf_section_data (sec)->this_hdr.contents != NULL)
2022 contents = elf_section_data (sec)->this_hdr.contents;
2023 /* Go get them off disk. */
2024 else
2025 {
2026 if (! bfd_malloc_and_get_section (abfd, sec, &contents))
2027 goto error_return;
2028 elf_section_data (sec)->this_hdr.contents = contents;
2029 }
2030
2031 /* Read this BFD's symbols. */
2032 /* Get cached copy if it exists. */
2033 if (symtab_hdr->contents != NULL)
2034 intsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
2035 else
2036 {
2037 intsyms = bfd_elf_get_elf_syms (abfd, symtab_hdr, symtab_hdr->sh_info, 0, NULL, NULL, NULL);
2038 symtab_hdr->contents = (bfd_byte *) intsyms;
2039 }
2040
2041 if (shndx_hdr && shndx_hdr->sh_size != 0)
2042 {
2043 bfd_size_type amt;
2044
2045 amt = symtab_hdr->sh_info;
2046 amt *= sizeof (Elf_External_Sym_Shndx);
2047 shndx_buf = (Elf_External_Sym_Shndx *) bfd_malloc (amt);
2048 if (shndx_buf == NULL)
2049 goto error_return;
2050 if (bfd_seek (abfd, shndx_hdr->sh_offset, SEEK_SET) != 0
2051 || bfd_bread (shndx_buf, amt, abfd) != amt)
2052 goto error_return;
2053 shndx_hdr->contents = (bfd_byte *) shndx_buf;
2054 }
2055
2056 /* Get a copy of the native relocations. */
2057 internal_relocs = (_bfd_elf_link_read_relocs
2058 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
2059 link_info->keep_memory));
2060 if (internal_relocs == NULL)
2061 goto error_return;
2062 if (! link_info->keep_memory)
2063 free_relocs = internal_relocs;
2064
2065 /* The RL_ relocs must be just before the operand relocs they go
2066 with, so we must sort them to guarantee this. We use bubblesort
2067 instead of qsort so we can guarantee that relocs with the same
2068 address remain in the same relative order. */
2069 reloc_bubblesort (internal_relocs, sec->reloc_count);
2070
2071 /* Walk through them looking for relaxing opportunities. */
2072 irelend = internal_relocs + sec->reloc_count;
2073
2074 /* This will either be NULL or a pointer to the next alignment
2075 relocation. */
2076 next_alignment = internal_relocs;
2077 /* This will be the previous alignment, although at first it points
2078 to the first real relocation. */
2079 prev_alignment = internal_relocs;
2080
2081 /* We calculate worst case shrinkage caused by alignment directives.
2082 No fool-proof, but better than either ignoring the problem or
2083 doing heavy duty analysis of all the alignment markers in all
2084 input sections. */
2085 section_alignment_glue = 0;
2086 for (irel = internal_relocs; irel < irelend; irel++)
2087 if (ELF32_R_TYPE (irel->r_info) == R_RX_RH_RELAX
2088 && irel->r_addend & RX_RELAXA_ALIGN)
2089 {
2090 int this_glue = 1 << (irel->r_addend & RX_RELAXA_ANUM);
2091
2092 if (section_alignment_glue < this_glue)
2093 section_alignment_glue = this_glue;
2094 }
2095 /* Worst case is all 0..N alignments, in order, causing 2*N-1 byte
2096 shrinkage. */
2097 section_alignment_glue *= 2;
2098
2099 for (irel = internal_relocs; irel < irelend; irel++)
2100 {
2101 unsigned char *insn;
2102 int nrelocs;
2103
2104 /* The insns we care about are all marked with one of these. */
2105 if (ELF32_R_TYPE (irel->r_info) != R_RX_RH_RELAX)
2106 continue;
2107
2108 if (irel->r_addend & RX_RELAXA_ALIGN
2109 || next_alignment == internal_relocs)
2110 {
2111 /* When we delete bytes, we need to maintain all the alignments
2112 indicated. In addition, we need to be careful about relaxing
2113 jumps across alignment boundaries - these displacements
2114 *grow* when we delete bytes. For now, don't shrink
2115 displacements across an alignment boundary, just in case.
2116 Note that this only affects relocations to the same
2117 section. */
2118 prev_alignment = next_alignment;
2119 next_alignment += 2;
2120 while (next_alignment < irelend
2121 && (ELF32_R_TYPE (next_alignment->r_info) != R_RX_RH_RELAX
2122 || !(next_alignment->r_addend & RX_RELAXA_ELIGN)))
2123 next_alignment ++;
2124 if (next_alignment >= irelend || next_alignment->r_offset == 0)
2125 next_alignment = NULL;
2126 }
2127
2128 /* When we hit alignment markers, see if we've shrunk enough
2129 before them to reduce the gap without violating the alignment
2130 requirements. */
2131 if (irel->r_addend & RX_RELAXA_ALIGN)
2132 {
2133 /* At this point, the next relocation *should* be the ELIGN
2134 end marker. */
2135 Elf_Internal_Rela *erel = irel + 1;
2136 unsigned int alignment, nbytes;
2137
2138 if (ELF32_R_TYPE (erel->r_info) != R_RX_RH_RELAX)
2139 continue;
2140 if (!(erel->r_addend & RX_RELAXA_ELIGN))
2141 continue;
2142
2143 alignment = 1 << (irel->r_addend & RX_RELAXA_ANUM);
2144
2145 if (erel->r_offset - irel->r_offset < alignment)
2146 continue;
2147
2148 nbytes = erel->r_offset - irel->r_offset;
2149 nbytes /= alignment;
2150 nbytes *= alignment;
2151
2152 elf32_rx_relax_delete_bytes (abfd, sec, erel->r_offset-nbytes, nbytes, next_alignment,
2153 erel->r_offset == sec->size);
2154 *again = TRUE;
2155
2156 continue;
2157 }
2158
2159 if (irel->r_addend & RX_RELAXA_ELIGN)
2160 continue;
2161
2162 insn = contents + irel->r_offset;
2163
2164 nrelocs = irel->r_addend & RX_RELAXA_RNUM;
2165
2166 /* At this point, we have an insn that is a candidate for linker
2167 relaxation. There are NRELOCS relocs following that may be
2168 relaxed, although each reloc may be made of more than one
2169 reloc entry (such as gp-rel symbols). */
2170
2171 /* Get the value of the symbol referred to by the reloc. Just
2172 in case this is the last reloc in the list, use the RL's
2173 addend to choose between this reloc (no addend) or the next
2174 (yes addend, which means at least one following reloc). */
2175
2176 /* srel points to the "current" reloction for this insn -
2177 actually the last reloc for a given operand, which is the one
2178 we need to update. We check the relaxations in the same
2179 order that the relocations happen, so we'll just push it
2180 along as we go. */
2181 srel = irel;
2182
2183 pc = sec->output_section->vma + sec->output_offset
2184 + srel->r_offset;
2185
2186 #define GET_RELOC \
2187 symval = OFFSET_FOR_RELOC (srel, &srel, &scale); \
2188 pcrel = symval - pc + srel->r_addend; \
2189 nrelocs --;
2190
2191 #define SNIPNR(offset, nbytes) \
2192 elf32_rx_relax_delete_bytes (abfd, sec, (insn - contents) + offset, nbytes, next_alignment, 0);
2193 #define SNIP(offset, nbytes, newtype) \
2194 SNIPNR (offset, nbytes); \
2195 srel->r_info = ELF32_R_INFO (ELF32_R_SYM (srel->r_info), newtype)
2196
2197 /* The order of these bit tests must match the order that the
2198 relocs appear in. Since we sorted those by offset, we can
2199 predict them. */
2200
2201 /* Note that the numbers in, say, DSP6 are the bit offsets of
2202 the code fields that describe the operand. Bits number 0 for
2203 the MSB of insn[0]. */
2204
2205 /* DSP* codes:
2206 0 00 [reg]
2207 1 01 dsp:8[reg]
2208 2 10 dsp:16[reg]
2209 3 11 reg */
2210 if (irel->r_addend & RX_RELAXA_DSP6)
2211 {
2212 GET_RELOC;
2213
2214 code = insn[0] & 3;
2215 if (code == 2 && symval/scale <= 255)
2216 {
2217 unsigned int newrel = ELF32_R_TYPE (srel->r_info);
2218 insn[0] &= 0xfc;
2219 insn[0] |= 0x01;
2220 newrel = next_smaller_reloc (ELF32_R_TYPE (srel->r_info));
2221 if (newrel != ELF32_R_TYPE (srel->r_info))
2222 {
2223 SNIP (3, 1, newrel);
2224 *again = TRUE;
2225 }
2226 }
2227
2228 else if (code == 1 && symval == 0)
2229 {
2230 insn[0] &= 0xfc;
2231 SNIP (2, 1, R_RX_NONE);
2232 *again = TRUE;
2233 }
2234
2235 /* Special case DSP:5 format: MOV.bwl dsp:5[Rsrc],Rdst. */
2236 else if (code == 1 && symval/scale <= 31
2237 /* Decodable bits. */
2238 && (insn[0] & 0xcc) == 0xcc
2239 /* Width. */
2240 && (insn[0] & 0x30) != 0x30
2241 /* Register MSBs. */
2242 && (insn[1] & 0x88) == 0x00)
2243 {
2244 int newrel = 0;
2245
2246 insn[0] = 0x88 | (insn[0] & 0x30);
2247 /* The register fields are in the right place already. */
2248
2249 /* We can't relax this new opcode. */
2250 irel->r_addend = 0;
2251
2252 switch ((insn[0] & 0x30) >> 4)
2253 {
2254 case 0:
2255 newrel = R_RX_RH_ABS5p5B;
2256 break;
2257 case 1:
2258 newrel = R_RX_RH_ABS5p5W;
2259 break;
2260 case 2:
2261 newrel = R_RX_RH_ABS5p5L;
2262 break;
2263 }
2264
2265 move_reloc (irel, srel, -2);
2266 SNIP (2, 1, newrel);
2267 }
2268
2269 /* Special case DSP:5 format: MOVU.bw dsp:5[Rsrc],Rdst. */
2270 else if (code == 1 && symval/scale <= 31
2271 /* Decodable bits. */
2272 && (insn[0] & 0xf8) == 0x58
2273 /* Register MSBs. */
2274 && (insn[1] & 0x88) == 0x00)
2275 {
2276 int newrel = 0;
2277
2278 insn[0] = 0xb0 | ((insn[0] & 0x04) << 1);
2279 /* The register fields are in the right place already. */
2280
2281 /* We can't relax this new opcode. */
2282 irel->r_addend = 0;
2283
2284 switch ((insn[0] & 0x08) >> 3)
2285 {
2286 case 0:
2287 newrel = R_RX_RH_ABS5p5B;
2288 break;
2289 case 1:
2290 newrel = R_RX_RH_ABS5p5W;
2291 break;
2292 }
2293
2294 move_reloc (irel, srel, -2);
2295 SNIP (2, 1, newrel);
2296 }
2297 }
2298
2299 /* A DSP4 operand always follows a DSP6 operand, even if there's
2300 no relocation for it. We have to read the code out of the
2301 opcode to calculate the offset of the operand. */
2302 if (irel->r_addend & RX_RELAXA_DSP4)
2303 {
2304 int code6, offset = 0;
2305
2306 GET_RELOC;
2307
2308 code6 = insn[0] & 0x03;
2309 switch (code6)
2310 {
2311 case 0: offset = 2; break;
2312 case 1: offset = 3; break;
2313 case 2: offset = 4; break;
2314 case 3: offset = 2; break;
2315 }
2316
2317 code = (insn[0] & 0x0c) >> 2;
2318
2319 if (code == 2 && symval / scale <= 255)
2320 {
2321 unsigned int newrel = ELF32_R_TYPE (srel->r_info);
2322
2323 insn[0] &= 0xf3;
2324 insn[0] |= 0x04;
2325 newrel = next_smaller_reloc (ELF32_R_TYPE (srel->r_info));
2326 if (newrel != ELF32_R_TYPE (srel->r_info))
2327 {
2328 SNIP (offset+1, 1, newrel);
2329 *again = TRUE;
2330 }
2331 }
2332
2333 else if (code == 1 && symval == 0)
2334 {
2335 insn[0] &= 0xf3;
2336 SNIP (offset, 1, R_RX_NONE);
2337 *again = TRUE;
2338 }
2339 /* Special case DSP:5 format: MOV.bwl Rsrc,dsp:5[Rdst] */
2340 else if (code == 1 && symval/scale <= 31
2341 /* Decodable bits. */
2342 && (insn[0] & 0xc3) == 0xc3
2343 /* Width. */
2344 && (insn[0] & 0x30) != 0x30
2345 /* Register MSBs. */
2346 && (insn[1] & 0x88) == 0x00)
2347 {
2348 int newrel = 0;
2349
2350 insn[0] = 0x80 | (insn[0] & 0x30);
2351 /* The register fields are in the right place already. */
2352
2353 /* We can't relax this new opcode. */
2354 irel->r_addend = 0;
2355
2356 switch ((insn[0] & 0x30) >> 4)
2357 {
2358 case 0:
2359 newrel = R_RX_RH_ABS5p5B;
2360 break;
2361 case 1:
2362 newrel = R_RX_RH_ABS5p5W;
2363 break;
2364 case 2:
2365 newrel = R_RX_RH_ABS5p5L;
2366 break;
2367 }
2368
2369 move_reloc (irel, srel, -2);
2370 SNIP (2, 1, newrel);
2371 }
2372 }
2373
2374 /* These always occur alone, but the offset depends on whether
2375 it's a MEMEX opcode (0x06) or not. */
2376 if (irel->r_addend & RX_RELAXA_DSP14)
2377 {
2378 int offset;
2379 GET_RELOC;
2380
2381 if (insn[0] == 0x06)
2382 offset = 3;
2383 else
2384 offset = 4;
2385
2386 code = insn[1] & 3;
2387
2388 if (code == 2 && symval / scale <= 255)
2389 {
2390 unsigned int newrel = ELF32_R_TYPE (srel->r_info);
2391
2392 insn[1] &= 0xfc;
2393 insn[1] |= 0x01;
2394 newrel = next_smaller_reloc (ELF32_R_TYPE (srel->r_info));
2395 if (newrel != ELF32_R_TYPE (srel->r_info))
2396 {
2397 SNIP (offset, 1, newrel);
2398 *again = TRUE;
2399 }
2400 }
2401 else if (code == 1 && symval == 0)
2402 {
2403 insn[1] &= 0xfc;
2404 SNIP (offset, 1, R_RX_NONE);
2405 *again = TRUE;
2406 }
2407 }
2408
2409 /* IMM* codes:
2410 0 00 imm:32
2411 1 01 simm:8
2412 2 10 simm:16
2413 3 11 simm:24. */
2414
2415 /* These always occur alone. */
2416 if (irel->r_addend & RX_RELAXA_IMM6)
2417 {
2418 long ssymval;
2419
2420 GET_RELOC;
2421
2422 /* These relocations sign-extend, so we must do signed compares. */
2423 ssymval = (long) symval;
2424
2425 code = insn[0] & 0x03;
2426
2427 if (code == 0 && ssymval <= 8388607 && ssymval >= -8388608)
2428 {
2429 unsigned int newrel = ELF32_R_TYPE (srel->r_info);
2430
2431 insn[0] &= 0xfc;
2432 insn[0] |= 0x03;
2433 newrel = next_smaller_reloc (ELF32_R_TYPE (srel->r_info));
2434 if (newrel != ELF32_R_TYPE (srel->r_info))
2435 {
2436 SNIP (2, 1, newrel);
2437 *again = TRUE;
2438 }
2439 }
2440
2441 else if (code == 3 && ssymval <= 32767 && ssymval >= -32768)
2442 {
2443 unsigned int newrel = ELF32_R_TYPE (srel->r_info);
2444
2445 insn[0] &= 0xfc;
2446 insn[0] |= 0x02;
2447 newrel = next_smaller_reloc (ELF32_R_TYPE (srel->r_info));
2448 if (newrel != ELF32_R_TYPE (srel->r_info))
2449 {
2450 SNIP (2, 1, newrel);
2451 *again = TRUE;
2452 }
2453 }
2454
2455 /* Special case UIMM8 format: CMP #uimm8,Rdst. */
2456 else if (code == 2 && ssymval <= 255 && ssymval >= 16
2457 /* Decodable bits. */
2458 && (insn[0] & 0xfc) == 0x74
2459 /* Decodable bits. */
2460 && ((insn[1] & 0xf0) == 0x00))
2461 {
2462 int newrel;
2463
2464 insn[0] = 0x75;
2465 insn[1] = 0x50 | (insn[1] & 0x0f);
2466
2467 /* We can't relax this new opcode. */
2468 irel->r_addend = 0;
2469
2470 if (STACK_REL_P (ELF32_R_TYPE (srel->r_info)))
2471 newrel = R_RX_ABS8U;
2472 else
2473 newrel = R_RX_DIR8U;
2474
2475 SNIP (2, 1, newrel);
2476 *again = TRUE;
2477 }
2478
2479 else if (code == 2 && ssymval <= 127 && ssymval >= -128)
2480 {
2481 unsigned int newrel = ELF32_R_TYPE (srel->r_info);
2482
2483 insn[0] &= 0xfc;
2484 insn[0] |= 0x01;
2485 newrel = next_smaller_reloc (ELF32_R_TYPE (srel->r_info));
2486 if (newrel != ELF32_R_TYPE (srel->r_info))
2487 {
2488 SNIP (2, 1, newrel);
2489 *again = TRUE;
2490 }
2491 }
2492
2493 /* Special case UIMM4 format: CMP, MUL, AND, OR. */
2494 else if (code == 1 && ssymval <= 15 && ssymval >= 0
2495 /* Decodable bits and immediate type. */
2496 && insn[0] == 0x75
2497 /* Decodable bits. */
2498 && (insn[1] & 0xc0) == 0x00)
2499 {
2500 static const int newop[4] = { 1, 3, 4, 5 };
2501
2502 insn[0] = 0x60 | newop[insn[1] >> 4];
2503 /* The register number doesn't move. */
2504
2505 /* We can't relax this new opcode. */
2506 irel->r_addend = 0;
2507
2508 move_reloc (irel, srel, -1);
2509
2510 SNIP (2, 1, R_RX_RH_UIMM4p8);
2511 *again = TRUE;
2512 }
2513
2514 /* Special case UIMM4 format: ADD -> ADD/SUB. */
2515 else if (code == 1 && ssymval <= 15 && ssymval >= -15
2516 /* Decodable bits and immediate type. */
2517 && insn[0] == 0x71
2518 /* Same register for source and destination. */
2519 && ((insn[1] >> 4) == (insn[1] & 0x0f)))
2520 {
2521 int newrel;
2522
2523 /* Note that we can't turn "add $0,Rs" into a NOP
2524 because the flags need to be set right. */
2525
2526 if (ssymval < 0)
2527 {
2528 insn[0] = 0x60; /* Subtract. */
2529 newrel = R_RX_RH_UNEG4p8;
2530 }
2531 else
2532 {
2533 insn[0] = 0x62; /* Add. */
2534 newrel = R_RX_RH_UIMM4p8;
2535 }
2536
2537 /* The register number is in the right place. */
2538
2539 /* We can't relax this new opcode. */
2540 irel->r_addend = 0;
2541
2542 move_reloc (irel, srel, -1);
2543
2544 SNIP (2, 1, newrel);
2545 *again = TRUE;
2546 }
2547 }
2548
2549 /* These are either matched with a DSP6 (2-byte base) or an id24
2550 (3-byte base). */
2551 if (irel->r_addend & RX_RELAXA_IMM12)
2552 {
2553 int dspcode, offset = 0;
2554 long ssymval;
2555
2556 GET_RELOC;
2557
2558 if ((insn[0] & 0xfc) == 0xfc)
2559 dspcode = 1; /* Just something with one byte operand. */
2560 else
2561 dspcode = insn[0] & 3;
2562 switch (dspcode)
2563 {
2564 case 0: offset = 2; break;
2565 case 1: offset = 3; break;
2566 case 2: offset = 4; break;
2567 case 3: offset = 2; break;
2568 }
2569
2570 /* These relocations sign-extend, so we must do signed compares. */
2571 ssymval = (long) symval;
2572
2573 code = (insn[1] >> 2) & 3;
2574 if (code == 0 && ssymval <= 8388607 && ssymval >= -8388608)
2575 {
2576 unsigned int newrel = ELF32_R_TYPE (srel->r_info);
2577
2578 insn[1] &= 0xf3;
2579 insn[1] |= 0x0c;
2580 newrel = next_smaller_reloc (ELF32_R_TYPE (srel->r_info));
2581 if (newrel != ELF32_R_TYPE (srel->r_info))
2582 {
2583 SNIP (offset, 1, newrel);
2584 *again = TRUE;
2585 }
2586 }
2587
2588 else if (code == 3 && ssymval <= 32767 && ssymval >= -32768)
2589 {
2590 unsigned int newrel = ELF32_R_TYPE (srel->r_info);
2591
2592 insn[1] &= 0xf3;
2593 insn[1] |= 0x08;
2594 newrel = next_smaller_reloc (ELF32_R_TYPE (srel->r_info));
2595 if (newrel != ELF32_R_TYPE (srel->r_info))
2596 {
2597 SNIP (offset, 1, newrel);
2598 *again = TRUE;
2599 }
2600 }
2601
2602 /* Special case UIMM8 format: MOV #uimm8,Rdst. */
2603 else if (code == 2 && ssymval <= 255 && ssymval >= 16
2604 /* Decodable bits. */
2605 && insn[0] == 0xfb
2606 /* Decodable bits. */
2607 && ((insn[1] & 0x03) == 0x02))
2608 {
2609 int newrel;
2610
2611 insn[0] = 0x75;
2612 insn[1] = 0x40 | (insn[1] >> 4);
2613
2614 /* We can't relax this new opcode. */
2615 irel->r_addend = 0;
2616
2617 if (STACK_REL_P (ELF32_R_TYPE (srel->r_info)))
2618 newrel = R_RX_ABS8U;
2619 else
2620 newrel = R_RX_DIR8U;
2621
2622 SNIP (2, 1, newrel);
2623 *again = TRUE;
2624 }
2625
2626 else if (code == 2 && ssymval <= 127 && ssymval >= -128)
2627 {
2628 unsigned int newrel = ELF32_R_TYPE(srel->r_info);
2629
2630 insn[1] &= 0xf3;
2631 insn[1] |= 0x04;
2632 newrel = next_smaller_reloc (ELF32_R_TYPE (srel->r_info));
2633 if (newrel != ELF32_R_TYPE(srel->r_info))
2634 {
2635 SNIP (offset, 1, newrel);
2636 *again = TRUE;
2637 }
2638 }
2639
2640 /* Special case UIMM4 format: MOV #uimm4,Rdst. */
2641 else if (code == 1 && ssymval <= 15 && ssymval >= 0
2642 /* Decodable bits. */
2643 && insn[0] == 0xfb
2644 /* Decodable bits. */
2645 && ((insn[1] & 0x03) == 0x02))
2646 {
2647 insn[0] = 0x66;
2648 insn[1] = insn[1] >> 4;
2649
2650 /* We can't relax this new opcode. */
2651 irel->r_addend = 0;
2652
2653 move_reloc (irel, srel, -1);
2654
2655 SNIP (2, 1, R_RX_RH_UIMM4p8);
2656 *again = TRUE;
2657 }
2658 }
2659
2660 if (irel->r_addend & RX_RELAXA_BRA)
2661 {
2662 unsigned int newrel = ELF32_R_TYPE (srel->r_info);
2663 int max_pcrel3 = 4;
2664 int alignment_glue = 0;
2665
2666 GET_RELOC;
2667
2668 /* Branches over alignment chunks are problematic, as
2669 deleting bytes here makes the branch *further* away. We
2670 can be agressive with branches within this alignment
2671 block, but not branches outside it. */
2672 if ((prev_alignment == NULL
2673 || symval < (bfd_vma)(sec_start + prev_alignment->r_offset))
2674 && (next_alignment == NULL
2675 || symval > (bfd_vma)(sec_start + next_alignment->r_offset)))
2676 alignment_glue = section_alignment_glue;
2677
2678 if (ELF32_R_TYPE(srel[1].r_info) == R_RX_RH_RELAX
2679 && srel[1].r_addend & RX_RELAXA_BRA
2680 && srel[1].r_offset < irel->r_offset + pcrel)
2681 max_pcrel3 ++;
2682
2683 newrel = next_smaller_reloc (ELF32_R_TYPE (srel->r_info));
2684
2685 /* The values we compare PCREL with are not what you'd
2686 expect; they're off by a little to compensate for (1)
2687 where the reloc is relative to the insn, and (2) how much
2688 the insn is going to change when we relax it. */
2689
2690 /* These we have to decode. */
2691 switch (insn[0])
2692 {
2693 case 0x04: /* BRA pcdsp:24 */
2694 if (-32768 + alignment_glue <= pcrel
2695 && pcrel <= 32765 - alignment_glue)
2696 {
2697 insn[0] = 0x38;
2698 SNIP (3, 1, newrel);
2699 *again = TRUE;
2700 }
2701 break;
2702
2703 case 0x38: /* BRA pcdsp:16 */
2704 if (-128 + alignment_glue <= pcrel
2705 && pcrel <= 127 - alignment_glue)
2706 {
2707 insn[0] = 0x2e;
2708 SNIP (2, 1, newrel);
2709 *again = TRUE;
2710 }
2711 break;
2712
2713 case 0x2e: /* BRA pcdsp:8 */
2714 /* Note that there's a risk here of shortening things so
2715 much that we no longer fit this reloc; it *should*
2716 only happen when you branch across a branch, and that
2717 branch also devolves into BRA.S. "Real" code should
2718 be OK. */
2719 if (max_pcrel3 + alignment_glue <= pcrel
2720 && pcrel <= 10 - alignment_glue
2721 && allow_pcrel3)
2722 {
2723 insn[0] = 0x08;
2724 SNIP (1, 1, newrel);
2725 move_reloc (irel, srel, -1);
2726 *again = TRUE;
2727 }
2728 break;
2729
2730 case 0x05: /* BSR pcdsp:24 */
2731 if (-32768 + alignment_glue <= pcrel
2732 && pcrel <= 32765 - alignment_glue)
2733 {
2734 insn[0] = 0x39;
2735 SNIP (1, 1, newrel);
2736 *again = TRUE;
2737 }
2738 break;
2739
2740 case 0x3a: /* BEQ.W pcdsp:16 */
2741 case 0x3b: /* BNE.W pcdsp:16 */
2742 if (-128 + alignment_glue <= pcrel
2743 && pcrel <= 127 - alignment_glue)
2744 {
2745 insn[0] = 0x20 | (insn[0] & 1);
2746 SNIP (1, 1, newrel);
2747 *again = TRUE;
2748 }
2749 break;
2750
2751 case 0x20: /* BEQ.B pcdsp:8 */
2752 case 0x21: /* BNE.B pcdsp:8 */
2753 if (max_pcrel3 + alignment_glue <= pcrel
2754 && pcrel - alignment_glue <= 10
2755 && allow_pcrel3)
2756 {
2757 insn[0] = 0x10 | ((insn[0] & 1) << 3);
2758 SNIP (1, 1, newrel);
2759 move_reloc (irel, srel, -1);
2760 *again = TRUE;
2761 }
2762 break;
2763
2764 case 0x16: /* synthetic BNE dsp24 */
2765 case 0x1e: /* synthetic BEQ dsp24 */
2766 if (-32767 + alignment_glue <= pcrel
2767 && pcrel <= 32766 - alignment_glue
2768 && insn[1] == 0x04)
2769 {
2770 if (insn[0] == 0x16)
2771 insn[0] = 0x3b;
2772 else
2773 insn[0] = 0x3a;
2774 /* We snip out the bytes at the end else the reloc
2775 will get moved too, and too much. */
2776 SNIP (3, 2, newrel);
2777 move_reloc (irel, srel, -1);
2778 *again = TRUE;
2779 }
2780 break;
2781 }
2782
2783 /* Special case - synthetic conditional branches, pcrel24.
2784 Note that EQ and NE have been handled above. */
2785 if ((insn[0] & 0xf0) == 0x20
2786 && insn[1] == 0x06
2787 && insn[2] == 0x04
2788 && srel->r_offset != irel->r_offset + 1
2789 && -32767 + alignment_glue <= pcrel
2790 && pcrel <= 32766 - alignment_glue)
2791 {
2792 insn[1] = 0x05;
2793 insn[2] = 0x38;
2794 SNIP (5, 1, newrel);
2795 *again = TRUE;
2796 }
2797
2798 /* Special case - synthetic conditional branches, pcrel16 */
2799 if ((insn[0] & 0xf0) == 0x20
2800 && insn[1] == 0x05
2801 && insn[2] == 0x38
2802 && srel->r_offset != irel->r_offset + 1
2803 && -127 + alignment_glue <= pcrel
2804 && pcrel <= 126 - alignment_glue)
2805 {
2806 int cond = (insn[0] & 0x0f) ^ 0x01;
2807
2808 insn[0] = 0x20 | cond;
2809 /* By moving the reloc first, we avoid having
2810 delete_bytes move it also. */
2811 move_reloc (irel, srel, -2);
2812 SNIP (2, 3, newrel);
2813 *again = TRUE;
2814 }
2815 }
2816
2817 BFD_ASSERT (nrelocs == 0);
2818
2819 /* Special case - check MOV.bwl #IMM, dsp[reg] and see if we can
2820 use MOV.bwl #uimm:8, dsp:5[r7] format. This is tricky
2821 because it may have one or two relocations. */
2822 if ((insn[0] & 0xfc) == 0xf8
2823 && (insn[1] & 0x80) == 0x00
2824 && (insn[0] & 0x03) != 0x03)
2825 {
2826 int dcode, icode, reg, ioff, dscale, ilen;
2827 bfd_vma disp_val = 0;
2828 long imm_val = 0;
2829 Elf_Internal_Rela * disp_rel = 0;
2830 Elf_Internal_Rela * imm_rel = 0;
2831
2832 /* Reset this. */
2833 srel = irel;
2834
2835 dcode = insn[0] & 0x03;
2836 icode = (insn[1] >> 2) & 0x03;
2837 reg = (insn[1] >> 4) & 0x0f;
2838
2839 ioff = dcode == 1 ? 3 : dcode == 2 ? 4 : 2;
2840
2841 /* Figure out what the dispacement is. */
2842 if (dcode == 1 || dcode == 2)
2843 {
2844 /* There's a displacement. See if there's a reloc for it. */
2845 if (srel[1].r_offset == irel->r_offset + 2)
2846 {
2847 GET_RELOC;
2848 disp_val = symval;
2849 disp_rel = srel;
2850 }
2851 else
2852 {
2853 if (dcode == 1)
2854 disp_val = insn[2];
2855 else
2856 {
2857 #if RX_OPCODE_BIG_ENDIAN
2858 disp_val = insn[2] * 256 + insn[3];
2859 #else
2860 disp_val = insn[2] + insn[3] * 256;
2861 #endif
2862 }
2863 switch (insn[1] & 3)
2864 {
2865 case 1:
2866 disp_val *= 2;
2867 scale = 2;
2868 break;
2869 case 2:
2870 disp_val *= 4;
2871 scale = 4;
2872 break;
2873 }
2874 }
2875 }
2876
2877 dscale = scale;
2878
2879 /* Figure out what the immediate is. */
2880 if (srel[1].r_offset == irel->r_offset + ioff)
2881 {
2882 GET_RELOC;
2883 imm_val = (long) symval;
2884 imm_rel = srel;
2885 }
2886 else
2887 {
2888 unsigned char * ip = insn + ioff;
2889
2890 switch (icode)
2891 {
2892 case 1:
2893 /* For byte writes, we don't sign extend. Makes the math easier later. */
2894 if (scale == 1)
2895 imm_val = ip[0];
2896 else
2897 imm_val = (char) ip[0];
2898 break;
2899 case 2:
2900 #if RX_OPCODE_BIG_ENDIAN
2901 imm_val = ((char) ip[0] << 8) | ip[1];
2902 #else
2903 imm_val = ((char) ip[1] << 8) | ip[0];
2904 #endif
2905 break;
2906 case 3:
2907 #if RX_OPCODE_BIG_ENDIAN
2908 imm_val = ((char) ip[0] << 16) | (ip[1] << 8) | ip[2];
2909 #else
2910 imm_val = ((char) ip[2] << 16) | (ip[1] << 8) | ip[0];
2911 #endif
2912 break;
2913 case 0:
2914 #if RX_OPCODE_BIG_ENDIAN
2915 imm_val = (ip[0] << 24) | (ip[1] << 16) | (ip[2] << 8) | ip[3];
2916 #else
2917 imm_val = (ip[3] << 24) | (ip[2] << 16) | (ip[1] << 8) | ip[0];
2918 #endif
2919 break;
2920 }
2921 }
2922
2923 ilen = 2;
2924
2925 switch (dcode)
2926 {
2927 case 1:
2928 ilen += 1;
2929 break;
2930 case 2:
2931 ilen += 2;
2932 break;
2933 }
2934
2935 switch (icode)
2936 {
2937 case 1:
2938 ilen += 1;
2939 break;
2940 case 2:
2941 ilen += 2;
2942 break;
2943 case 3:
2944 ilen += 3;
2945 break;
2946 case 4:
2947 ilen += 4;
2948 break;
2949 }
2950
2951 /* The shortcut happens when the immediate is 0..255,
2952 register r0 to r7, and displacement (scaled) 0..31. */
2953
2954 if (0 <= imm_val && imm_val <= 255
2955 && 0 <= reg && reg <= 7
2956 && disp_val / dscale <= 31)
2957 {
2958 insn[0] = 0x3c | (insn[1] & 0x03);
2959 insn[1] = (((disp_val / dscale) << 3) & 0x80) | (reg << 4) | ((disp_val/dscale) & 0x0f);
2960 insn[2] = imm_val;
2961
2962 if (disp_rel)
2963 {
2964 int newrel = R_RX_NONE;
2965
2966 switch (dscale)
2967 {
2968 case 1:
2969 newrel = R_RX_RH_ABS5p8B;
2970 break;
2971 case 2:
2972 newrel = R_RX_RH_ABS5p8W;
2973 break;
2974 case 4:
2975 newrel = R_RX_RH_ABS5p8L;
2976 break;
2977 }
2978 disp_rel->r_info = ELF32_R_INFO (ELF32_R_SYM (disp_rel->r_info), newrel);
2979 move_reloc (irel, disp_rel, -1);
2980 }
2981 if (imm_rel)
2982 {
2983 imm_rel->r_info = ELF32_R_INFO (ELF32_R_SYM (imm_rel->r_info), R_RX_DIR8U);
2984 move_reloc (disp_rel ? disp_rel : irel,
2985 imm_rel,
2986 irel->r_offset - imm_rel->r_offset + 2);
2987 }
2988
2989 SNIPNR (3, ilen - 3);
2990 *again = TRUE;
2991
2992 /* We can't relax this new opcode. */
2993 irel->r_addend = 0;
2994 }
2995 }
2996 }
2997
2998 /* We can't reliably relax branches to DIR3U_PCREL unless we know
2999 whatever they're branching over won't shrink any more. If we're
3000 basically done here, do one more pass just for branches - but
3001 don't request a pass after that one! */
3002 if (!*again && !allow_pcrel3)
3003 {
3004 bfd_boolean ignored;
3005
3006 elf32_rx_relax_section (abfd, sec, link_info, &ignored, TRUE);
3007 }
3008
3009 return TRUE;
3010
3011 error_return:
3012 if (free_relocs != NULL)
3013 free (free_relocs);
3014
3015 if (free_contents != NULL)
3016 free (free_contents);
3017
3018 if (shndx_buf != NULL)
3019 {
3020 shndx_hdr->contents = NULL;
3021 free (shndx_buf);
3022 }
3023
3024 if (free_intsyms != NULL)
3025 free (free_intsyms);
3026
3027 return FALSE;
3028 }
3029
3030 static bfd_boolean
3031 elf32_rx_relax_section_wrapper (bfd * abfd,
3032 asection * sec,
3033 struct bfd_link_info * link_info,
3034 bfd_boolean * again)
3035 {
3036 return elf32_rx_relax_section (abfd, sec, link_info, again, FALSE);
3037 }
3038 \f
3039 /* Function to set the ELF flag bits. */
3040
3041 static bfd_boolean
3042 rx_elf_set_private_flags (bfd * abfd, flagword flags)
3043 {
3044 elf_elfheader (abfd)->e_flags = flags;
3045 elf_flags_init (abfd) = TRUE;
3046 return TRUE;
3047 }
3048
3049 static bfd_boolean no_warn_mismatch = FALSE;
3050 static bfd_boolean ignore_lma = TRUE;
3051
3052 void bfd_elf32_rx_set_target_flags (bfd_boolean, bfd_boolean);
3053
3054 void
3055 bfd_elf32_rx_set_target_flags (bfd_boolean user_no_warn_mismatch,
3056 bfd_boolean user_ignore_lma)
3057 {
3058 no_warn_mismatch = user_no_warn_mismatch;
3059 ignore_lma = user_ignore_lma;
3060 }
3061
3062 /* Converts FLAGS into a descriptive string.
3063 Returns a static pointer. */
3064
3065 static const char *
3066 describe_flags (flagword flags)
3067 {
3068 static char buf [128];
3069
3070 buf[0] = 0;
3071
3072 if (flags & E_FLAG_RX_64BIT_DOUBLES)
3073 strcat (buf, "64-bit doubles");
3074 else
3075 strcat (buf, "32-bit doubles");
3076
3077 if (flags & E_FLAG_RX_DSP)
3078 strcat (buf, ", dsp");
3079 else
3080 strcat (buf, ", no dsp");
3081
3082 if (flags & E_FLAG_RX_PID)
3083 strcat (buf, ", pid");
3084 else
3085 strcat (buf, ", no pid");
3086
3087 if (flags & E_FLAG_RX_ABI)
3088 strcat (buf, ", RX ABI");
3089 else
3090 strcat (buf, ", GCC ABI");
3091
3092 if (flags & E_FLAG_RX_SINSNS_SET)
3093 strcat (buf, flags & E_FLAG_RX_SINSNS_YES ? ", uses String instructions" : ", bans String instructions");
3094
3095 return buf;
3096 }
3097
3098 /* Merge backend specific data from an object file to the output
3099 object file when linking. */
3100
3101 static bfd_boolean
3102 rx_elf_merge_private_bfd_data (bfd * ibfd, bfd * obfd)
3103 {
3104 flagword old_flags;
3105 flagword new_flags;
3106 bfd_boolean error = FALSE;
3107
3108 new_flags = elf_elfheader (ibfd)->e_flags;
3109 old_flags = elf_elfheader (obfd)->e_flags;
3110
3111 if (!elf_flags_init (obfd))
3112 {
3113 /* First call, no flags set. */
3114 elf_flags_init (obfd) = TRUE;
3115 elf_elfheader (obfd)->e_flags = new_flags;
3116 }
3117 else if (old_flags != new_flags)
3118 {
3119 flagword known_flags;
3120
3121 if (old_flags & E_FLAG_RX_SINSNS_SET)
3122 {
3123 if ((new_flags & E_FLAG_RX_SINSNS_SET) == 0)
3124 {
3125 new_flags &= ~ E_FLAG_RX_SINSNS_MASK;
3126 new_flags |= (old_flags & E_FLAG_RX_SINSNS_MASK);
3127 }
3128 }
3129 else if (new_flags & E_FLAG_RX_SINSNS_SET)
3130 {
3131 old_flags &= ~ E_FLAG_RX_SINSNS_MASK;
3132 old_flags |= (new_flags & E_FLAG_RX_SINSNS_MASK);
3133 }
3134
3135 known_flags = E_FLAG_RX_ABI | E_FLAG_RX_64BIT_DOUBLES
3136 | E_FLAG_RX_DSP | E_FLAG_RX_PID | E_FLAG_RX_SINSNS_MASK;
3137
3138 if ((old_flags ^ new_flags) & known_flags)
3139 {
3140 /* Only complain if flag bits we care about do not match.
3141 Other bits may be set, since older binaries did use some
3142 deprecated flags. */
3143 if (no_warn_mismatch)
3144 {
3145 elf_elfheader (obfd)->e_flags = (new_flags | old_flags) & known_flags;
3146 }
3147 else
3148 {
3149 _bfd_error_handler ("There is a conflict merging the ELF header flags from %s",
3150 bfd_get_filename (ibfd));
3151 _bfd_error_handler (" the input file's flags: %s",
3152 describe_flags (new_flags));
3153 _bfd_error_handler (" the output file's flags: %s",
3154 describe_flags (old_flags));
3155 error = TRUE;
3156 }
3157 }
3158 else
3159 elf_elfheader (obfd)->e_flags = new_flags & known_flags;
3160 }
3161
3162 if (error)
3163 bfd_set_error (bfd_error_bad_value);
3164
3165 return !error;
3166 }
3167 \f
3168 static bfd_boolean
3169 rx_elf_print_private_bfd_data (bfd * abfd, void * ptr)
3170 {
3171 FILE * file = (FILE *) ptr;
3172 flagword flags;
3173
3174 BFD_ASSERT (abfd != NULL && ptr != NULL);
3175
3176 /* Print normal ELF private data. */
3177 _bfd_elf_print_private_bfd_data (abfd, ptr);
3178
3179 flags = elf_elfheader (abfd)->e_flags;
3180 fprintf (file, _("private flags = 0x%lx:"), (long) flags);
3181
3182 fprintf (file, "%s", describe_flags (flags));
3183 return TRUE;
3184 }
3185
3186 /* Return the MACH for an e_flags value. */
3187
3188 static int
3189 elf32_rx_machine (bfd * abfd ATTRIBUTE_UNUSED)
3190 {
3191 #if 0 /* FIXME: EF_RX_CPU_MASK collides with E_FLAG_RX_...
3192 Need to sort out how these flag bits are used.
3193 For now we assume that the flags are OK. */
3194 if ((elf_elfheader (abfd)->e_flags & EF_RX_CPU_MASK) == EF_RX_CPU_RX)
3195 #endif
3196 return bfd_mach_rx;
3197
3198 return 0;
3199 }
3200
3201 static bfd_boolean
3202 rx_elf_object_p (bfd * abfd)
3203 {
3204 int i;
3205 unsigned int u;
3206 Elf_Internal_Phdr *phdr = elf_tdata (abfd)->phdr;
3207 int nphdrs = elf_elfheader (abfd)->e_phnum;
3208 sec_ptr bsec;
3209 static int saw_be = FALSE;
3210
3211 /* We never want to automatically choose the non-swapping big-endian
3212 target. The user can only get that explicitly, such as with -I
3213 and objcopy. */
3214 if (abfd->xvec == &rx_elf32_be_ns_vec
3215 && abfd->target_defaulted)
3216 return FALSE;
3217
3218 /* BFD->target_defaulted is not set to TRUE when a target is chosen
3219 as a fallback, so we check for "scanning" to know when to stop
3220 using the non-swapping target. */
3221 if (abfd->xvec == &rx_elf32_be_ns_vec
3222 && saw_be)
3223 return FALSE;
3224 if (abfd->xvec == &rx_elf32_be_vec)
3225 saw_be = TRUE;
3226
3227 bfd_default_set_arch_mach (abfd, bfd_arch_rx,
3228 elf32_rx_machine (abfd));
3229
3230 /* For each PHDR in the object, we must find some section that
3231 corresponds (based on matching file offsets) and use its VMA
3232 information to reconstruct the p_vaddr field we clobbered when we
3233 wrote it out. */
3234 for (i=0; i<nphdrs; i++)
3235 {
3236 for (u=0; u<elf_tdata(abfd)->num_elf_sections; u++)
3237 {
3238 Elf_Internal_Shdr *sec = elf_tdata(abfd)->elf_sect_ptr[u];
3239
3240 if (phdr[i].p_filesz
3241 && phdr[i].p_offset <= (bfd_vma) sec->sh_offset
3242 && (bfd_vma)sec->sh_offset <= phdr[i].p_offset + (phdr[i].p_filesz - 1))
3243 {
3244 /* Found one! The difference between the two addresses,
3245 plus the difference between the two file offsets, is
3246 enough information to reconstruct the lma. */
3247
3248 /* Example where they aren't:
3249 PHDR[1] = lma fffc0100 offset 00002010 size 00000100
3250 SEC[6] = vma 00000050 offset 00002050 size 00000040
3251
3252 The correct LMA for the section is fffc0140 + (2050-2010).
3253 */
3254
3255 phdr[i].p_vaddr = sec->sh_addr + (sec->sh_offset - phdr[i].p_offset);
3256 break;
3257 }
3258 }
3259
3260 /* We must update the bfd sections as well, so we don't stop
3261 with one match. */
3262 bsec = abfd->sections;
3263 while (bsec)
3264 {
3265 if (phdr[i].p_filesz
3266 && phdr[i].p_vaddr <= bsec->vma
3267 && bsec->vma <= phdr[i].p_vaddr + (phdr[i].p_filesz - 1))
3268 {
3269 bsec->lma = phdr[i].p_paddr + (bsec->vma - phdr[i].p_vaddr);
3270 }
3271 bsec = bsec->next;
3272 }
3273 }
3274
3275 return TRUE;
3276 }
3277 \f
3278
3279 #ifdef DEBUG
3280 void
3281 rx_dump_symtab (bfd * abfd, void * internal_syms, void * external_syms)
3282 {
3283 size_t locsymcount;
3284 Elf_Internal_Sym * isymbuf;
3285 Elf_Internal_Sym * isymend;
3286 Elf_Internal_Sym * isym;
3287 Elf_Internal_Shdr * symtab_hdr;
3288 bfd_boolean free_internal = FALSE, free_external = FALSE;
3289 char * st_info_str;
3290 char * st_info_stb_str;
3291 char * st_other_str;
3292 char * st_shndx_str;
3293
3294 if (! internal_syms)
3295 {
3296 internal_syms = bfd_malloc (1000);
3297 free_internal = 1;
3298 }
3299 if (! external_syms)
3300 {
3301 external_syms = bfd_malloc (1000);
3302 free_external = 1;
3303 }
3304
3305 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3306 locsymcount = symtab_hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
3307 if (free_internal)
3308 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
3309 symtab_hdr->sh_info, 0,
3310 internal_syms, external_syms, NULL);
3311 else
3312 isymbuf = internal_syms;
3313 isymend = isymbuf + locsymcount;
3314
3315 for (isym = isymbuf ; isym < isymend ; isym++)
3316 {
3317 switch (ELF_ST_TYPE (isym->st_info))
3318 {
3319 case STT_FUNC: st_info_str = "STT_FUNC"; break;
3320 case STT_SECTION: st_info_str = "STT_SECTION"; break;
3321 case STT_FILE: st_info_str = "STT_FILE"; break;
3322 case STT_OBJECT: st_info_str = "STT_OBJECT"; break;
3323 case STT_TLS: st_info_str = "STT_TLS"; break;
3324 default: st_info_str = "";
3325 }
3326 switch (ELF_ST_BIND (isym->st_info))
3327 {
3328 case STB_LOCAL: st_info_stb_str = "STB_LOCAL"; break;
3329 case STB_GLOBAL: st_info_stb_str = "STB_GLOBAL"; break;
3330 default: st_info_stb_str = "";
3331 }
3332 switch (ELF_ST_VISIBILITY (isym->st_other))
3333 {
3334 case STV_DEFAULT: st_other_str = "STV_DEFAULT"; break;
3335 case STV_INTERNAL: st_other_str = "STV_INTERNAL"; break;
3336 case STV_PROTECTED: st_other_str = "STV_PROTECTED"; break;
3337 default: st_other_str = "";
3338 }
3339 switch (isym->st_shndx)
3340 {
3341 case SHN_ABS: st_shndx_str = "SHN_ABS"; break;
3342 case SHN_COMMON: st_shndx_str = "SHN_COMMON"; break;
3343 case SHN_UNDEF: st_shndx_str = "SHN_UNDEF"; break;
3344 default: st_shndx_str = "";
3345 }
3346
3347 printf ("isym = %p st_value = %lx st_size = %lx st_name = (%lu) %s "
3348 "st_info = (%d) %s %s st_other = (%d) %s st_shndx = (%d) %s\n",
3349 isym,
3350 (unsigned long) isym->st_value,
3351 (unsigned long) isym->st_size,
3352 isym->st_name,
3353 bfd_elf_string_from_elf_section (abfd, symtab_hdr->sh_link,
3354 isym->st_name),
3355 isym->st_info, st_info_str, st_info_stb_str,
3356 isym->st_other, st_other_str,
3357 isym->st_shndx, st_shndx_str);
3358 }
3359 if (free_internal)
3360 free (internal_syms);
3361 if (free_external)
3362 free (external_syms);
3363 }
3364
3365 char *
3366 rx_get_reloc (long reloc)
3367 {
3368 if (0 <= reloc && reloc < R_RX_max)
3369 return rx_elf_howto_table[reloc].name;
3370 return "";
3371 }
3372 #endif /* DEBUG */
3373
3374 \f
3375 /* We must take care to keep the on-disk copy of any code sections
3376 that are fully linked swapped if the target is big endian, to match
3377 the Renesas tools. */
3378
3379 /* The rule is: big endian object that are final-link executables,
3380 have code sections stored with 32-bit words swapped relative to
3381 what you'd get by default. */
3382
3383 static bfd_boolean
3384 rx_get_section_contents (bfd * abfd,
3385 sec_ptr section,
3386 void * location,
3387 file_ptr offset,
3388 bfd_size_type count)
3389 {
3390 int exec = (abfd->flags & EXEC_P) ? 1 : 0;
3391 int s_code = (section->flags & SEC_CODE) ? 1 : 0;
3392 bfd_boolean rv;
3393
3394 #ifdef DJDEBUG
3395 fprintf (stderr, "dj: get %ld %ld from %s %s e%d sc%d %08lx:%08lx\n",
3396 (long) offset, (long) count, section->name,
3397 bfd_big_endian(abfd) ? "be" : "le",
3398 exec, s_code, (long unsigned) section->filepos,
3399 (long unsigned) offset);
3400 #endif
3401
3402 if (exec && s_code && bfd_big_endian (abfd))
3403 {
3404 char * cloc = (char *) location;
3405 bfd_size_type cnt, end_cnt;
3406
3407 rv = TRUE;
3408
3409 /* Fetch and swap unaligned bytes at the beginning. */
3410 if (offset % 4)
3411 {
3412 char buf[4];
3413
3414 rv = _bfd_generic_get_section_contents (abfd, section, buf,
3415 (offset & -4), 4);
3416 if (!rv)
3417 return FALSE;
3418
3419 bfd_putb32 (bfd_getl32 (buf), buf);
3420
3421 cnt = 4 - (offset % 4);
3422 if (cnt > count)
3423 cnt = count;
3424
3425 memcpy (location, buf + (offset % 4), cnt);
3426
3427 count -= cnt;
3428 offset += cnt;
3429 cloc += count;
3430 }
3431
3432 end_cnt = count % 4;
3433
3434 /* Fetch and swap the middle bytes. */
3435 if (count >= 4)
3436 {
3437 rv = _bfd_generic_get_section_contents (abfd, section, cloc, offset,
3438 count - end_cnt);
3439 if (!rv)
3440 return FALSE;
3441
3442 for (cnt = count; cnt >= 4; cnt -= 4, cloc += 4)
3443 bfd_putb32 (bfd_getl32 (cloc), cloc);
3444 }
3445
3446 /* Fetch and swap the end bytes. */
3447 if (end_cnt > 0)
3448 {
3449 char buf[4];
3450
3451 /* Fetch the end bytes. */
3452 rv = _bfd_generic_get_section_contents (abfd, section, buf,
3453 offset + count - end_cnt, 4);
3454 if (!rv)
3455 return FALSE;
3456
3457 bfd_putb32 (bfd_getl32 (buf), buf);
3458 memcpy (cloc, buf, end_cnt);
3459 }
3460 }
3461 else
3462 rv = _bfd_generic_get_section_contents (abfd, section, location, offset, count);
3463
3464 return rv;
3465 }
3466
3467 #ifdef DJDEBUG
3468 static bfd_boolean
3469 rx2_set_section_contents (bfd * abfd,
3470 sec_ptr section,
3471 const void * location,
3472 file_ptr offset,
3473 bfd_size_type count)
3474 {
3475 bfd_size_type i;
3476
3477 fprintf (stderr, " set sec %s %08x loc %p offset %#x count %#x\n",
3478 section->name, (unsigned) section->vma, location, (int) offset, (int) count);
3479 for (i = 0; i < count; i++)
3480 {
3481 if (i % 16 == 0 && i > 0)
3482 fprintf (stderr, "\n");
3483
3484 if (i % 16 && i % 4 == 0)
3485 fprintf (stderr, " ");
3486
3487 if (i % 16 == 0)
3488 fprintf (stderr, " %08x:", (int) (section->vma + offset + i));
3489
3490 fprintf (stderr, " %02x", ((unsigned char *) location)[i]);
3491 }
3492 fprintf (stderr, "\n");
3493
3494 return _bfd_elf_set_section_contents (abfd, section, location, offset, count);
3495 }
3496 #define _bfd_elf_set_section_contents rx2_set_section_contents
3497 #endif
3498
3499 static bfd_boolean
3500 rx_set_section_contents (bfd * abfd,
3501 sec_ptr section,
3502 const void * location,
3503 file_ptr offset,
3504 bfd_size_type count)
3505 {
3506 bfd_boolean exec = (abfd->flags & EXEC_P) ? TRUE : FALSE;
3507 bfd_boolean s_code = (section->flags & SEC_CODE) ? TRUE : FALSE;
3508 bfd_boolean rv;
3509 char * swapped_data = NULL;
3510 bfd_size_type i;
3511 bfd_vma caddr = section->vma + offset;
3512 file_ptr faddr = 0;
3513 bfd_size_type scount;
3514
3515 #ifdef DJDEBUG
3516 bfd_size_type i;
3517
3518 fprintf (stderr, "\ndj: set %ld %ld to %s %s e%d sc%d\n",
3519 (long) offset, (long) count, section->name,
3520 bfd_big_endian (abfd) ? "be" : "le",
3521 exec, s_code);
3522
3523 for (i = 0; i < count; i++)
3524 {
3525 int a = section->vma + offset + i;
3526
3527 if (a % 16 == 0 && a > 0)
3528 fprintf (stderr, "\n");
3529
3530 if (a % 16 && a % 4 == 0)
3531 fprintf (stderr, " ");
3532
3533 if (a % 16 == 0 || i == 0)
3534 fprintf (stderr, " %08x:", (int) (section->vma + offset + i));
3535
3536 fprintf (stderr, " %02x", ((unsigned char *) location)[i]);
3537 }
3538
3539 fprintf (stderr, "\n");
3540 #endif
3541
3542 if (! exec || ! s_code || ! bfd_big_endian (abfd))
3543 return _bfd_elf_set_section_contents (abfd, section, location, offset, count);
3544
3545 while (count > 0 && caddr > 0 && caddr % 4)
3546 {
3547 switch (caddr % 4)
3548 {
3549 case 0: faddr = offset + 3; break;
3550 case 1: faddr = offset + 1; break;
3551 case 2: faddr = offset - 1; break;
3552 case 3: faddr = offset - 3; break;
3553 }
3554
3555 rv = _bfd_elf_set_section_contents (abfd, section, location, faddr, 1);
3556 if (! rv)
3557 return rv;
3558
3559 location ++;
3560 offset ++;
3561 count --;
3562 caddr ++;
3563 }
3564
3565 scount = (int)(count / 4) * 4;
3566 if (scount > 0)
3567 {
3568 char * cloc = (char *) location;
3569
3570 swapped_data = (char *) bfd_alloc (abfd, count);
3571
3572 for (i = 0; i < count; i += 4)
3573 {
3574 bfd_vma v = bfd_getl32 (cloc + i);
3575 bfd_putb32 (v, swapped_data + i);
3576 }
3577
3578 rv = _bfd_elf_set_section_contents (abfd, section, swapped_data, offset, scount);
3579
3580 if (!rv)
3581 return rv;
3582 }
3583
3584 count -= scount;
3585 location += scount;
3586 offset += scount;
3587
3588 if (count > 0)
3589 {
3590 caddr = section->vma + offset;
3591 while (count > 0)
3592 {
3593 switch (caddr % 4)
3594 {
3595 case 0: faddr = offset + 3; break;
3596 case 1: faddr = offset + 1; break;
3597 case 2: faddr = offset - 1; break;
3598 case 3: faddr = offset - 3; break;
3599 }
3600 rv = _bfd_elf_set_section_contents (abfd, section, location, faddr, 1);
3601 if (! rv)
3602 return rv;
3603
3604 location ++;
3605 offset ++;
3606 count --;
3607 caddr ++;
3608 }
3609 }
3610
3611 return TRUE;
3612 }
3613
3614 static bfd_boolean
3615 rx_final_link (bfd * abfd, struct bfd_link_info * info)
3616 {
3617 asection * o;
3618
3619 for (o = abfd->sections; o != NULL; o = o->next)
3620 {
3621 #ifdef DJDEBUG
3622 fprintf (stderr, "sec %s fl %x vma %lx lma %lx size %lx raw %lx\n",
3623 o->name, o->flags, o->vma, o->lma, o->size, o->rawsize);
3624 #endif
3625 if (o->flags & SEC_CODE
3626 && bfd_big_endian (abfd)
3627 && o->size % 4)
3628 {
3629 #ifdef DJDEBUG
3630 fprintf (stderr, "adjusting...\n");
3631 #endif
3632 o->size += 4 - (o->size % 4);
3633 }
3634 }
3635
3636 return bfd_elf_final_link (abfd, info);
3637 }
3638
3639 static bfd_boolean
3640 elf32_rx_modify_program_headers (bfd * abfd ATTRIBUTE_UNUSED,
3641 struct bfd_link_info * info ATTRIBUTE_UNUSED)
3642 {
3643 const struct elf_backend_data * bed;
3644 struct elf_obj_tdata * tdata;
3645 Elf_Internal_Phdr * phdr;
3646 unsigned int count;
3647 unsigned int i;
3648
3649 bed = get_elf_backend_data (abfd);
3650 tdata = elf_tdata (abfd);
3651 phdr = tdata->phdr;
3652 count = elf_program_header_size (abfd) / bed->s->sizeof_phdr;
3653
3654 if (ignore_lma)
3655 for (i = count; i-- != 0;)
3656 if (phdr[i].p_type == PT_LOAD)
3657 {
3658 /* The Renesas tools expect p_paddr to be zero. However,
3659 there is no other way to store the writable data in ROM for
3660 startup initialization. So, we let the linker *think*
3661 we're using paddr and vaddr the "usual" way, but at the
3662 last minute we move the paddr into the vaddr (which is what
3663 the simulator uses) and zero out paddr. Note that this
3664 does not affect the section headers, just the program
3665 headers. We hope. */
3666 phdr[i].p_vaddr = phdr[i].p_paddr;
3667 #if 0 /* If we zero out p_paddr, then the LMA in the section table
3668 becomes wrong. */
3669 phdr[i].p_paddr = 0;
3670 #endif
3671 }
3672
3673 return TRUE;
3674 }
3675
3676 /* The default literal sections should always be marked as "code" (i.e.,
3677 SHF_EXECINSTR). This is particularly important for big-endian mode
3678 when we do not want their contents byte reversed. */
3679 static const struct bfd_elf_special_section elf32_rx_special_sections[] =
3680 {
3681 { STRING_COMMA_LEN (".init_array"), 0, SHT_INIT_ARRAY, SHF_ALLOC + SHF_EXECINSTR },
3682 { STRING_COMMA_LEN (".fini_array"), 0, SHT_FINI_ARRAY, SHF_ALLOC + SHF_EXECINSTR },
3683 { STRING_COMMA_LEN (".preinit_array"), 0, SHT_PREINIT_ARRAY, SHF_ALLOC + SHF_EXECINSTR },
3684 { NULL, 0, 0, 0, 0 }
3685 };
3686 \f
3687 typedef struct {
3688 bfd *abfd;
3689 struct bfd_link_info *info;
3690 bfd_vma table_start;
3691 int table_size;
3692 bfd_vma *table_handlers;
3693 bfd_vma table_default_handler;
3694 struct bfd_link_hash_entry **table_entries;
3695 struct bfd_link_hash_entry *table_default_entry;
3696 FILE *mapfile;
3697 } RX_Table_Info;
3698
3699 static bfd_boolean
3700 rx_table_find (struct bfd_hash_entry *vent, void *vinfo)
3701 {
3702 RX_Table_Info *info = (RX_Table_Info *)vinfo;
3703 struct bfd_link_hash_entry *ent = (struct bfd_link_hash_entry *)vent;
3704 const char *name; /* of the symbol we've found */
3705 asection *sec;
3706 struct bfd *abfd;
3707 int idx;
3708 const char *tname; /* name of the table */
3709 bfd_vma start_addr, end_addr;
3710 char *buf;
3711 struct bfd_link_hash_entry * h;
3712
3713 /* We're looking for globally defined symbols of the form
3714 $tablestart$<NAME>. */
3715 if (ent->type != bfd_link_hash_defined
3716 && ent->type != bfd_link_hash_defweak)
3717 return TRUE;
3718
3719 name = ent->root.string;
3720 sec = ent->u.def.section;
3721 abfd = sec->owner;
3722
3723 if (strncmp (name, "$tablestart$", 12))
3724 return TRUE;
3725
3726 sec->flags |= SEC_KEEP;
3727
3728 tname = name + 12;
3729
3730 start_addr = ent->u.def.value;
3731
3732 /* At this point, we can't build the table but we can (and must)
3733 find all the related symbols and mark their sections as SEC_KEEP
3734 so we don't garbage collect them. */
3735
3736 buf = (char *) malloc (12 + 10 + strlen (tname));
3737
3738 sprintf (buf, "$tableend$%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 _bfd_error_handler (_("%B:%A: table %s missing corresponding %s"),
3744 abfd, sec, name, buf);
3745 return TRUE;
3746 }
3747
3748 if (h->u.def.section != ent->u.def.section)
3749 {
3750 _bfd_error_handler (_("%B:%A: %s and %s must be in the same input section"),
3751 h->u.def.section->owner, h->u.def.section,
3752 name, buf);
3753 return TRUE;
3754 }
3755
3756 end_addr = h->u.def.value;
3757
3758 sprintf (buf, "$tableentry$default$%s", tname);
3759 h = bfd_link_hash_lookup (info->info->hash, buf, FALSE, FALSE, TRUE);
3760 if (h && (h->type == bfd_link_hash_defined
3761 || h->type == bfd_link_hash_defweak))
3762 {
3763 h->u.def.section->flags |= SEC_KEEP;
3764 }
3765
3766 for (idx = 0; idx < (int) (end_addr - start_addr) / 4; idx ++)
3767 {
3768 sprintf (buf, "$tableentry$%d$%s", idx, tname);
3769 h = bfd_link_hash_lookup (info->info->hash, buf, FALSE, FALSE, TRUE);
3770 if (h && (h->type == bfd_link_hash_defined
3771 || h->type == bfd_link_hash_defweak))
3772 {
3773 h->u.def.section->flags |= SEC_KEEP;
3774 }
3775 }
3776
3777 /* Return TRUE to keep scanning, FALSE to end the traversal. */
3778 return TRUE;
3779 }
3780
3781 /* We need to check for table entry symbols and build the tables, and
3782 we need to do it before the linker does garbage collection. This function is
3783 called once per input object file. */
3784 static bfd_boolean
3785 rx_check_directives
3786 (bfd * abfd ATTRIBUTE_UNUSED,
3787 struct bfd_link_info * info ATTRIBUTE_UNUSED)
3788 {
3789 RX_Table_Info stuff;
3790
3791 stuff.abfd = abfd;
3792 stuff.info = info;
3793 bfd_hash_traverse (&(info->hash->table), rx_table_find, &stuff);
3794
3795 return TRUE;
3796 }
3797
3798 \f
3799 static bfd_boolean
3800 rx_table_map_2 (struct bfd_hash_entry *vent, void *vinfo)
3801 {
3802 RX_Table_Info *info = (RX_Table_Info *)vinfo;
3803 struct bfd_link_hash_entry *ent = (struct bfd_link_hash_entry *)vent;
3804 int idx;
3805 const char *name;
3806 bfd_vma addr;
3807
3808 /* See if the symbol ENT has an address listed in the table, and
3809 isn't a debug/special symbol. If so, put it in the table. */
3810
3811 if (ent->type != bfd_link_hash_defined
3812 && ent->type != bfd_link_hash_defweak)
3813 return TRUE;
3814
3815 name = ent->root.string;
3816
3817 if (name[0] == '$' || name[0] == '.' || name[0] < ' ')
3818 return TRUE;
3819
3820 addr = (ent->u.def.value
3821 + ent->u.def.section->output_section->vma
3822 + ent->u.def.section->output_offset);
3823
3824 for (idx = 0; idx < info->table_size; idx ++)
3825 if (addr == info->table_handlers[idx])
3826 info->table_entries[idx] = ent;
3827
3828 if (addr == info->table_default_handler)
3829 info->table_default_entry = ent;
3830
3831 return TRUE;
3832 }
3833
3834 static bfd_boolean
3835 rx_table_map (struct bfd_hash_entry *vent, void *vinfo)
3836 {
3837 RX_Table_Info *info = (RX_Table_Info *)vinfo;
3838 struct bfd_link_hash_entry *ent = (struct bfd_link_hash_entry *)vent;
3839 const char *name; /* of the symbol we've found */
3840 int idx;
3841 const char *tname; /* name of the table */
3842 bfd_vma start_addr, end_addr;
3843 char *buf;
3844 struct bfd_link_hash_entry * h;
3845 int need_elipses;
3846
3847 /* We're looking for globally defined symbols of the form
3848 $tablestart$<NAME>. */
3849 if (ent->type != bfd_link_hash_defined
3850 && ent->type != bfd_link_hash_defweak)
3851 return TRUE;
3852
3853 name = ent->root.string;
3854
3855 if (strncmp (name, "$tablestart$", 12))
3856 return TRUE;
3857
3858 tname = name + 12;
3859 start_addr = (ent->u.def.value
3860 + ent->u.def.section->output_section->vma
3861 + ent->u.def.section->output_offset);
3862
3863 buf = (char *) malloc (12 + 10 + strlen (tname));
3864
3865 sprintf (buf, "$tableend$%s", tname);
3866 end_addr = get_symbol_value_maybe (buf, info->info);
3867
3868 sprintf (buf, "$tableentry$default$%s", tname);
3869 h = bfd_link_hash_lookup (info->info->hash, buf, FALSE, FALSE, TRUE);
3870 if (h)
3871 {
3872 info->table_default_handler = (h->u.def.value
3873 + h->u.def.section->output_section->vma
3874 + h->u.def.section->output_offset);
3875 }
3876 else
3877 /* Zero is a valid handler address! */
3878 info->table_default_handler = (bfd_vma) (-1);
3879 info->table_default_entry = NULL;
3880
3881 info->table_start = start_addr;
3882 info->table_size = (int) (end_addr - start_addr) / 4;
3883 info->table_handlers = (bfd_vma *) malloc (info->table_size * sizeof (bfd_vma));
3884 info->table_entries = (struct bfd_link_hash_entry **) malloc (info->table_size * sizeof (struct bfd_link_hash_entry));
3885
3886 for (idx = 0; idx < (int) (end_addr - start_addr) / 4; idx ++)
3887 {
3888 sprintf (buf, "$tableentry$%d$%s", idx, tname);
3889 h = bfd_link_hash_lookup (info->info->hash, buf, FALSE, FALSE, TRUE);
3890 if (h && (h->type == bfd_link_hash_defined
3891 || h->type == bfd_link_hash_defweak))
3892 {
3893 info->table_handlers[idx] = (h->u.def.value
3894 + h->u.def.section->output_section->vma
3895 + h->u.def.section->output_offset);
3896 }
3897 else
3898 info->table_handlers[idx] = info->table_default_handler;
3899 info->table_entries[idx] = NULL;
3900 }
3901
3902 free (buf);
3903
3904 bfd_hash_traverse (&(info->info->hash->table), rx_table_map_2, info);
3905
3906 fprintf (info->mapfile, "\nRX Vector Table: %s has %d entries at 0x%08" BFD_VMA_FMT "x\n\n",
3907 tname, info->table_size, start_addr);
3908
3909 if (info->table_default_entry)
3910 fprintf (info->mapfile, " default handler is: %s at 0x%08" BFD_VMA_FMT "x\n",
3911 info->table_default_entry->root.string,
3912 info->table_default_handler);
3913 else if (info->table_default_handler != (bfd_vma)(-1))
3914 fprintf (info->mapfile, " default handler is at 0x%08" BFD_VMA_FMT "x\n",
3915 info->table_default_handler);
3916 else
3917 fprintf (info->mapfile, " no default handler\n");
3918
3919 need_elipses = 1;
3920 for (idx = 0; idx < info->table_size; idx ++)
3921 {
3922 if (info->table_handlers[idx] == info->table_default_handler)
3923 {
3924 if (need_elipses)
3925 fprintf (info->mapfile, " . . .\n");
3926 need_elipses = 0;
3927 continue;
3928 }
3929 need_elipses = 1;
3930
3931 fprintf (info->mapfile, " 0x%08" BFD_VMA_FMT "x [%3d] ", start_addr + 4 * idx, idx);
3932
3933 if (info->table_handlers[idx] == (bfd_vma) (-1))
3934 fprintf (info->mapfile, "(no handler found)\n");
3935
3936 else if (info->table_handlers[idx] == info->table_default_handler)
3937 {
3938 if (info->table_default_entry)
3939 fprintf (info->mapfile, "(default)\n");
3940 else
3941 fprintf (info->mapfile, "(default)\n");
3942 }
3943
3944 else if (info->table_entries[idx])
3945 {
3946 fprintf (info->mapfile, "0x%08" BFD_VMA_FMT "x %s\n", info->table_handlers[idx], info->table_entries[idx]->root.string);
3947 }
3948
3949 else
3950 {
3951 fprintf (info->mapfile, "0x%08" BFD_VMA_FMT "x ???\n", info->table_handlers[idx]);
3952 }
3953 }
3954 if (need_elipses)
3955 fprintf (info->mapfile, " . . .\n");
3956
3957 return TRUE;
3958 }
3959
3960 void
3961 rx_additional_link_map_text (bfd *obfd, struct bfd_link_info *info, FILE *mapfile)
3962 {
3963 /* We scan the symbol table looking for $tableentry$'s, and for
3964 each, try to deduce which handlers go with which entries. */
3965
3966 RX_Table_Info stuff;
3967
3968 stuff.abfd = obfd;
3969 stuff.info = info;
3970 stuff.mapfile = mapfile;
3971 bfd_hash_traverse (&(info->hash->table), rx_table_map, &stuff);
3972 }
3973
3974 \f
3975 #define ELF_ARCH bfd_arch_rx
3976 #define ELF_MACHINE_CODE EM_RX
3977 #define ELF_MAXPAGESIZE 0x1000
3978
3979 #define TARGET_BIG_SYM rx_elf32_be_vec
3980 #define TARGET_BIG_NAME "elf32-rx-be"
3981
3982 #define TARGET_LITTLE_SYM rx_elf32_le_vec
3983 #define TARGET_LITTLE_NAME "elf32-rx-le"
3984
3985 #define elf_info_to_howto_rel NULL
3986 #define elf_info_to_howto rx_info_to_howto_rela
3987 #define elf_backend_object_p rx_elf_object_p
3988 #define elf_backend_relocate_section rx_elf_relocate_section
3989 #define elf_symbol_leading_char ('_')
3990 #define elf_backend_can_gc_sections 1
3991 #define elf_backend_modify_program_headers elf32_rx_modify_program_headers
3992
3993 #define bfd_elf32_bfd_reloc_type_lookup rx_reloc_type_lookup
3994 #define bfd_elf32_bfd_reloc_name_lookup rx_reloc_name_lookup
3995 #define bfd_elf32_bfd_set_private_flags rx_elf_set_private_flags
3996 #define bfd_elf32_bfd_merge_private_bfd_data rx_elf_merge_private_bfd_data
3997 #define bfd_elf32_bfd_print_private_bfd_data rx_elf_print_private_bfd_data
3998 #define bfd_elf32_get_section_contents rx_get_section_contents
3999 #define bfd_elf32_set_section_contents rx_set_section_contents
4000 #define bfd_elf32_bfd_final_link rx_final_link
4001 #define bfd_elf32_bfd_relax_section elf32_rx_relax_section_wrapper
4002 #define elf_backend_special_sections elf32_rx_special_sections
4003 #define elf_backend_check_directives rx_check_directives
4004
4005 #include "elf32-target.h"
4006
4007 /* We define a second big-endian target that doesn't have the custom
4008 section get/set hooks, for times when we want to preserve the
4009 pre-swapped .text sections (like objcopy). */
4010
4011 #undef TARGET_BIG_SYM
4012 #define TARGET_BIG_SYM rx_elf32_be_ns_vec
4013 #undef TARGET_BIG_NAME
4014 #define TARGET_BIG_NAME "elf32-rx-be-ns"
4015 #undef TARGET_LITTLE_SYM
4016
4017 #undef bfd_elf32_get_section_contents
4018 #undef bfd_elf32_set_section_contents
4019
4020 #undef elf32_bed
4021 #define elf32_bed elf32_rx_be_ns_bed
4022
4023 #include "elf32-target.h"
The GNU Binutils are a collection of binary tools.