projects / deliverable / binutils-gdb.git / blob
? search:


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