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