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