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