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