?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update my e-mail address.
[binutils-gdb.git] / bfd / elf32-crx.c
blob5b330bd1d0c9f083568f33613a7798089e364021
1 /* BFD back-end for National Semiconductor's CRX ELF
2 Copyright (C) 2004-2017 Free Software Foundation, Inc.
3 Written by Tomer Levi, NSC, Israel.
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., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
21
22 #include "sysdep.h"
23 #include "bfd.h"
24 #include "bfdlink.h"
25 #include "libbfd.h"
26 #include "elf-bfd.h"
27 #include "elf/crx.h"
28
29 static reloc_howto_type *elf_crx_reloc_type_lookup
30 (bfd *, bfd_reloc_code_real_type);
31 static void elf_crx_info_to_howto
32 (bfd *, arelent *, Elf_Internal_Rela *);
33 static bfd_boolean elf32_crx_relax_delete_bytes
34 (struct bfd_link_info *, bfd *, asection *, bfd_vma, int);
35 static bfd_reloc_status_type crx_elf_final_link_relocate
36 (reloc_howto_type *, bfd *, bfd *, asection *,
37 bfd_byte *, bfd_vma, bfd_vma, bfd_vma,
38 struct bfd_link_info *, asection *, int);
39 static bfd_boolean elf32_crx_relocate_section
40 (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
41 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **);
42 static bfd_boolean elf32_crx_relax_section
43 (bfd *, asection *, struct bfd_link_info *, bfd_boolean *);
44 static bfd_byte * elf32_crx_get_relocated_section_contents
45 (bfd *, struct bfd_link_info *, struct bfd_link_order *,
46 bfd_byte *, bfd_boolean, asymbol **);
47
48 /* crx_reloc_map array maps BFD relocation enum into a CRGAS relocation type. */
49
50 struct crx_reloc_map
51 {
52 bfd_reloc_code_real_type bfd_reloc_enum; /* BFD relocation enum. */
53 unsigned short crx_reloc_type; /* CRX relocation type. */
54 };
55
56 static const struct crx_reloc_map crx_reloc_map[R_CRX_MAX] =
57 {
58 {BFD_RELOC_NONE, R_CRX_NONE},
59 {BFD_RELOC_CRX_REL4, R_CRX_REL4},
60 {BFD_RELOC_CRX_REL8, R_CRX_REL8},
61 {BFD_RELOC_CRX_REL8_CMP, R_CRX_REL8_CMP},
62 {BFD_RELOC_CRX_REL16, R_CRX_REL16},
63 {BFD_RELOC_CRX_REL24, R_CRX_REL24},
64 {BFD_RELOC_CRX_REL32, R_CRX_REL32},
65 {BFD_RELOC_CRX_REGREL12, R_CRX_REGREL12},
66 {BFD_RELOC_CRX_REGREL22, R_CRX_REGREL22},
67 {BFD_RELOC_CRX_REGREL28, R_CRX_REGREL28},
68 {BFD_RELOC_CRX_REGREL32, R_CRX_REGREL32},
69 {BFD_RELOC_CRX_ABS16, R_CRX_ABS16},
70 {BFD_RELOC_CRX_ABS32, R_CRX_ABS32},
71 {BFD_RELOC_CRX_NUM8, R_CRX_NUM8},
72 {BFD_RELOC_CRX_NUM16, R_CRX_NUM16},
73 {BFD_RELOC_CRX_NUM32, R_CRX_NUM32},
74 {BFD_RELOC_CRX_IMM16, R_CRX_IMM16},
75 {BFD_RELOC_CRX_IMM32, R_CRX_IMM32},
76 {BFD_RELOC_CRX_SWITCH8, R_CRX_SWITCH8},
77 {BFD_RELOC_CRX_SWITCH16, R_CRX_SWITCH16},
78 {BFD_RELOC_CRX_SWITCH32, R_CRX_SWITCH32}
79 };
80
81 static reloc_howto_type crx_elf_howto_table[] =
82 {
83 HOWTO (R_CRX_NONE, /* type */
84 0, /* rightshift */
85 3, /* size */
86 0, /* bitsize */
87 FALSE, /* pc_relative */
88 0, /* bitpos */
89 complain_overflow_dont,/* complain_on_overflow */
90 bfd_elf_generic_reloc, /* special_function */
91 "R_CRX_NONE", /* name */
92 FALSE, /* partial_inplace */
93 0, /* src_mask */
94 0, /* dst_mask */
95 FALSE), /* pcrel_offset */
96
97 HOWTO (R_CRX_REL4, /* type */
98 1, /* rightshift */
99 0, /* size */
100 4, /* bitsize */
101 TRUE, /* pc_relative */
102 0, /* bitpos */
103 complain_overflow_bitfield,/* complain_on_overflow */
104 bfd_elf_generic_reloc, /* special_function */
105 "R_CRX_REL4", /* name */
106 FALSE, /* partial_inplace */
107 0x0, /* src_mask */
108 0xf, /* dst_mask */
109 FALSE), /* pcrel_offset */
110
111 HOWTO (R_CRX_REL8, /* type */
112 1, /* rightshift */
113 0, /* size */
114 8, /* bitsize */
115 TRUE, /* pc_relative */
116 0, /* bitpos */
117 complain_overflow_bitfield,/* complain_on_overflow */
118 bfd_elf_generic_reloc, /* special_function */
119 "R_CRX_REL8", /* name */
120 FALSE, /* partial_inplace */
121 0x0, /* src_mask */
122 0xff, /* dst_mask */
123 FALSE), /* pcrel_offset */
124
125 HOWTO (R_CRX_REL8_CMP, /* type */
126 1, /* rightshift */
127 0, /* size */
128 8, /* bitsize */
129 TRUE, /* pc_relative */
130 0, /* bitpos */
131 complain_overflow_bitfield,/* complain_on_overflow */
132 bfd_elf_generic_reloc, /* special_function */
133 "R_CRX_REL8_CMP", /* name */
134 FALSE, /* partial_inplace */
135 0x0, /* src_mask */
136 0xff, /* dst_mask */
137 FALSE), /* pcrel_offset */
138
139 HOWTO (R_CRX_REL16, /* type */
140 1, /* rightshift */
141 1, /* size */
142 16, /* bitsize */
143 TRUE, /* pc_relative */
144 0, /* bitpos */
145 complain_overflow_bitfield,/* complain_on_overflow */
146 bfd_elf_generic_reloc, /* special_function */
147 "R_CRX_REL16", /* name */
148 FALSE, /* partial_inplace */
149 0x0, /* src_mask */
150 0xffff, /* dst_mask */
151 FALSE), /* pcrel_offset */
152
153 HOWTO (R_CRX_REL24, /* type */
154 1, /* rightshift */
155 2, /* size */
156 24, /* bitsize */
157 TRUE, /* pc_relative */
158 0, /* bitpos */
159 complain_overflow_bitfield,/* complain_on_overflow */
160 bfd_elf_generic_reloc, /* special_function */
161 "R_CRX_REL24", /* name */
162 FALSE, /* partial_inplace */
163 0x0, /* src_mask */
164 0xffffff, /* dst_mask */
165 FALSE), /* pcrel_offset */
166
167 HOWTO (R_CRX_REL32, /* type */
168 1, /* rightshift */
169 2, /* size */
170 32, /* bitsize */
171 TRUE, /* pc_relative */
172 0, /* bitpos */
173 complain_overflow_bitfield,/* complain_on_overflow */
174 bfd_elf_generic_reloc, /* special_function */
175 "R_CRX_REL32", /* name */
176 FALSE, /* partial_inplace */
177 0x0, /* src_mask */
178 0xffffffff, /* dst_mask */
179 FALSE), /* pcrel_offset */
180
181 HOWTO (R_CRX_REGREL12, /* type */
182 0, /* rightshift */
183 1, /* size */
184 12, /* bitsize */
185 FALSE, /* pc_relative */
186 0, /* bitpos */
187 complain_overflow_bitfield,/* complain_on_overflow */
188 bfd_elf_generic_reloc, /* special_function */
189 "R_CRX_REGREL12", /* name */
190 FALSE, /* partial_inplace */
191 0x0, /* src_mask */
192 0xfff, /* dst_mask */
193 FALSE), /* pcrel_offset */
194
195 HOWTO (R_CRX_REGREL22, /* type */
196 0, /* rightshift */
197 2, /* size */
198 22, /* bitsize */
199 FALSE, /* pc_relative */
200 0, /* bitpos */
201 complain_overflow_bitfield,/* complain_on_overflow */
202 bfd_elf_generic_reloc, /* special_function */
203 "R_CRX_REGREL22", /* name */
204 FALSE, /* partial_inplace */
205 0x0, /* src_mask */
206 0x3fffff, /* dst_mask */
207 FALSE), /* pcrel_offset */
208
209 HOWTO (R_CRX_REGREL28, /* type */
210 0, /* rightshift */
211 2, /* size */
212 28, /* bitsize */
213 FALSE, /* pc_relative */
214 0, /* bitpos */
215 complain_overflow_bitfield,/* complain_on_overflow */
216 bfd_elf_generic_reloc, /* special_function */
217 "R_CRX_REGREL28", /* name */
218 FALSE, /* partial_inplace */
219 0x0, /* src_mask */
220 0xfffffff, /* dst_mask */
221 FALSE), /* pcrel_offset */
222
223 HOWTO (R_CRX_REGREL32, /* type */
224 0, /* rightshift */
225 2, /* size */
226 32, /* bitsize */
227 FALSE, /* pc_relative */
228 0, /* bitpos */
229 complain_overflow_bitfield,/* complain_on_overflow */
230 bfd_elf_generic_reloc, /* special_function */
231 "R_CRX_REGREL32", /* name */
232 FALSE, /* partial_inplace */
233 0x0, /* src_mask */
234 0xffffffff, /* dst_mask */
235 FALSE), /* pcrel_offset */
236
237 HOWTO (R_CRX_ABS16, /* type */
238 0, /* rightshift */
239 1, /* size */
240 16, /* bitsize */
241 FALSE, /* pc_relative */
242 0, /* bitpos */
243 complain_overflow_bitfield,/* complain_on_overflow */
244 bfd_elf_generic_reloc, /* special_function */
245 "R_CRX_ABS16", /* name */
246 FALSE, /* partial_inplace */
247 0x0, /* src_mask */
248 0xffff, /* dst_mask */
249 FALSE), /* pcrel_offset */
250
251 HOWTO (R_CRX_ABS32, /* type */
252 0, /* rightshift */
253 2, /* size */
254 32, /* bitsize */
255 FALSE, /* pc_relative */
256 0, /* bitpos */
257 complain_overflow_bitfield,/* complain_on_overflow */
258 bfd_elf_generic_reloc, /* special_function */
259 "R_CRX_ABS32", /* name */
260 FALSE, /* partial_inplace */
261 0x0, /* src_mask */
262 0xffffffff, /* dst_mask */
263 FALSE), /* pcrel_offset */
264
265 HOWTO (R_CRX_NUM8, /* type */
266 0, /* rightshift */
267 0, /* size */
268 8, /* bitsize */
269 FALSE, /* pc_relative */
270 0, /* bitpos */
271 complain_overflow_bitfield,/* complain_on_overflow */
272 bfd_elf_generic_reloc, /* special_function */
273 "R_CRX_NUM8", /* name */
274 FALSE, /* partial_inplace */
275 0x0, /* src_mask */
276 0xff, /* dst_mask */
277 FALSE), /* pcrel_offset */
278
279 HOWTO (R_CRX_NUM16, /* type */
280 0, /* rightshift */
281 1, /* size */
282 16, /* bitsize */
283 FALSE, /* pc_relative */
284 0, /* bitpos */
285 complain_overflow_bitfield,/* complain_on_overflow */
286 bfd_elf_generic_reloc, /* special_function */
287 "R_CRX_NUM16", /* name */
288 FALSE, /* partial_inplace */
289 0x0, /* src_mask */
290 0xffff, /* dst_mask */
291 FALSE), /* pcrel_offset */
292
293 HOWTO (R_CRX_NUM32, /* type */
294 0, /* rightshift */
295 2, /* size */
296 32, /* bitsize */
297 FALSE, /* pc_relative */
298 0, /* bitpos */
299 complain_overflow_bitfield,/* complain_on_overflow */
300 bfd_elf_generic_reloc, /* special_function */
301 "R_CRX_NUM32", /* name */
302 FALSE, /* partial_inplace */
303 0x0, /* src_mask */
304 0xffffffff, /* dst_mask */
305 FALSE), /* pcrel_offset */
306
307 HOWTO (R_CRX_IMM16, /* type */
308 0, /* rightshift */
309 1, /* size */
310 16, /* bitsize */
311 FALSE, /* pc_relative */
312 0, /* bitpos */
313 complain_overflow_bitfield,/* complain_on_overflow */
314 bfd_elf_generic_reloc, /* special_function */
315 "R_CRX_IMM16", /* name */
316 FALSE, /* partial_inplace */
317 0x0, /* src_mask */
318 0xffff, /* dst_mask */
319 FALSE), /* pcrel_offset */
320
321 HOWTO (R_CRX_IMM32, /* type */
322 0, /* rightshift */
323 2, /* size */
324 32, /* bitsize */
325 FALSE, /* pc_relative */
326 0, /* bitpos */
327 complain_overflow_bitfield,/* complain_on_overflow */
328 bfd_elf_generic_reloc, /* special_function */
329 "R_CRX_IMM32", /* name */
330 FALSE, /* partial_inplace */
331 0x0, /* src_mask */
332 0xffffffff, /* dst_mask */
333 FALSE), /* pcrel_offset */
334
335 /* An 8 bit switch table entry. This is generated for an expression
336 such as ``.byte L1 - L2''. The offset holds the difference
337 between the reloc address and L2. */
338 HOWTO (R_CRX_SWITCH8, /* type */
339 0, /* rightshift */
340 0, /* size (0 = byte, 1 = short, 2 = long) */
341 8, /* bitsize */
342 FALSE, /* pc_relative */
343 0, /* bitpos */
344 complain_overflow_unsigned, /* complain_on_overflow */
345 bfd_elf_generic_reloc, /* special_function */
346 "R_CRX_SWITCH8", /* name */
347 FALSE, /* partial_inplace */
348 0x0, /* src_mask */
349 0xff, /* dst_mask */
350 TRUE), /* pcrel_offset */
351
352 /* A 16 bit switch table entry. This is generated for an expression
353 such as ``.word L1 - L2''. The offset holds the difference
354 between the reloc address and L2. */
355 HOWTO (R_CRX_SWITCH16, /* type */
356 0, /* rightshift */
357 1, /* size (0 = byte, 1 = short, 2 = long) */
358 16, /* bitsize */
359 FALSE, /* pc_relative */
360 0, /* bitpos */
361 complain_overflow_unsigned, /* complain_on_overflow */
362 bfd_elf_generic_reloc, /* special_function */
363 "R_CRX_SWITCH16", /* name */
364 FALSE, /* partial_inplace */
365 0x0, /* src_mask */
366 0xffff, /* dst_mask */
367 TRUE), /* pcrel_offset */
368
369 /* A 32 bit switch table entry. This is generated for an expression
370 such as ``.long L1 - L2''. The offset holds the difference
371 between the reloc address and L2. */
372 HOWTO (R_CRX_SWITCH32, /* type */
373 0, /* rightshift */
374 2, /* size (0 = byte, 1 = short, 2 = long) */
375 32, /* bitsize */
376 FALSE, /* pc_relative */
377 0, /* bitpos */
378 complain_overflow_unsigned, /* complain_on_overflow */
379 bfd_elf_generic_reloc, /* special_function */
380 "R_CRX_SWITCH32", /* name */
381 FALSE, /* partial_inplace */
382 0x0, /* src_mask */
383 0xffffffff, /* dst_mask */
384 TRUE) /* pcrel_offset */
385 };
386
387 /* Retrieve a howto ptr using a BFD reloc_code. */
388
389 static reloc_howto_type *
390 elf_crx_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
391 bfd_reloc_code_real_type code)
392 {
393 unsigned int i;
394
395 for (i = 0; i < R_CRX_MAX; i++)
396 if (code == crx_reloc_map[i].bfd_reloc_enum)
397 return &crx_elf_howto_table[crx_reloc_map[i].crx_reloc_type];
398
399 printf ("This relocation Type is not supported -0x%x\n", code);
400 return 0;
401 }
402
403 static reloc_howto_type *
404 elf_crx_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
405 const char *r_name)
406 {
407 unsigned int i;
408
409 for (i = 0;
410 i < sizeof (crx_elf_howto_table) / sizeof (crx_elf_howto_table[0]);
411 i++)
412 if (crx_elf_howto_table[i].name != NULL
413 && strcasecmp (crx_elf_howto_table[i].name, r_name) == 0)
414 return &crx_elf_howto_table[i];
415
416 return NULL;
417 }
418
419 /* Retrieve a howto ptr using an internal relocation entry. */
420
421 static void
422 elf_crx_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
423 Elf_Internal_Rela *dst)
424 {
425 unsigned int r_type = ELF32_R_TYPE (dst->r_info);
426 if (r_type >= R_CRX_MAX)
427 {
428 /* xgettext:c-format */
429 _bfd_error_handler (_("%B: unrecognised CRX reloc number: %d"),
430 abfd, r_type);
431 bfd_set_error (bfd_error_bad_value);
432 r_type = R_CRX_NONE;
433 }
434 cache_ptr->howto = &crx_elf_howto_table[r_type];
435 }
436
437 /* Perform a relocation as part of a final link. */
438
439 static bfd_reloc_status_type
440 crx_elf_final_link_relocate (reloc_howto_type *howto, bfd *input_bfd,
441 bfd *output_bfd ATTRIBUTE_UNUSED,
442 asection *input_section, bfd_byte *contents,
443 bfd_vma offset, bfd_vma Rvalue, bfd_vma addend,
444 struct bfd_link_info *info ATTRIBUTE_UNUSED,
445 asection *sec ATTRIBUTE_UNUSED,
446 int is_local ATTRIBUTE_UNUSED)
447 {
448 unsigned short r_type = howto->type;
449 bfd_byte *hit_data = contents + offset;
450 bfd_vma reloc_bits, check;
451
452 switch (r_type)
453 {
454 case R_CRX_IMM16:
455 case R_CRX_IMM32:
456 case R_CRX_ABS16:
457 case R_CRX_ABS32:
458 case R_CRX_REL8_CMP:
459 case R_CRX_REL16:
460 case R_CRX_REL24:
461 case R_CRX_REL32:
462 case R_CRX_REGREL12:
463 case R_CRX_REGREL22:
464 case R_CRX_REGREL28:
465 case R_CRX_REGREL32:
466 /* 'hit_data' is relative to the start of the instruction, not the
467 relocation offset. Advance it to account for the exact offset. */
468 hit_data += 2;
469 break;
470
471 case R_CRX_REL4:
472 /* This relocation type is used only in 'Branch if Equal to 0'
473 instructions and requires special handling. */
474 Rvalue -= 1;
475 break;
476
477 case R_CRX_NONE:
478 return bfd_reloc_ok;
479 break;
480
481 case R_CRX_SWITCH8:
482 case R_CRX_SWITCH16:
483 case R_CRX_SWITCH32:
484 /* We only care about the addend, where the difference between
485 expressions is kept. */
486 Rvalue = 0;
487
488 default:
489 break;
490 }
491
492 if (howto->pc_relative)
493 {
494 /* Subtract the address of the section containing the location. */
495 Rvalue -= (input_section->output_section->vma
496 + input_section->output_offset);
497 /* Subtract the position of the location within the section. */
498 Rvalue -= offset;
499 }
500
501 /* Add in supplied addend. */
502 Rvalue += addend;
503
504 /* Complain if the bitfield overflows, whether it is considered
505 as signed or unsigned. */
506 check = Rvalue >> howto->rightshift;
507
508 /* Assumes two's complement. This expression avoids
509 overflow if howto->bitsize is the number of bits in
510 bfd_vma. */
511 reloc_bits = (((1 << (howto->bitsize - 1)) - 1) << 1) | 1;
512
513 if (((bfd_vma) check & ~reloc_bits) != 0
514 && (((bfd_vma) check & ~reloc_bits)
515 != (-(bfd_vma) 1 & ~reloc_bits)))
516 {
517 /* The above right shift is incorrect for a signed
518 value. See if turning on the upper bits fixes the
519 overflow. */
520 if (howto->rightshift && (bfd_signed_vma) Rvalue < 0)
521 {
522 check |= ((bfd_vma) - 1
523 & ~((bfd_vma) - 1
524 >> howto->rightshift));
525 if (((bfd_vma) check & ~reloc_bits)
526 != (-(bfd_vma) 1 & ~reloc_bits))
527 return bfd_reloc_overflow;
528 }
529 else
530 return bfd_reloc_overflow;
531 }
532
533 /* Drop unwanted bits from the value we are relocating to. */
534 Rvalue >>= (bfd_vma) howto->rightshift;
535
536 /* Apply dst_mask to select only relocatable part of the insn. */
537 Rvalue &= howto->dst_mask;
538
539 switch (howto->size)
540 {
541 case 0:
542 if (r_type == R_CRX_REL4)
543 {
544 Rvalue <<= 4;
545 Rvalue |= (bfd_get_8 (input_bfd, hit_data) & 0x0f);
546 }
547
548 bfd_put_8 (input_bfd, (unsigned char) Rvalue, hit_data);
549 break;
550
551 case 1:
552 if (r_type == R_CRX_REGREL12)
553 Rvalue |= (bfd_get_16 (input_bfd, hit_data) & 0xf000);
554
555 bfd_put_16 (input_bfd, Rvalue, hit_data);
556 break;
557
558 case 2:
559 if (r_type == R_CRX_REL24
560 || r_type == R_CRX_REGREL22
561 || r_type == R_CRX_REGREL28)
562 Rvalue |= (((bfd_get_16 (input_bfd, hit_data) << 16) |
563 bfd_get_16 (input_bfd, hit_data + 2)) & ~howto->dst_mask);
564
565 if (r_type == R_CRX_NUM32 || r_type == R_CRX_SWITCH32)
566 /* Relocation on DATA is purely little-endian, that is, for a
567 multi-byte datum, the lowest address in memory contains the
568 little end of the datum, that is, the least significant byte.
569 Therefore we use BFD's byte Putting functions. */
570 bfd_put_32 (input_bfd, Rvalue, hit_data);
571 else
572 /* Relocation on INSTRUCTIONS is different : Instructions are
573 word-addressable, that is, each word itself is arranged according
574 to little-endian convention, whereas the words are arranged with
575 respect to one another in BIG ENDIAN fashion.
576 When there is an immediate value that spans a word boundary, it is
577 split in a big-endian way with respect to the words. */
578 {
579 bfd_put_16 (input_bfd, (Rvalue >> 16) & 0xffff, hit_data);
580 bfd_put_16 (input_bfd, Rvalue & 0xffff, hit_data + 2);
581 }
582 break;
583
584 default:
585 return bfd_reloc_notsupported;
586 }
587
588 return bfd_reloc_ok;
589 }
590
591 /* Delete some bytes from a section while relaxing. */
592
593 static bfd_boolean
594 elf32_crx_relax_delete_bytes (struct bfd_link_info *link_info, bfd *abfd,
595 asection *sec, bfd_vma addr, int count)
596 {
597 Elf_Internal_Shdr *symtab_hdr;
598 unsigned int sec_shndx;
599 bfd_byte *contents;
600 Elf_Internal_Rela *irel, *irelend;
601 bfd_vma toaddr;
602 Elf_Internal_Sym *isym;
603 Elf_Internal_Sym *isymend;
604 struct elf_link_hash_entry **sym_hashes;
605 struct elf_link_hash_entry **end_hashes;
606 struct elf_link_hash_entry **start_hashes;
607 unsigned int symcount;
608
609 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
610
611 contents = elf_section_data (sec)->this_hdr.contents;
612
613 toaddr = sec->size;
614
615 irel = elf_section_data (sec)->relocs;
616 irelend = irel + sec->reloc_count;
617
618 /* Actually delete the bytes. */
619 memmove (contents + addr, contents + addr + count,
620 (size_t) (toaddr - addr - count));
621 sec->size -= count;
622
623 /* Adjust all the relocs. */
624 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
625 {
626 /* Get the new reloc address. */
627 if ((irel->r_offset > addr
628 && irel->r_offset < toaddr))
629 irel->r_offset -= count;
630 }
631
632 /* Adjust the local symbols defined in this section. */
633 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
634 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
635 for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
636 {
637 if (isym->st_shndx == sec_shndx
638 && isym->st_value > addr
639 && isym->st_value < toaddr)
640 {
641 /* Adjust the addend of SWITCH relocations in this section,
642 which reference this local symbol. */
643 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
644 {
645 unsigned long r_symndx;
646 Elf_Internal_Sym *rsym;
647 bfd_vma addsym, subsym;
648
649 /* Skip if not a SWITCH relocation. */
650 if (ELF32_R_TYPE (irel->r_info) != (int) R_CRX_SWITCH8
651 && ELF32_R_TYPE (irel->r_info) != (int) R_CRX_SWITCH16
652 && ELF32_R_TYPE (irel->r_info) != (int) R_CRX_SWITCH32)
653 continue;
654
655 r_symndx = ELF32_R_SYM (irel->r_info);
656 rsym = (Elf_Internal_Sym *) symtab_hdr->contents + r_symndx;
657
658 /* Skip if not the local adjusted symbol. */
659 if (rsym != isym)
660 continue;
661
662 addsym = isym->st_value;
663 subsym = addsym - irel->r_addend;
664
665 /* Fix the addend only when -->> (addsym > addr >= subsym). */
666 if (subsym <= addr)
667 irel->r_addend -= count;
668 else
669 continue;
670 }
671
672 isym->st_value -= count;
673 }
674 }
675
676 /* Now adjust the global symbols defined in this section. */
677 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
678 - symtab_hdr->sh_info);
679 sym_hashes = start_hashes = elf_sym_hashes (abfd);
680 end_hashes = sym_hashes + symcount;
681
682 for (; sym_hashes < end_hashes; sym_hashes++)
683 {
684 struct elf_link_hash_entry *sym_hash = *sym_hashes;
685
686 /* The '--wrap SYMBOL' option is causing a pain when the object file,
687 containing the definition of __wrap_SYMBOL, includes a direct
688 call to SYMBOL as well. Since both __wrap_SYMBOL and SYMBOL reference
689 the same symbol (which is __wrap_SYMBOL), but still exist as two
690 different symbols in 'sym_hashes', we don't want to adjust
691 the global symbol __wrap_SYMBOL twice.
692 This check is only relevant when symbols are being wrapped. */
693 if (link_info->wrap_hash != NULL)
694 {
695 struct elf_link_hash_entry **cur_sym_hashes;
696
697 /* Loop only over the symbols whom been already checked. */
698 for (cur_sym_hashes = start_hashes; cur_sym_hashes < sym_hashes;
699 cur_sym_hashes++)
700 {
701 /* If the current symbol is identical to 'sym_hash', that means
702 the symbol was already adjusted (or at least checked). */
703 if (*cur_sym_hashes == sym_hash)
704 break;
705 }
706 /* Don't adjust the symbol again. */
707 if (cur_sym_hashes < sym_hashes)
708 continue;
709 }
710
711 if ((sym_hash->root.type == bfd_link_hash_defined
712 || sym_hash->root.type == bfd_link_hash_defweak)
713 && sym_hash->root.u.def.section == sec
714 && sym_hash->root.u.def.value > addr
715 && sym_hash->root.u.def.value < toaddr)
716 sym_hash->root.u.def.value -= count;
717 }
718
719 return TRUE;
720 }
721
722 /* This is a version of bfd_generic_get_relocated_section_contents
723 which uses elf32_crx_relocate_section. */
724
725 static bfd_byte *
726 elf32_crx_get_relocated_section_contents (bfd *output_bfd,
727 struct bfd_link_info *link_info,
728 struct bfd_link_order *link_order,
729 bfd_byte *data,
730 bfd_boolean relocatable,
731 asymbol **symbols)
732 {
733 Elf_Internal_Shdr *symtab_hdr;
734 asection *input_section = link_order->u.indirect.section;
735 bfd *input_bfd = input_section->owner;
736 asection **sections = NULL;
737 Elf_Internal_Rela *internal_relocs = NULL;
738 Elf_Internal_Sym *isymbuf = NULL;
739
740 /* We only need to handle the case of relaxing, or of having a
741 particular set of section contents, specially. */
742 if (relocatable
743 || elf_section_data (input_section)->this_hdr.contents == NULL)
744 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
745 link_order, data,
746 relocatable,
747 symbols);
748
749 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
750
751 memcpy (data, elf_section_data (input_section)->this_hdr.contents,
752 (size_t) input_section->size);
753
754 if ((input_section->flags & SEC_RELOC) != 0
755 && input_section->reloc_count > 0)
756 {
757 Elf_Internal_Sym *isym;
758 Elf_Internal_Sym *isymend;
759 asection **secpp;
760 bfd_size_type amt;
761
762 internal_relocs = (_bfd_elf_link_read_relocs
763 (input_bfd, input_section, NULL,
764 (Elf_Internal_Rela *) NULL, FALSE));
765 if (internal_relocs == NULL)
766 goto error_return;
767
768 if (symtab_hdr->sh_info != 0)
769 {
770 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
771 if (isymbuf == NULL)
772 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
773 symtab_hdr->sh_info, 0,
774 NULL, NULL, NULL);
775 if (isymbuf == NULL)
776 goto error_return;
777 }
778
779 amt = symtab_hdr->sh_info;
780 amt *= sizeof (asection *);
781 sections = bfd_malloc (amt);
782 if (sections == NULL && amt != 0)
783 goto error_return;
784
785 isymend = isymbuf + symtab_hdr->sh_info;
786 for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
787 {
788 asection *isec;
789
790 if (isym->st_shndx == SHN_UNDEF)
791 isec = bfd_und_section_ptr;
792 else if (isym->st_shndx == SHN_ABS)
793 isec = bfd_abs_section_ptr;
794 else if (isym->st_shndx == SHN_COMMON)
795 isec = bfd_com_section_ptr;
796 else
797 isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
798
799 *secpp = isec;
800 }
801
802 if (! elf32_crx_relocate_section (output_bfd, link_info, input_bfd,
803 input_section, data, internal_relocs,
804 isymbuf, sections))
805 goto error_return;
806
807 if (sections != NULL)
808 free (sections);
809 if (isymbuf != NULL
810 && symtab_hdr->contents != (unsigned char *) isymbuf)
811 free (isymbuf);
812 if (elf_section_data (input_section)->relocs != internal_relocs)
813 free (internal_relocs);
814 }
815
816 return data;
817
818 error_return:
819 if (sections != NULL)
820 free (sections);
821 if (isymbuf != NULL
822 && symtab_hdr->contents != (unsigned char *) isymbuf)
823 free (isymbuf);
824 if (internal_relocs != NULL
825 && elf_section_data (input_section)->relocs != internal_relocs)
826 free (internal_relocs);
827 return NULL;
828 }
829
830 /* Relocate a CRX ELF section. */
831
832 static bfd_boolean
833 elf32_crx_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
834 bfd *input_bfd, asection *input_section,
835 bfd_byte *contents, Elf_Internal_Rela *relocs,
836 Elf_Internal_Sym *local_syms,
837 asection **local_sections)
838 {
839 Elf_Internal_Shdr *symtab_hdr;
840 struct elf_link_hash_entry **sym_hashes;
841 Elf_Internal_Rela *rel, *relend;
842
843 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
844 sym_hashes = elf_sym_hashes (input_bfd);
845
846 rel = relocs;
847 relend = relocs + input_section->reloc_count;
848 for (; rel < relend; rel++)
849 {
850 int r_type;
851 reloc_howto_type *howto;
852 unsigned long r_symndx;
853 Elf_Internal_Sym *sym;
854 asection *sec;
855 struct elf_link_hash_entry *h;
856 bfd_vma relocation;
857 bfd_reloc_status_type r;
858
859 r_symndx = ELF32_R_SYM (rel->r_info);
860 r_type = ELF32_R_TYPE (rel->r_info);
861 howto = crx_elf_howto_table + (r_type);
862
863 h = NULL;
864 sym = NULL;
865 sec = NULL;
866 if (r_symndx < symtab_hdr->sh_info)
867 {
868 sym = local_syms + r_symndx;
869 sec = local_sections[r_symndx];
870 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
871 }
872 else
873 {
874 bfd_boolean unresolved_reloc, warned, ignored;
875
876 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
877 r_symndx, symtab_hdr, sym_hashes,
878 h, sec, relocation,
879 unresolved_reloc, warned, ignored);
880 }
881
882 if (sec != NULL && discarded_section (sec))
883 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
884 rel, 1, relend, howto, 0, contents);
885
886 if (bfd_link_relocatable (info))
887 continue;
888
889 r = crx_elf_final_link_relocate (howto, input_bfd, output_bfd,
890 input_section,
891 contents, rel->r_offset,
892 relocation, rel->r_addend,
893 info, sec, h == NULL);
894
895 if (r != bfd_reloc_ok)
896 {
897 const char *name;
898 const char *msg = (const char *) 0;
899
900 if (h != NULL)
901 name = h->root.root.string;
902 else
903 {
904 name = (bfd_elf_string_from_elf_section
905 (input_bfd, symtab_hdr->sh_link, sym->st_name));
906 if (name == NULL || *name == '\0')
907 name = bfd_section_name (input_bfd, sec);
908 }
909
910 switch (r)
911 {
912 case bfd_reloc_overflow:
913 (*info->callbacks->reloc_overflow)
914 (info, (h ? &h->root : NULL), name, howto->name,
915 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
916 break;
917
918 case bfd_reloc_undefined:
919 (*info->callbacks->undefined_symbol)
920 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
921 break;
922
923 case bfd_reloc_outofrange:
924 msg = _("internal error: out of range error");
925 goto common_error;
926
927 case bfd_reloc_notsupported:
928 msg = _("internal error: unsupported relocation error");
929 goto common_error;
930
931 case bfd_reloc_dangerous:
932 msg = _("internal error: dangerous error");
933 goto common_error;
934
935 default:
936 msg = _("internal error: unknown error");
937 /* Fall through. */
938
939 common_error:
940 (*info->callbacks->warning) (info, msg, name, input_bfd,
941 input_section, rel->r_offset);
942 break;
943 }
944 }
945 }
946
947 return TRUE;
948 }
949
950 /* This function handles relaxing for the CRX.
951
952 There's quite a few relaxing opportunites available on the CRX:
953
954 * bal/bcond:32 -> bal/bcond:16 2 bytes
955 * bcond:16 -> bcond:8 2 bytes
956 * cmpbcond:24 -> cmpbcond:8 2 bytes
957 * arithmetic imm32 -> arithmetic imm16 2 bytes
958
959 Symbol- and reloc-reading infrastructure copied from elf-m10200.c. */
960
961 static bfd_boolean
962 elf32_crx_relax_section (bfd *abfd, asection *sec,
963 struct bfd_link_info *link_info, bfd_boolean *again)
964 {
965 Elf_Internal_Shdr *symtab_hdr;
966 Elf_Internal_Rela *internal_relocs;
967 Elf_Internal_Rela *irel, *irelend;
968 bfd_byte *contents = NULL;
969 Elf_Internal_Sym *isymbuf = NULL;
970
971 /* Assume nothing changes. */
972 *again = FALSE;
973
974 /* We don't have to do anything for a relocatable link, if
975 this section does not have relocs, or if this is not a
976 code section. */
977 if (bfd_link_relocatable (link_info)
978 || (sec->flags & SEC_RELOC) == 0
979 || sec->reloc_count == 0
980 || (sec->flags & SEC_CODE) == 0)
981 return TRUE;
982
983 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
984
985 /* Get a copy of the native relocations. */
986 internal_relocs = (_bfd_elf_link_read_relocs
987 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
988 link_info->keep_memory));
989 if (internal_relocs == NULL)
990 goto error_return;
991
992 /* Walk through them looking for relaxing opportunities. */
993 irelend = internal_relocs + sec->reloc_count;
994 for (irel = internal_relocs; irel < irelend; irel++)
995 {
996 bfd_vma symval;
997
998 /* If this isn't something that can be relaxed, then ignore
999 this reloc. */
1000 if (ELF32_R_TYPE (irel->r_info) != (int) R_CRX_REL32
1001 && ELF32_R_TYPE (irel->r_info) != (int) R_CRX_REL16
1002 && ELF32_R_TYPE (irel->r_info) != (int) R_CRX_REL24
1003 && ELF32_R_TYPE (irel->r_info) != (int) R_CRX_IMM32)
1004 continue;
1005
1006 /* Get the section contents if we haven't done so already. */
1007 if (contents == NULL)
1008 {
1009 /* Get cached copy if it exists. */
1010 if (elf_section_data (sec)->this_hdr.contents != NULL)
1011 contents = elf_section_data (sec)->this_hdr.contents;
1012 /* Go get them off disk. */
1013 else if (!bfd_malloc_and_get_section (abfd, sec, &contents))
1014 goto error_return;
1015 }
1016
1017 /* Read this BFD's local symbols if we haven't done so already. */
1018 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
1019 {
1020 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1021 if (isymbuf == NULL)
1022 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1023 symtab_hdr->sh_info, 0,
1024 NULL, NULL, NULL);
1025 if (isymbuf == NULL)
1026 goto error_return;
1027 }
1028
1029 /* Get the value of the symbol referred to by the reloc. */
1030 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1031 {
1032 /* A local symbol. */
1033 Elf_Internal_Sym *isym;
1034 asection *sym_sec;
1035
1036 isym = isymbuf + ELF32_R_SYM (irel->r_info);
1037 if (isym->st_shndx == SHN_UNDEF)
1038 sym_sec = bfd_und_section_ptr;
1039 else if (isym->st_shndx == SHN_ABS)
1040 sym_sec = bfd_abs_section_ptr;
1041 else if (isym->st_shndx == SHN_COMMON)
1042 sym_sec = bfd_com_section_ptr;
1043 else
1044 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1045 symval = (isym->st_value
1046 + sym_sec->output_section->vma
1047 + sym_sec->output_offset);
1048 }
1049 else
1050 {
1051 unsigned long indx;
1052 struct elf_link_hash_entry *h;
1053
1054 /* An external symbol. */
1055 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
1056 h = elf_sym_hashes (abfd)[indx];
1057 BFD_ASSERT (h != NULL);
1058
1059 if (h->root.type != bfd_link_hash_defined
1060 && h->root.type != bfd_link_hash_defweak)
1061 /* This appears to be a reference to an undefined
1062 symbol. Just ignore it--it will be caught by the
1063 regular reloc processing. */
1064 continue;
1065
1066 symval = (h->root.u.def.value
1067 + h->root.u.def.section->output_section->vma
1068 + h->root.u.def.section->output_offset);
1069 }
1070
1071 /* For simplicity of coding, we are going to modify the section
1072 contents, the section relocs, and the BFD symbol table. We
1073 must tell the rest of the code not to free up this
1074 information. It would be possible to instead create a table
1075 of changes which have to be made, as is done in coff-mips.c;
1076 that would be more work, but would require less memory when
1077 the linker is run. */
1078
1079 /* Try to turn a 32bit pc-relative branch/call into
1080 a 16bit pc-relative branch/call. */
1081 if (ELF32_R_TYPE (irel->r_info) == (int) R_CRX_REL32)
1082 {
1083 bfd_vma value = symval;
1084
1085 /* Deal with pc-relative gunk. */
1086 value -= (sec->output_section->vma + sec->output_offset);
1087 value -= irel->r_offset;
1088 value += irel->r_addend;
1089
1090 /* See if the value will fit in 16 bits, note the high value is
1091 0xfffe + 2 as the target will be two bytes closer if we are
1092 able to relax. */
1093 if ((long) value < 0x10000 && (long) value > -0x10002)
1094 {
1095 unsigned short code;
1096
1097 /* Get the opcode. */
1098 code = (unsigned short) bfd_get_16 (abfd, contents + irel->r_offset);
1099
1100 /* Verify it's a 'bal'/'bcond' and fix the opcode. */
1101 if ((code & 0xfff0) == 0x3170)
1102 bfd_put_8 (abfd, 0x30, contents + irel->r_offset + 1);
1103 else if ((code & 0xf0ff) == 0x707f)
1104 bfd_put_8 (abfd, 0x7e, contents + irel->r_offset);
1105 else
1106 continue;
1107
1108 /* Note that we've changed the relocs, section contents, etc. */
1109 elf_section_data (sec)->relocs = internal_relocs;
1110 elf_section_data (sec)->this_hdr.contents = contents;
1111 symtab_hdr->contents = (unsigned char *) isymbuf;
1112
1113 /* Fix the relocation's type. */
1114 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1115 R_CRX_REL16);
1116
1117 /* Delete two bytes of data. */
1118 if (!elf32_crx_relax_delete_bytes (link_info, abfd, sec,
1119 irel->r_offset + 2, 2))
1120 goto error_return;
1121
1122 /* That will change things, so, we should relax again.
1123 Note that this is not required, and it may be slow. */
1124 *again = TRUE;
1125 }
1126 }
1127
1128 /* Try to turn a 16bit pc-relative branch into an
1129 8bit pc-relative branch. */
1130 if (ELF32_R_TYPE (irel->r_info) == (int) R_CRX_REL16)
1131 {
1132 bfd_vma value = symval;
1133
1134 /* Deal with pc-relative gunk. */
1135 value -= (sec->output_section->vma + sec->output_offset);
1136 value -= irel->r_offset;
1137 value += irel->r_addend;
1138
1139 /* See if the value will fit in 8 bits, note the high value is
1140 0xfc + 2 as the target will be two bytes closer if we are
1141 able to relax. */
1142 if ((long) value < 0xfe && (long) value > -0x100)
1143 {
1144 unsigned short code;
1145
1146 /* Get the opcode. */
1147 code = (unsigned short) bfd_get_16 (abfd, contents + irel->r_offset);
1148
1149 /* Verify it's a 'bcond' opcode. */
1150 if ((code & 0xf0ff) != 0x707e)
1151 continue;
1152
1153 /* Note that we've changed the relocs, section contents, etc. */
1154 elf_section_data (sec)->relocs = internal_relocs;
1155 elf_section_data (sec)->this_hdr.contents = contents;
1156 symtab_hdr->contents = (unsigned char *) isymbuf;
1157
1158 /* Fix the relocation's type. */
1159 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1160 R_CRX_REL8);
1161
1162 /* Delete two bytes of data. */
1163 if (!elf32_crx_relax_delete_bytes (link_info, abfd, sec,
1164 irel->r_offset + 2, 2))
1165 goto error_return;
1166
1167 /* That will change things, so, we should relax again.
1168 Note that this is not required, and it may be slow. */
1169 *again = TRUE;
1170 }
1171 }
1172
1173 /* Try to turn a 24bit pc-relative cmp&branch into
1174 an 8bit pc-relative cmp&branch. */
1175 if (ELF32_R_TYPE (irel->r_info) == (int) R_CRX_REL24)
1176 {
1177 bfd_vma value = symval;
1178
1179 /* Deal with pc-relative gunk. */
1180 value -= (sec->output_section->vma + sec->output_offset);
1181 value -= irel->r_offset;
1182 value += irel->r_addend;
1183
1184 /* See if the value will fit in 8 bits, note the high value is
1185 0x7e + 2 as the target will be two bytes closer if we are
1186 able to relax. */
1187 if ((long) value < 0x100 && (long) value > -0x100)
1188 {
1189 unsigned short code;
1190
1191 /* Get the opcode. */
1192 code = (unsigned short) bfd_get_16 (abfd, contents + irel->r_offset);
1193
1194 /* Verify it's a 'cmp&branch' opcode. */
1195 if ((code & 0xfff0) != 0x3180 && (code & 0xfff0) != 0x3190
1196 && (code & 0xfff0) != 0x31a0 && (code & 0xfff0) != 0x31c0
1197 && (code & 0xfff0) != 0x31d0 && (code & 0xfff0) != 0x31e0
1198 /* Or a Co-processor branch ('bcop'). */
1199 && (code & 0xfff0) != 0x3010 && (code & 0xfff0) != 0x3110)
1200 continue;
1201
1202 /* Note that we've changed the relocs, section contents, etc. */
1203 elf_section_data (sec)->relocs = internal_relocs;
1204 elf_section_data (sec)->this_hdr.contents = contents;
1205 symtab_hdr->contents = (unsigned char *) isymbuf;
1206
1207 /* Fix the opcode. */
1208 bfd_put_8 (abfd, 0x30, contents + irel->r_offset + 1);
1209
1210 /* Fix the relocation's type. */
1211 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1212 R_CRX_REL8_CMP);
1213
1214 /* Delete two bytes of data. */
1215 if (!elf32_crx_relax_delete_bytes (link_info, abfd, sec,
1216 irel->r_offset + 4, 2))
1217 goto error_return;
1218
1219 /* That will change things, so, we should relax again.
1220 Note that this is not required, and it may be slow. */
1221 *again = TRUE;
1222 }
1223 }
1224
1225 /* Try to turn a 32bit immediate address into
1226 a 16bit immediate address. */
1227 if (ELF32_R_TYPE (irel->r_info) == (int) R_CRX_IMM32)
1228 {
1229 bfd_vma value = symval;
1230
1231 /* See if the value will fit in 16 bits. */
1232 if ((long) value < 0x7fff && (long) value > -0x8000)
1233 {
1234 unsigned short code;
1235
1236 /* Get the opcode. */
1237 code = (unsigned short) bfd_get_16 (abfd, contents + irel->r_offset);
1238
1239 /* Verify it's a 'arithmetic double'. */
1240 if ((code & 0xf0f0) != 0x20f0)
1241 continue;
1242
1243 /* Note that we've changed the relocs, section contents, etc. */
1244 elf_section_data (sec)->relocs = internal_relocs;
1245 elf_section_data (sec)->this_hdr.contents = contents;
1246 symtab_hdr->contents = (unsigned char *) isymbuf;
1247
1248 /* Fix the opcode. */
1249 bfd_put_8 (abfd, (code & 0xff) - 0x10, contents + irel->r_offset);
1250
1251 /* Fix the relocation's type. */
1252 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1253 R_CRX_IMM16);
1254
1255 /* Delete two bytes of data. */
1256 if (!elf32_crx_relax_delete_bytes (link_info, abfd, sec,
1257 irel->r_offset + 2, 2))
1258 goto error_return;
1259
1260 /* That will change things, so, we should relax again.
1261 Note that this is not required, and it may be slow. */
1262 *again = TRUE;
1263 }
1264 }
1265 }
1266
1267 if (isymbuf != NULL
1268 && symtab_hdr->contents != (unsigned char *) isymbuf)
1269 {
1270 if (! link_info->keep_memory)
1271 free (isymbuf);
1272 else
1273 {
1274 /* Cache the symbols for elf_link_input_bfd. */
1275 symtab_hdr->contents = (unsigned char *) isymbuf;
1276 }
1277 }
1278
1279 if (contents != NULL
1280 && elf_section_data (sec)->this_hdr.contents != contents)
1281 {
1282 if (! link_info->keep_memory)
1283 free (contents);
1284 else
1285 {
1286 /* Cache the section contents for elf_link_input_bfd. */
1287 elf_section_data (sec)->this_hdr.contents = contents;
1288 }
1289 }
1290
1291 if (internal_relocs != NULL
1292 && elf_section_data (sec)->relocs != internal_relocs)
1293 free (internal_relocs);
1294
1295 return TRUE;
1296
1297 error_return:
1298 if (isymbuf != NULL
1299 && symtab_hdr->contents != (unsigned char *) isymbuf)
1300 free (isymbuf);
1301 if (contents != NULL
1302 && elf_section_data (sec)->this_hdr.contents != contents)
1303 free (contents);
1304 if (internal_relocs != NULL
1305 && elf_section_data (sec)->relocs != internal_relocs)
1306 free (internal_relocs);
1307
1308 return FALSE;
1309 }
1310
1311 /* Definitions for setting CRX target vector. */
1312 #define TARGET_LITTLE_SYM crx_elf32_vec
1313 #define TARGET_LITTLE_NAME "elf32-crx"
1314 #define ELF_ARCH bfd_arch_crx
1315 #define ELF_MACHINE_CODE EM_CRX
1316 #define ELF_MAXPAGESIZE 0x1
1317 #define elf_symbol_leading_char '_'
1318
1319 #define bfd_elf32_bfd_reloc_type_lookup elf_crx_reloc_type_lookup
1320 #define bfd_elf32_bfd_reloc_name_lookup \
1321 elf_crx_reloc_name_lookup
1322 #define elf_info_to_howto elf_crx_info_to_howto
1323 #define elf_info_to_howto_rel 0
1324 #define elf_backend_relocate_section elf32_crx_relocate_section
1325 #define bfd_elf32_bfd_relax_section elf32_crx_relax_section
1326 #define bfd_elf32_bfd_get_relocated_section_contents \
1327 elf32_crx_get_relocated_section_contents
1328 #define elf_backend_can_gc_sections 1
1329 #define elf_backend_rela_normal 1
1330
1331 #include "elf32-target.h"
The GNU Binutils are a collection of binary tools.