projects / deliverable / binutils-gdb.git / blob
? search:


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