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