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