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