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