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