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