projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
update copyright dates
[deliverable/binutils-gdb.git] / bfd / elf32-crx.c
1 /* BFD back-end for National Semiconductor's CRX ELF
2 Copyright 2004, 2005, 2006, 2007, 2009 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 2, /* size */
86 32, /* 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 BFD_ASSERT (r_type < (unsigned int) R_CRX_MAX);
427 cache_ptr->howto = &crx_elf_howto_table[r_type];
428 }
429
430 /* Perform a relocation as part of a final link. */
431
432 static bfd_reloc_status_type
433 crx_elf_final_link_relocate (reloc_howto_type *howto, bfd *input_bfd,
434 bfd *output_bfd ATTRIBUTE_UNUSED,
435 asection *input_section, bfd_byte *contents,
436 bfd_vma offset, bfd_vma Rvalue, bfd_vma addend,
437 struct bfd_link_info *info ATTRIBUTE_UNUSED,
438 asection *sec ATTRIBUTE_UNUSED,
439 int is_local ATTRIBUTE_UNUSED)
440 {
441 unsigned short r_type = howto->type;
442 bfd_byte *hit_data = contents + offset;
443 bfd_vma reloc_bits, check;
444
445 switch (r_type)
446 {
447 case R_CRX_IMM16:
448 case R_CRX_IMM32:
449 case R_CRX_ABS16:
450 case R_CRX_ABS32:
451 case R_CRX_REL8_CMP:
452 case R_CRX_REL16:
453 case R_CRX_REL24:
454 case R_CRX_REL32:
455 case R_CRX_REGREL12:
456 case R_CRX_REGREL22:
457 case R_CRX_REGREL28:
458 case R_CRX_REGREL32:
459 /* 'hit_data' is relative to the start of the instruction, not the
460 relocation offset. Advance it to account for the exact offset. */
461 hit_data += 2;
462 break;
463
464 case R_CRX_REL4:
465 /* This relocation type is used only in 'Branch if Equal to 0'
466 instructions and requires special handling. */
467 Rvalue -= 1;
468 break;
469
470 case R_CRX_NONE:
471 return bfd_reloc_ok;
472 break;
473
474 case R_CRX_SWITCH8:
475 case R_CRX_SWITCH16:
476 case R_CRX_SWITCH32:
477 /* We only care about the addend, where the difference between
478 expressions is kept. */
479 Rvalue = 0;
480
481 default:
482 break;
483 }
484
485 if (howto->pc_relative)
486 {
487 /* Subtract the address of the section containing the location. */
488 Rvalue -= (input_section->output_section->vma
489 + input_section->output_offset);
490 /* Subtract the position of the location within the section. */
491 Rvalue -= offset;
492 }
493
494 /* Add in supplied addend. */
495 Rvalue += addend;
496
497 /* Complain if the bitfield overflows, whether it is considered
498 as signed or unsigned. */
499 check = Rvalue >> howto->rightshift;
500
501 /* Assumes two's complement. This expression avoids
502 overflow if howto->bitsize is the number of bits in
503 bfd_vma. */
504 reloc_bits = (((1 << (howto->bitsize - 1)) - 1) << 1) | 1;
505
506 if (((bfd_vma) check & ~reloc_bits) != 0
507 && (((bfd_vma) check & ~reloc_bits)
508 != (-(bfd_vma) 1 & ~reloc_bits)))
509 {
510 /* The above right shift is incorrect for a signed
511 value. See if turning on the upper bits fixes the
512 overflow. */
513 if (howto->rightshift && (bfd_signed_vma) Rvalue < 0)
514 {
515 check |= ((bfd_vma) - 1
516 & ~((bfd_vma) - 1
517 >> howto->rightshift));
518 if (((bfd_vma) check & ~reloc_bits)
519 != (-(bfd_vma) 1 & ~reloc_bits))
520 return bfd_reloc_overflow;
521 }
522 else
523 return bfd_reloc_overflow;
524 }
525
526 /* Drop unwanted bits from the value we are relocating to. */
527 Rvalue >>= (bfd_vma) howto->rightshift;
528
529 /* Apply dst_mask to select only relocatable part of the insn. */
530 Rvalue &= howto->dst_mask;
531
532 switch (howto->size)
533 {
534 case 0:
535 if (r_type == R_CRX_REL4)
536 {
537 Rvalue <<= 4;
538 Rvalue |= (bfd_get_8 (input_bfd, hit_data) & 0x0f);
539 }
540
541 bfd_put_8 (input_bfd, (unsigned char) Rvalue, hit_data);
542 break;
543
544 case 1:
545 if (r_type == R_CRX_REGREL12)
546 Rvalue |= (bfd_get_16 (input_bfd, hit_data) & 0xf000);
547
548 bfd_put_16 (input_bfd, Rvalue, hit_data);
549 break;
550
551 case 2:
552 if (r_type == R_CRX_REL24
553 || r_type == R_CRX_REGREL22
554 || r_type == R_CRX_REGREL28)
555 Rvalue |= (((bfd_get_16 (input_bfd, hit_data) << 16) |
556 bfd_get_16 (input_bfd, hit_data + 2)) & ~howto->dst_mask);
557
558 if (r_type == R_CRX_NUM32 || r_type == R_CRX_SWITCH32)
559 /* Relocation on DATA is purely little-endian, that is, for a
560 multi-byte datum, the lowest address in memory contains the
561 little end of the datum, that is, the least significant byte.
562 Therefore we use BFD's byte Putting functions. */
563 bfd_put_32 (input_bfd, Rvalue, hit_data);
564 else
565 /* Relocation on INSTRUCTIONS is different : Instructions are
566 word-addressable, that is, each word itself is arranged according
567 to little-endian convention, whereas the words are arranged with
568 respect to one another in BIG ENDIAN fashion.
569 When there is an immediate value that spans a word boundary, it is
570 split in a big-endian way with respect to the words. */
571 {
572 bfd_put_16 (input_bfd, (Rvalue >> 16) & 0xffff, hit_data);
573 bfd_put_16 (input_bfd, Rvalue & 0xffff, hit_data + 2);
574 }
575 break;
576
577 default:
578 return bfd_reloc_notsupported;
579 }
580
581 return bfd_reloc_ok;
582 }
583
584 /* Delete some bytes from a section while relaxing. */
585
586 static bfd_boolean
587 elf32_crx_relax_delete_bytes (struct bfd_link_info *link_info, bfd *abfd,
588 asection *sec, bfd_vma addr, int count)
589 {
590 Elf_Internal_Shdr *symtab_hdr;
591 unsigned int sec_shndx;
592 bfd_byte *contents;
593 Elf_Internal_Rela *irel, *irelend;
594 Elf_Internal_Rela *irelalign;
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 /* The deletion must stop at the next ALIGN reloc for an aligment
608 power larger than the number of bytes we are deleting. */
609
610 irelalign = NULL;
611 toaddr = sec->size;
612
613 irel = elf_section_data (sec)->relocs;
614 irelend = irel + sec->reloc_count;
615
616 /* Actually delete the bytes. */
617 memmove (contents + addr, contents + addr + count,
618 (size_t) (toaddr - addr - count));
619 sec->size -= count;
620
621 /* Adjust all the relocs. */
622 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
623 {
624 /* Get the new reloc address. */
625 if ((irel->r_offset > addr
626 && irel->r_offset < toaddr))
627 irel->r_offset -= count;
628 }
629
630 /* Adjust the local symbols defined in this section. */
631 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
632 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
633 for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
634 {
635 if (isym->st_shndx == sec_shndx
636 && isym->st_value > addr
637 && isym->st_value < toaddr)
638 {
639 /* Adjust the addend of SWITCH relocations in this section,
640 which reference this local symbol. */
641 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
642 {
643 unsigned long r_symndx;
644 Elf_Internal_Sym *rsym;
645 bfd_vma addsym, subsym;
646
647 /* Skip if not a SWITCH relocation. */
648 if (ELF32_R_TYPE (irel->r_info) != (int) R_CRX_SWITCH8
649 && ELF32_R_TYPE (irel->r_info) != (int) R_CRX_SWITCH16
650 && ELF32_R_TYPE (irel->r_info) != (int) R_CRX_SWITCH32)
651 continue;
652
653 r_symndx = ELF32_R_SYM (irel->r_info);
654 rsym = (Elf_Internal_Sym *) symtab_hdr->contents + r_symndx;
655
656 /* Skip if not the local adjusted symbol. */
657 if (rsym != isym)
658 continue;
659
660 addsym = isym->st_value;
661 subsym = addsym - irel->r_addend;
662
663 /* Fix the addend only when -->> (addsym > addr >= subsym). */
664 if (subsym <= addr)
665 irel->r_addend -= count;
666 else
667 continue;
668 }
669
670 isym->st_value -= count;
671 }
672 }
673
674 /* Now adjust the global symbols defined in this section. */
675 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
676 - symtab_hdr->sh_info);
677 sym_hashes = start_hashes = elf_sym_hashes (abfd);
678 end_hashes = sym_hashes + symcount;
679
680 for (; sym_hashes < end_hashes; sym_hashes++)
681 {
682 struct elf_link_hash_entry *sym_hash = *sym_hashes;
683
684 /* The '--wrap SYMBOL' option is causing a pain when the object file,
685 containing the definition of __wrap_SYMBOL, includes a direct
686 call to SYMBOL as well. Since both __wrap_SYMBOL and SYMBOL reference
687 the same symbol (which is __wrap_SYMBOL), but still exist as two
688 different symbols in 'sym_hashes', we don't want to adjust
689 the global symbol __wrap_SYMBOL twice.
690 This check is only relevant when symbols are being wrapped. */
691 if (link_info->wrap_hash != NULL)
692 {
693 struct elf_link_hash_entry **cur_sym_hashes;
694
695 /* Loop only over the symbols whom been already checked. */
696 for (cur_sym_hashes = start_hashes; cur_sym_hashes < sym_hashes;
697 cur_sym_hashes++)
698 {
699 /* If the current symbol is identical to 'sym_hash', that means
700 the symbol was already adjusted (or at least checked). */
701 if (*cur_sym_hashes == sym_hash)
702 break;
703 }
704 /* Don't adjust the symbol again. */
705 if (cur_sym_hashes < sym_hashes)
706 continue;
707 }
708
709 if ((sym_hash->root.type == bfd_link_hash_defined
710 || sym_hash->root.type == bfd_link_hash_defweak)
711 && sym_hash->root.u.def.section == sec
712 && sym_hash->root.u.def.value > addr
713 && sym_hash->root.u.def.value < toaddr)
714 sym_hash->root.u.def.value -= count;
715 }
716
717 return TRUE;
718 }
719
720 /* This is a version of bfd_generic_get_relocated_section_contents
721 which uses elf32_crx_relocate_section. */
722
723 static bfd_byte *
724 elf32_crx_get_relocated_section_contents (bfd *output_bfd,
725 struct bfd_link_info *link_info,
726 struct bfd_link_order *link_order,
727 bfd_byte *data,
728 bfd_boolean relocatable,
729 asymbol **symbols)
730 {
731 Elf_Internal_Shdr *symtab_hdr;
732 asection *input_section = link_order->u.indirect.section;
733 bfd *input_bfd = input_section->owner;
734 asection **sections = NULL;
735 Elf_Internal_Rela *internal_relocs = NULL;
736 Elf_Internal_Sym *isymbuf = NULL;
737
738 /* We only need to handle the case of relaxing, or of having a
739 particular set of section contents, specially. */
740 if (relocatable
741 || elf_section_data (input_section)->this_hdr.contents == NULL)
742 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
743 link_order, data,
744 relocatable,
745 symbols);
746
747 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
748
749 memcpy (data, elf_section_data (input_section)->this_hdr.contents,
750 (size_t) input_section->size);
751
752 if ((input_section->flags & SEC_RELOC) != 0
753 && input_section->reloc_count > 0)
754 {
755 Elf_Internal_Sym *isym;
756 Elf_Internal_Sym *isymend;
757 asection **secpp;
758 bfd_size_type amt;
759
760 internal_relocs = (_bfd_elf_link_read_relocs
761 (input_bfd, input_section, (PTR) NULL,
762 (Elf_Internal_Rela *) NULL, FALSE));
763 if (internal_relocs == NULL)
764 goto error_return;
765
766 if (symtab_hdr->sh_info != 0)
767 {
768 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
769 if (isymbuf == NULL)
770 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
771 symtab_hdr->sh_info, 0,
772 NULL, NULL, NULL);
773 if (isymbuf == NULL)
774 goto error_return;
775 }
776
777 amt = symtab_hdr->sh_info;
778 amt *= sizeof (asection *);
779 sections = bfd_malloc (amt);
780 if (sections == NULL && amt != 0)
781 goto error_return;
782
783 isymend = isymbuf + symtab_hdr->sh_info;
784 for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
785 {
786 asection *isec;
787
788 if (isym->st_shndx == SHN_UNDEF)
789 isec = bfd_und_section_ptr;
790 else if (isym->st_shndx == SHN_ABS)
791 isec = bfd_abs_section_ptr;
792 else if (isym->st_shndx == SHN_COMMON)
793 isec = bfd_com_section_ptr;
794 else
795 isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
796
797 *secpp = isec;
798 }
799
800 if (! elf32_crx_relocate_section (output_bfd, link_info, input_bfd,
801 input_section, data, internal_relocs,
802 isymbuf, sections))
803 goto error_return;
804
805 if (sections != NULL)
806 free (sections);
807 if (isymbuf != NULL
808 && symtab_hdr->contents != (unsigned char *) isymbuf)
809 free (isymbuf);
810 if (elf_section_data (input_section)->relocs != internal_relocs)
811 free (internal_relocs);
812 }
813
814 return data;
815
816 error_return:
817 if (sections != NULL)
818 free (sections);
819 if (isymbuf != NULL
820 && symtab_hdr->contents != (unsigned char *) isymbuf)
821 free (isymbuf);
822 if (internal_relocs != NULL
823 && elf_section_data (input_section)->relocs != internal_relocs)
824 free (internal_relocs);
825 return NULL;
826 }
827
828 /* Relocate a CRX ELF section. */
829
830 static bfd_boolean
831 elf32_crx_relocate_section (bfd *output_bfd, struct bfd_link_info *info,
832 bfd *input_bfd, asection *input_section,
833 bfd_byte *contents, Elf_Internal_Rela *relocs,
834 Elf_Internal_Sym *local_syms,
835 asection **local_sections)
836 {
837 Elf_Internal_Shdr *symtab_hdr;
838 struct elf_link_hash_entry **sym_hashes;
839 Elf_Internal_Rela *rel, *relend;
840
841 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
842 sym_hashes = elf_sym_hashes (input_bfd);
843
844 rel = relocs;
845 relend = relocs + input_section->reloc_count;
846 for (; rel < relend; rel++)
847 {
848 int r_type;
849 reloc_howto_type *howto;
850 unsigned long r_symndx;
851 Elf_Internal_Sym *sym;
852 asection *sec;
853 struct elf_link_hash_entry *h;
854 bfd_vma relocation;
855 bfd_reloc_status_type r;
856
857 r_symndx = ELF32_R_SYM (rel->r_info);
858 r_type = ELF32_R_TYPE (rel->r_info);
859 howto = crx_elf_howto_table + (r_type);
860
861 h = NULL;
862 sym = NULL;
863 sec = NULL;
864 if (r_symndx < symtab_hdr->sh_info)
865 {
866 sym = local_syms + r_symndx;
867 sec = local_sections[r_symndx];
868 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
869 }
870 else
871 {
872 bfd_boolean unresolved_reloc, warned;
873
874 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
875 r_symndx, symtab_hdr, sym_hashes,
876 h, sec, relocation,
877 unresolved_reloc, warned);
878 }
879
880 if (sec != NULL && elf_discarded_section (sec))
881 {
882 /* For relocs against symbols from removed linkonce sections,
883 or sections discarded by a linker script, we just want the
884 section contents zeroed. Avoid any special processing. */
885 _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
886 rel->r_info = 0;
887 rel->r_addend = 0;
888 continue;
889 }
890
891 if (info->relocatable)
892 continue;
893
894 r = crx_elf_final_link_relocate (howto, input_bfd, output_bfd,
895 input_section,
896 contents, rel->r_offset,
897 relocation, rel->r_addend,
898 info, sec, h == NULL);
899
900 if (r != bfd_reloc_ok)
901 {
902 const char *name;
903 const char *msg = (const char *) 0;
904
905 if (h != NULL)
906 name = h->root.root.string;
907 else
908 {
909 name = (bfd_elf_string_from_elf_section
910 (input_bfd, symtab_hdr->sh_link, sym->st_name));
911 if (name == NULL || *name == '\0')
912 name = bfd_section_name (input_bfd, sec);
913 }
914
915 switch (r)
916 {
917 case bfd_reloc_overflow:
918 if (!((*info->callbacks->reloc_overflow)
919 (info, (h ? &h->root : NULL), name, howto->name,
920 (bfd_vma) 0, input_bfd, input_section,
921 rel->r_offset)))
922 return FALSE;
923 break;
924
925 case bfd_reloc_undefined:
926 if (!((*info->callbacks->undefined_symbol)
927 (info, name, input_bfd, input_section,
928 rel->r_offset, TRUE)))
929 return FALSE;
930 break;
931
932 case bfd_reloc_outofrange:
933 msg = _("internal error: out of range error");
934 goto common_error;
935
936 case bfd_reloc_notsupported:
937 msg = _("internal error: unsupported relocation error");
938 goto common_error;
939
940 case bfd_reloc_dangerous:
941 msg = _("internal error: dangerous error");
942 goto common_error;
943
944 default:
945 msg = _("internal error: unknown error");
946 /* Fall through. */
947
948 common_error:
949 if (!((*info->callbacks->warning)
950 (info, msg, name, input_bfd, input_section,
951 rel->r_offset)))
952 return FALSE;
953 break;
954 }
955 }
956 }
957
958 return TRUE;
959 }
960
961 /* This function handles relaxing for the CRX.
962
963 There's quite a few relaxing opportunites available on the CRX:
964
965 * bal/bcond:32 -> bal/bcond:16 2 bytes
966 * bcond:16 -> bcond:8 2 bytes
967 * cmpbcond:24 -> cmpbcond:8 2 bytes
968 * arithmetic imm32 -> arithmetic imm16 2 bytes
969
970 Symbol- and reloc-reading infrastructure copied from elf-m10200.c. */
971
972 static bfd_boolean
973 elf32_crx_relax_section (bfd *abfd, asection *sec,
974 struct bfd_link_info *link_info, bfd_boolean *again)
975 {
976 Elf_Internal_Shdr *symtab_hdr;
977 Elf_Internal_Rela *internal_relocs;
978 Elf_Internal_Rela *irel, *irelend;
979 bfd_byte *contents = NULL;
980 Elf_Internal_Sym *isymbuf = NULL;
981
982 /* Assume nothing changes. */
983 *again = FALSE;
984
985 /* We don't have to do anything for a relocatable link, if
986 this section does not have relocs, or if this is not a
987 code section. */
988 if (link_info->relocatable
989 || (sec->flags & SEC_RELOC) == 0
990 || sec->reloc_count == 0
991 || (sec->flags & SEC_CODE) == 0)
992 return TRUE;
993
994 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
995
996 /* Get a copy of the native relocations. */
997 internal_relocs = (_bfd_elf_link_read_relocs
998 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
999 link_info->keep_memory));
1000 if (internal_relocs == NULL)
1001 goto error_return;
1002
1003 /* Walk through them looking for relaxing opportunities. */
1004 irelend = internal_relocs + sec->reloc_count;
1005 for (irel = internal_relocs; irel < irelend; irel++)
1006 {
1007 bfd_vma symval;
1008
1009 /* If this isn't something that can be relaxed, then ignore
1010 this reloc. */
1011 if (ELF32_R_TYPE (irel->r_info) != (int) R_CRX_REL32
1012 && ELF32_R_TYPE (irel->r_info) != (int) R_CRX_REL16
1013 && ELF32_R_TYPE (irel->r_info) != (int) R_CRX_REL24
1014 && ELF32_R_TYPE (irel->r_info) != (int) R_CRX_IMM32)
1015 continue;
1016
1017 /* Get the section contents if we haven't done so already. */
1018 if (contents == NULL)
1019 {
1020 /* Get cached copy if it exists. */
1021 if (elf_section_data (sec)->this_hdr.contents != NULL)
1022 contents = elf_section_data (sec)->this_hdr.contents;
1023 /* Go get them off disk. */
1024 else if (!bfd_malloc_and_get_section (abfd, sec, &contents))
1025 goto error_return;
1026 }
1027
1028 /* Read this BFD's local symbols if we haven't done so already. */
1029 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
1030 {
1031 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1032 if (isymbuf == NULL)
1033 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1034 symtab_hdr->sh_info, 0,
1035 NULL, NULL, NULL);
1036 if (isymbuf == NULL)
1037 goto error_return;
1038 }
1039
1040 /* Get the value of the symbol referred to by the reloc. */
1041 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1042 {
1043 /* A local symbol. */
1044 Elf_Internal_Sym *isym;
1045 asection *sym_sec;
1046
1047 isym = isymbuf + ELF32_R_SYM (irel->r_info);
1048 if (isym->st_shndx == SHN_UNDEF)
1049 sym_sec = bfd_und_section_ptr;
1050 else if (isym->st_shndx == SHN_ABS)
1051 sym_sec = bfd_abs_section_ptr;
1052 else if (isym->st_shndx == SHN_COMMON)
1053 sym_sec = bfd_com_section_ptr;
1054 else
1055 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1056 symval = (isym->st_value
1057 + sym_sec->output_section->vma
1058 + sym_sec->output_offset);
1059 }
1060 else
1061 {
1062 unsigned long indx;
1063 struct elf_link_hash_entry *h;
1064
1065 /* An external symbol. */
1066 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
1067 h = elf_sym_hashes (abfd)[indx];
1068 BFD_ASSERT (h != NULL);
1069
1070 if (h->root.type != bfd_link_hash_defined
1071 && h->root.type != bfd_link_hash_defweak)
1072 /* This appears to be a reference to an undefined
1073 symbol. Just ignore it--it will be caught by the
1074 regular reloc processing. */
1075 continue;
1076
1077 symval = (h->root.u.def.value
1078 + h->root.u.def.section->output_section->vma
1079 + h->root.u.def.section->output_offset);
1080 }
1081
1082 /* For simplicity of coding, we are going to modify the section
1083 contents, the section relocs, and the BFD symbol table. We
1084 must tell the rest of the code not to free up this
1085 information. It would be possible to instead create a table
1086 of changes which have to be made, as is done in coff-mips.c;
1087 that would be more work, but would require less memory when
1088 the linker is run. */
1089
1090 /* Try to turn a 32bit pc-relative branch/call into
1091 a 16bit pc-relative branch/call. */
1092 if (ELF32_R_TYPE (irel->r_info) == (int) R_CRX_REL32)
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 16 bits, note the high value is
1102 0xfffe + 2 as the target will be two bytes closer if we are
1103 able to relax. */
1104 if ((long) value < 0x10000 && (long) value > -0x10002)
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 'bal'/'bcond' and fix the opcode. */
1112 if ((code & 0xfff0) == 0x3170)
1113 bfd_put_8 (abfd, 0x30, contents + irel->r_offset + 1);
1114 else if ((code & 0xf0ff) == 0x707f)
1115 bfd_put_8 (abfd, 0x7e, contents + irel->r_offset);
1116 else
1117 continue;
1118
1119 /* Note that we've changed the relocs, section contents, etc. */
1120 elf_section_data (sec)->relocs = internal_relocs;
1121 elf_section_data (sec)->this_hdr.contents = contents;
1122 symtab_hdr->contents = (unsigned char *) isymbuf;
1123
1124 /* Fix the relocation's type. */
1125 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1126 R_CRX_REL16);
1127
1128 /* Delete two bytes of data. */
1129 if (!elf32_crx_relax_delete_bytes (link_info, abfd, sec,
1130 irel->r_offset + 2, 2))
1131 goto error_return;
1132
1133 /* That will change things, so, we should relax again.
1134 Note that this is not required, and it may be slow. */
1135 *again = TRUE;
1136 }
1137 }
1138
1139 /* Try to turn a 16bit pc-relative branch into an
1140 8bit pc-relative branch. */
1141 if (ELF32_R_TYPE (irel->r_info) == (int) R_CRX_REL16)
1142 {
1143 bfd_vma value = symval;
1144
1145 /* Deal with pc-relative gunk. */
1146 value -= (sec->output_section->vma + sec->output_offset);
1147 value -= irel->r_offset;
1148 value += irel->r_addend;
1149
1150 /* See if the value will fit in 8 bits, note the high value is
1151 0xfc + 2 as the target will be two bytes closer if we are
1152 able to relax. */
1153 if ((long) value < 0xfe && (long) value > -0x100)
1154 {
1155 unsigned short code;
1156
1157 /* Get the opcode. */
1158 code = (unsigned short) bfd_get_16 (abfd, contents + irel->r_offset);
1159
1160 /* Verify it's a 'bcond' opcode. */
1161 if ((code & 0xf0ff) != 0x707e)
1162 continue;
1163
1164 /* Note that we've changed the relocs, section contents, etc. */
1165 elf_section_data (sec)->relocs = internal_relocs;
1166 elf_section_data (sec)->this_hdr.contents = contents;
1167 symtab_hdr->contents = (unsigned char *) isymbuf;
1168
1169 /* Fix the relocation's type. */
1170 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1171 R_CRX_REL8);
1172
1173 /* Delete two bytes of data. */
1174 if (!elf32_crx_relax_delete_bytes (link_info, abfd, sec,
1175 irel->r_offset + 2, 2))
1176 goto error_return;
1177
1178 /* That will change things, so, we should relax again.
1179 Note that this is not required, and it may be slow. */
1180 *again = TRUE;
1181 }
1182 }
1183
1184 /* Try to turn a 24bit pc-relative cmp&branch into
1185 an 8bit pc-relative cmp&branch. */
1186 if (ELF32_R_TYPE (irel->r_info) == (int) R_CRX_REL24)
1187 {
1188 bfd_vma value = symval;
1189
1190 /* Deal with pc-relative gunk. */
1191 value -= (sec->output_section->vma + sec->output_offset);
1192 value -= irel->r_offset;
1193 value += irel->r_addend;
1194
1195 /* See if the value will fit in 8 bits, note the high value is
1196 0x7e + 2 as the target will be two bytes closer if we are
1197 able to relax. */
1198 if ((long) value < 0x100 && (long) value > -0x100)
1199 {
1200 unsigned short code;
1201
1202 /* Get the opcode. */
1203 code = (unsigned short) bfd_get_16 (abfd, contents + irel->r_offset);
1204
1205 /* Verify it's a 'cmp&branch' opcode. */
1206 if ((code & 0xfff0) != 0x3180 && (code & 0xfff0) != 0x3190
1207 && (code & 0xfff0) != 0x31a0 && (code & 0xfff0) != 0x31c0
1208 && (code & 0xfff0) != 0x31d0 && (code & 0xfff0) != 0x31e0
1209 /* Or a Co-processor branch ('bcop'). */
1210 && (code & 0xfff0) != 0x3010 && (code & 0xfff0) != 0x3110)
1211 continue;
1212
1213 /* Note that we've changed the relocs, section contents, etc. */
1214 elf_section_data (sec)->relocs = internal_relocs;
1215 elf_section_data (sec)->this_hdr.contents = contents;
1216 symtab_hdr->contents = (unsigned char *) isymbuf;
1217
1218 /* Fix the opcode. */
1219 bfd_put_8 (abfd, 0x30, contents + irel->r_offset + 1);
1220
1221 /* Fix the relocation's type. */
1222 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1223 R_CRX_REL8_CMP);
1224
1225 /* Delete two bytes of data. */
1226 if (!elf32_crx_relax_delete_bytes (link_info, abfd, sec,
1227 irel->r_offset + 4, 2))
1228 goto error_return;
1229
1230 /* That will change things, so, we should relax again.
1231 Note that this is not required, and it may be slow. */
1232 *again = TRUE;
1233 }
1234 }
1235
1236 /* Try to turn a 32bit immediate address into
1237 a 16bit immediate address. */
1238 if (ELF32_R_TYPE (irel->r_info) == (int) R_CRX_IMM32)
1239 {
1240 bfd_vma value = symval;
1241
1242 /* See if the value will fit in 16 bits. */
1243 if ((long) value < 0x7fff && (long) value > -0x8000)
1244 {
1245 unsigned short code;
1246
1247 /* Get the opcode. */
1248 code = (unsigned short) bfd_get_16 (abfd, contents + irel->r_offset);
1249
1250 /* Verify it's a 'arithmetic double'. */
1251 if ((code & 0xf0f0) != 0x20f0)
1252 continue;
1253
1254 /* Note that we've changed the relocs, section contents, etc. */
1255 elf_section_data (sec)->relocs = internal_relocs;
1256 elf_section_data (sec)->this_hdr.contents = contents;
1257 symtab_hdr->contents = (unsigned char *) isymbuf;
1258
1259 /* Fix the opcode. */
1260 bfd_put_8 (abfd, (code & 0xff) - 0x10, contents + irel->r_offset);
1261
1262 /* Fix the relocation's type. */
1263 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1264 R_CRX_IMM16);
1265
1266 /* Delete two bytes of data. */
1267 if (!elf32_crx_relax_delete_bytes (link_info, abfd, sec,
1268 irel->r_offset + 2, 2))
1269 goto error_return;
1270
1271 /* That will change things, so, we should relax again.
1272 Note that this is not required, and it may be slow. */
1273 *again = TRUE;
1274 }
1275 }
1276 }
1277
1278 if (isymbuf != NULL
1279 && symtab_hdr->contents != (unsigned char *) isymbuf)
1280 {
1281 if (! link_info->keep_memory)
1282 free (isymbuf);
1283 else
1284 {
1285 /* Cache the symbols for elf_link_input_bfd. */
1286 symtab_hdr->contents = (unsigned char *) isymbuf;
1287 }
1288 }
1289
1290 if (contents != NULL
1291 && elf_section_data (sec)->this_hdr.contents != contents)
1292 {
1293 if (! link_info->keep_memory)
1294 free (contents);
1295 else
1296 {
1297 /* Cache the section contents for elf_link_input_bfd. */
1298 elf_section_data (sec)->this_hdr.contents = contents;
1299 }
1300 }
1301
1302 if (internal_relocs != NULL
1303 && elf_section_data (sec)->relocs != internal_relocs)
1304 free (internal_relocs);
1305
1306 return TRUE;
1307
1308 error_return:
1309 if (isymbuf != NULL
1310 && symtab_hdr->contents != (unsigned char *) isymbuf)
1311 free (isymbuf);
1312 if (contents != NULL
1313 && elf_section_data (sec)->this_hdr.contents != contents)
1314 free (contents);
1315 if (internal_relocs != NULL
1316 && elf_section_data (sec)->relocs != internal_relocs)
1317 free (internal_relocs);
1318
1319 return FALSE;
1320 }
1321
1322 /* Definitions for setting CRX target vector. */
1323 #define TARGET_LITTLE_SYM bfd_elf32_crx_vec
1324 #define TARGET_LITTLE_NAME "elf32-crx"
1325 #define ELF_ARCH bfd_arch_crx
1326 #define ELF_MACHINE_CODE EM_CRX
1327 #define ELF_MAXPAGESIZE 0x1
1328 #define elf_symbol_leading_char '_'
1329
1330 #define bfd_elf32_bfd_reloc_type_lookup elf_crx_reloc_type_lookup
1331 #define bfd_elf32_bfd_reloc_name_lookup \
1332 elf_crx_reloc_name_lookup
1333 #define elf_info_to_howto elf_crx_info_to_howto
1334 #define elf_info_to_howto_rel 0
1335 #define elf_backend_relocate_section elf32_crx_relocate_section
1336 #define bfd_elf32_bfd_relax_section elf32_crx_relax_section
1337 #define bfd_elf32_bfd_get_relocated_section_contents \
1338 elf32_crx_get_relocated_section_contents
1339 #define elf_backend_can_gc_sections 1
1340 #define elf_backend_rela_normal 1
1341
1342 #include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.062025 seconds and 5 git commands to generate.