projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
19990502 sourceware import
[deliverable/binutils-gdb.git] / bfd / elf-m10200.c
1 /* Matsushita 10200 specific support for 32-bit ELF
2 Copyright (C) 1996, 1997, 1998 Free Software Foundation, Inc.
3
4 This file is part of BFD, the Binary File Descriptor library.
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
19
20 #include "bfd.h"
21 #include "sysdep.h"
22 #include "libbfd.h"
23 #include "elf-bfd.h"
24
25 static reloc_howto_type *bfd_elf32_bfd_reloc_type_lookup
26 PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
27 static void mn10200_info_to_howto
28 PARAMS ((bfd *, arelent *, Elf32_Internal_Rela *));
29 static boolean mn10200_elf_relax_delete_bytes
30 PARAMS ((bfd *, asection *, bfd_vma, int));
31 static boolean mn10200_elf_symbol_address_p
32 PARAMS ((bfd *, asection *, Elf32_External_Sym *, bfd_vma));
33
34 /* We have to use RELA instructions since md_apply_fix3 in the assembler
35 does absolutely nothing. */
36 #define USE_RELA
37
38 enum reloc_type
39 {
40 R_MN10200_NONE = 0,
41 R_MN10200_32,
42 R_MN10200_16,
43 R_MN10200_8,
44 R_MN10200_24,
45 R_MN10200_PCREL8,
46 R_MN10200_PCREL16,
47 R_MN10200_PCREL24,
48 R_MN10200_MAX
49 };
50
51 static reloc_howto_type elf_mn10200_howto_table[] =
52 {
53 /* Dummy relocation. Does nothing. */
54 HOWTO (R_MN10200_NONE,
55 0,
56 2,
57 16,
58 false,
59 0,
60 complain_overflow_bitfield,
61 bfd_elf_generic_reloc,
62 "R_MN10200_NONE",
63 false,
64 0,
65 0,
66 false),
67 /* Standard 32 bit reloc. */
68 HOWTO (R_MN10200_32,
69 0,
70 2,
71 32,
72 false,
73 0,
74 complain_overflow_bitfield,
75 bfd_elf_generic_reloc,
76 "R_MN10200_32",
77 false,
78 0xffffffff,
79 0xffffffff,
80 false),
81 /* Standard 16 bit reloc. */
82 HOWTO (R_MN10200_16,
83 0,
84 1,
85 16,
86 false,
87 0,
88 complain_overflow_bitfield,
89 bfd_elf_generic_reloc,
90 "R_MN10200_16",
91 false,
92 0xffff,
93 0xffff,
94 false),
95 /* Standard 8 bit reloc. */
96 HOWTO (R_MN10200_8,
97 0,
98 0,
99 8,
100 false,
101 0,
102 complain_overflow_bitfield,
103 bfd_elf_generic_reloc,
104 "R_MN10200_8",
105 false,
106 0xff,
107 0xff,
108 false),
109 /* Standard 24 bit reloc. */
110 HOWTO (R_MN10200_24,
111 0,
112 2,
113 24,
114 false,
115 0,
116 complain_overflow_bitfield,
117 bfd_elf_generic_reloc,
118 "R_MN10200_24",
119 false,
120 0xffffff,
121 0xffffff,
122 false),
123 /* Simple 8 pc-relative reloc. */
124 HOWTO (R_MN10200_PCREL8,
125 0,
126 0,
127 8,
128 true,
129 0,
130 complain_overflow_bitfield,
131 bfd_elf_generic_reloc,
132 "R_MN10200_PCREL8",
133 false,
134 0xff,
135 0xff,
136 true),
137 /* Simple 16 pc-relative reloc. */
138 HOWTO (R_MN10200_PCREL16,
139 0,
140 1,
141 16,
142 true,
143 0,
144 complain_overflow_bitfield,
145 bfd_elf_generic_reloc,
146 "R_MN10200_PCREL16",
147 false,
148 0xffff,
149 0xffff,
150 true),
151 /* Simple 32bit pc-relative reloc with a 1 byte adjustment
152 to get the pc-relative offset correct. */
153 HOWTO (R_MN10200_PCREL24,
154 0,
155 2,
156 24,
157 true,
158 0,
159 complain_overflow_bitfield,
160 bfd_elf_generic_reloc,
161 "R_MN10200_PCREL24",
162 false,
163 0xffffff,
164 0xffffff,
165 true),
166 };
167
168 struct mn10200_reloc_map
169 {
170 bfd_reloc_code_real_type bfd_reloc_val;
171 unsigned char elf_reloc_val;
172 };
173
174 static const struct mn10200_reloc_map mn10200_reloc_map[] =
175 {
176 { BFD_RELOC_NONE, R_MN10200_NONE, },
177 { BFD_RELOC_32, R_MN10200_32, },
178 { BFD_RELOC_16, R_MN10200_16, },
179 { BFD_RELOC_8, R_MN10200_8, },
180 { BFD_RELOC_24, R_MN10200_24, },
181 { BFD_RELOC_8_PCREL, R_MN10200_PCREL8, },
182 { BFD_RELOC_16_PCREL, R_MN10200_PCREL16, },
183 { BFD_RELOC_24_PCREL, R_MN10200_PCREL24, },
184 };
185
186 static reloc_howto_type *
187 bfd_elf32_bfd_reloc_type_lookup (abfd, code)
188 bfd *abfd;
189 bfd_reloc_code_real_type code;
190 {
191 unsigned int i;
192
193 for (i = 0;
194 i < sizeof (mn10200_reloc_map) / sizeof (struct mn10200_reloc_map);
195 i++)
196 {
197 if (mn10200_reloc_map[i].bfd_reloc_val == code)
198 return &elf_mn10200_howto_table[mn10200_reloc_map[i].elf_reloc_val];
199 }
200
201 return NULL;
202 }
203
204 /* Set the howto pointer for an MN10200 ELF reloc. */
205
206 static void
207 mn10200_info_to_howto (abfd, cache_ptr, dst)
208 bfd *abfd;
209 arelent *cache_ptr;
210 Elf32_Internal_Rela *dst;
211 {
212 unsigned int r_type;
213
214 r_type = ELF32_R_TYPE (dst->r_info);
215 BFD_ASSERT (r_type < (unsigned int) R_MN10200_MAX);
216 cache_ptr->howto = &elf_mn10200_howto_table[r_type];
217 }
218
219 /* Perform a relocation as part of a final link. */
220 static bfd_reloc_status_type
221 mn10200_elf_final_link_relocate (howto, input_bfd, output_bfd,
222 input_section, contents, offset, value,
223 addend, info, sym_sec, is_local)
224 reloc_howto_type *howto;
225 bfd *input_bfd;
226 bfd *output_bfd;
227 asection *input_section;
228 bfd_byte *contents;
229 bfd_vma offset;
230 bfd_vma value;
231 bfd_vma addend;
232 struct bfd_link_info *info;
233 asection *sym_sec;
234 int is_local;
235 {
236 unsigned long r_type = howto->type;
237 bfd_byte *hit_data = contents + offset;
238
239 switch (r_type)
240 {
241
242 case R_MN10200_NONE:
243 return bfd_reloc_ok;
244
245 case R_MN10200_32:
246 value += addend;
247 bfd_put_32 (input_bfd, value, hit_data);
248 return bfd_reloc_ok;
249
250 case R_MN10200_16:
251 value += addend;
252
253 if ((long)value > 0x7fff || (long)value < -0x8000)
254 return bfd_reloc_overflow;
255
256 bfd_put_16 (input_bfd, value, hit_data);
257 return bfd_reloc_ok;
258
259 case R_MN10200_8:
260 value += addend;
261
262 if ((long)value > 0x7f || (long)value < -0x80)
263 return bfd_reloc_overflow;
264
265 bfd_put_8 (input_bfd, value, hit_data);
266 return bfd_reloc_ok;
267
268 case R_MN10200_24:
269 value += addend;
270
271 if ((long)value > 0x7fffff || (long)value < -0x800000)
272 return bfd_reloc_overflow;
273
274 value &= 0xffffff;
275 value |= (bfd_get_32 (input_bfd, hit_data) & 0xff000000);
276 bfd_put_32 (input_bfd, value, hit_data);
277 return bfd_reloc_ok;
278
279 case R_MN10200_PCREL8:
280 value -= (input_section->output_section->vma
281 + input_section->output_offset);
282 value -= (offset + 1);
283 value += addend;
284
285 if ((long)value > 0xff || (long)value < -0x100)
286 return bfd_reloc_overflow;
287
288 bfd_put_8 (input_bfd, value, hit_data);
289 return bfd_reloc_ok;
290
291 case R_MN10200_PCREL16:
292 value -= (input_section->output_section->vma
293 + input_section->output_offset);
294 value -= (offset + 2);
295 value += addend;
296
297 if ((long)value > 0xffff || (long)value < -0x10000)
298 return bfd_reloc_overflow;
299
300 bfd_put_16 (input_bfd, value, hit_data);
301 return bfd_reloc_ok;
302
303 case R_MN10200_PCREL24:
304 value -= (input_section->output_section->vma
305 + input_section->output_offset);
306 value -= (offset + 3);
307 value += addend;
308
309 if ((long)value > 0xffffff || (long)value < -0x1000000)
310 return bfd_reloc_overflow;
311
312 value &= 0xffffff;
313 value |= (bfd_get_32 (input_bfd, hit_data) & 0xff000000);
314 bfd_put_32 (input_bfd, value, hit_data);
315 return bfd_reloc_ok;
316
317 default:
318 return bfd_reloc_notsupported;
319 }
320 }
321
322 \f
323 /* Relocate an MN10200 ELF section. */
324 static boolean
325 mn10200_elf_relocate_section (output_bfd, info, input_bfd, input_section,
326 contents, relocs, local_syms, local_sections)
327 bfd *output_bfd;
328 struct bfd_link_info *info;
329 bfd *input_bfd;
330 asection *input_section;
331 bfd_byte *contents;
332 Elf_Internal_Rela *relocs;
333 Elf_Internal_Sym *local_syms;
334 asection **local_sections;
335 {
336 Elf_Internal_Shdr *symtab_hdr;
337 struct elf_link_hash_entry **sym_hashes;
338 Elf_Internal_Rela *rel, *relend;
339
340 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
341 sym_hashes = elf_sym_hashes (input_bfd);
342
343 rel = relocs;
344 relend = relocs + input_section->reloc_count;
345 for (; rel < relend; rel++)
346 {
347 int r_type;
348 reloc_howto_type *howto;
349 unsigned long r_symndx;
350 Elf_Internal_Sym *sym;
351 asection *sec;
352 struct elf_link_hash_entry *h;
353 bfd_vma relocation;
354 bfd_reloc_status_type r;
355
356 r_symndx = ELF32_R_SYM (rel->r_info);
357 r_type = ELF32_R_TYPE (rel->r_info);
358 howto = elf_mn10200_howto_table + r_type;
359
360 if (info->relocateable)
361 {
362 /* This is a relocateable link. We don't have to change
363 anything, unless the reloc is against a section symbol,
364 in which case we have to adjust according to where the
365 section symbol winds up in the output section. */
366 if (r_symndx < symtab_hdr->sh_info)
367 {
368 sym = local_syms + r_symndx;
369 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
370 {
371 sec = local_sections[r_symndx];
372 rel->r_addend += sec->output_offset + sym->st_value;
373 }
374 }
375
376 continue;
377 }
378
379 /* This is a final link. */
380 h = NULL;
381 sym = NULL;
382 sec = NULL;
383 if (r_symndx < symtab_hdr->sh_info)
384 {
385 sym = local_syms + r_symndx;
386 sec = local_sections[r_symndx];
387 relocation = (sec->output_section->vma
388 + sec->output_offset
389 + sym->st_value);
390 }
391 else
392 {
393 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
394 while (h->root.type == bfd_link_hash_indirect
395 || h->root.type == bfd_link_hash_warning)
396 h = (struct elf_link_hash_entry *) h->root.u.i.link;
397 if (h->root.type == bfd_link_hash_defined
398 || h->root.type == bfd_link_hash_defweak)
399 {
400 sec = h->root.u.def.section;
401 relocation = (h->root.u.def.value
402 + sec->output_section->vma
403 + sec->output_offset);
404 }
405 else if (h->root.type == bfd_link_hash_undefweak)
406 relocation = 0;
407 else
408 {
409 if (! ((*info->callbacks->undefined_symbol)
410 (info, h->root.root.string, input_bfd,
411 input_section, rel->r_offset)))
412 return false;
413 relocation = 0;
414 }
415 }
416
417 r = mn10200_elf_final_link_relocate (howto, input_bfd, output_bfd,
418 input_section,
419 contents, rel->r_offset,
420 relocation, rel->r_addend,
421 info, sec, h == NULL);
422
423 if (r != bfd_reloc_ok)
424 {
425 const char *name;
426 const char *msg = (const char *)0;
427
428 if (h != NULL)
429 name = h->root.root.string;
430 else
431 {
432 name = (bfd_elf_string_from_elf_section
433 (input_bfd, symtab_hdr->sh_link, sym->st_name));
434 if (name == NULL || *name == '\0')
435 name = bfd_section_name (input_bfd, sec);
436 }
437
438 switch (r)
439 {
440 case bfd_reloc_overflow:
441 if (! ((*info->callbacks->reloc_overflow)
442 (info, name, howto->name, (bfd_vma) 0,
443 input_bfd, input_section, rel->r_offset)))
444 return false;
445 break;
446
447 case bfd_reloc_undefined:
448 if (! ((*info->callbacks->undefined_symbol)
449 (info, name, input_bfd, input_section,
450 rel->r_offset)))
451 return false;
452 break;
453
454 case bfd_reloc_outofrange:
455 msg = _("internal error: out of range error");
456 goto common_error;
457
458 case bfd_reloc_notsupported:
459 msg = _("internal error: unsupported relocation error");
460 goto common_error;
461
462 case bfd_reloc_dangerous:
463 msg = _("internal error: dangerous error");
464 goto common_error;
465
466 default:
467 msg = _("internal error: unknown error");
468 /* fall through */
469
470 common_error:
471 if (!((*info->callbacks->warning)
472 (info, msg, name, input_bfd, input_section,
473 rel->r_offset)))
474 return false;
475 break;
476 }
477 }
478 }
479
480 return true;
481 }
482
483 /* This function handles relaxing for the mn10200.
484
485 There's quite a few relaxing opportunites available on the mn10200:
486
487 * jsr:24 -> jsr:16 2 bytes
488
489 * jmp:24 -> jmp:16 2 bytes
490 * jmp:16 -> bra:8 1 byte
491
492 * If the previous instruction is a conditional branch
493 around the jump/bra, we may be able to reverse its condition
494 and change its target to the jump's target. The jump/bra
495 can then be deleted. 2 bytes
496
497 * mov abs24 -> mov abs16 2 byte savings
498
499 * Most instructions which accept imm24 can relax to imm16 2 bytes
500 - Most instructions which accept imm16 can relax to imm8 1 byte
501
502 * Most instructions which accept d24 can relax to d16 2 bytes
503 - Most instructions which accept d16 can relax to d8 1 byte
504
505 abs24, imm24, d24 all look the same at the reloc level. It
506 might make the code simpler if we had different relocs for
507 the various relaxable operand types.
508
509 We don't handle imm16->imm8 or d16->d8 as they're very rare
510 and somewhat more difficult to support. */
511
512 static boolean
513 mn10200_elf_relax_section (abfd, sec, link_info, again)
514 bfd *abfd;
515 asection *sec;
516 struct bfd_link_info *link_info;
517 boolean *again;
518 {
519 Elf_Internal_Shdr *symtab_hdr;
520 Elf_Internal_Rela *internal_relocs;
521 Elf_Internal_Rela *free_relocs = NULL;
522 Elf_Internal_Rela *irel, *irelend;
523 bfd_byte *contents = NULL;
524 bfd_byte *free_contents = NULL;
525 Elf32_External_Sym *extsyms = NULL;
526 Elf32_External_Sym *free_extsyms = NULL;
527
528 /* Assume nothing changes. */
529 *again = false;
530
531 /* We don't have to do anything for a relocateable link, if
532 this section does not have relocs, or if this is not a
533 code section. */
534 if (link_info->relocateable
535 || (sec->flags & SEC_RELOC) == 0
536 || sec->reloc_count == 0
537 || (sec->flags & SEC_CODE) == 0)
538 return true;
539
540 /* If this is the first time we have been called for this section,
541 initialize the cooked size. */
542 if (sec->_cooked_size == 0)
543 sec->_cooked_size = sec->_raw_size;
544
545 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
546
547 /* Get a copy of the native relocations. */
548 internal_relocs = (_bfd_elf32_link_read_relocs
549 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
550 link_info->keep_memory));
551 if (internal_relocs == NULL)
552 goto error_return;
553 if (! link_info->keep_memory)
554 free_relocs = internal_relocs;
555
556 /* Walk through them looking for relaxing opportunities. */
557 irelend = internal_relocs + sec->reloc_count;
558 for (irel = internal_relocs; irel < irelend; irel++)
559 {
560 bfd_vma symval;
561
562 /* If this isn't something that can be relaxed, then ignore
563 this reloc. */
564 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_NONE
565 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_8
566 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_MAX)
567 continue;
568
569 /* Get the section contents if we haven't done so already. */
570 if (contents == NULL)
571 {
572 /* Get cached copy if it exists. */
573 if (elf_section_data (sec)->this_hdr.contents != NULL)
574 contents = elf_section_data (sec)->this_hdr.contents;
575 else
576 {
577 /* Go get them off disk. */
578 contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
579 if (contents == NULL)
580 goto error_return;
581 free_contents = contents;
582
583 if (! bfd_get_section_contents (abfd, sec, contents,
584 (file_ptr) 0, sec->_raw_size))
585 goto error_return;
586 }
587 }
588
589 /* Read this BFD's symbols if we haven't done so already. */
590 if (extsyms == NULL)
591 {
592 /* Get cached copy if it exists. */
593 if (symtab_hdr->contents != NULL)
594 extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
595 else
596 {
597 /* Go get them off disk. */
598 extsyms = ((Elf32_External_Sym *)
599 bfd_malloc (symtab_hdr->sh_size));
600 if (extsyms == NULL)
601 goto error_return;
602 free_extsyms = extsyms;
603 if (bfd_seek (abfd, symtab_hdr->sh_offset, SEEK_SET) != 0
604 || (bfd_read (extsyms, 1, symtab_hdr->sh_size, abfd)
605 != symtab_hdr->sh_size))
606 goto error_return;
607 }
608 }
609
610 /* Get the value of the symbol referred to by the reloc. */
611 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
612 {
613 Elf_Internal_Sym isym;
614 asection *sym_sec;
615
616 /* A local symbol. */
617 bfd_elf32_swap_symbol_in (abfd,
618 extsyms + ELF32_R_SYM (irel->r_info),
619 &isym);
620
621 sym_sec = bfd_section_from_elf_index (abfd, isym.st_shndx);
622 symval = (isym.st_value
623 + sym_sec->output_section->vma
624 + sym_sec->output_offset);
625 }
626 else
627 {
628 unsigned long indx;
629 struct elf_link_hash_entry *h;
630
631 /* An external symbol. */
632 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
633 h = elf_sym_hashes (abfd)[indx];
634 BFD_ASSERT (h != NULL);
635 if (h->root.type != bfd_link_hash_defined
636 && h->root.type != bfd_link_hash_defweak)
637 {
638 /* This appears to be a reference to an undefined
639 symbol. Just ignore it--it will be caught by the
640 regular reloc processing. */
641 continue;
642 }
643
644 symval = (h->root.u.def.value
645 + h->root.u.def.section->output_section->vma
646 + h->root.u.def.section->output_offset);
647 }
648
649 /* For simplicity of coding, we are going to modify the section
650 contents, the section relocs, and the BFD symbol table. We
651 must tell the rest of the code not to free up this
652 information. It would be possible to instead create a table
653 of changes which have to be made, as is done in coff-mips.c;
654 that would be more work, but would require less memory when
655 the linker is run. */
656
657
658 /* Try to turn a 24bit pc-relative branch/call into a 16bit pc-relative
659 branch/call. */
660 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_PCREL24)
661 {
662 bfd_vma value = symval;
663
664 /* Deal with pc-relative gunk. */
665 value -= (sec->output_section->vma + sec->output_offset);
666 value -= (irel->r_offset + 3);
667 value += irel->r_addend;
668
669 /* See if the value will fit in 16 bits, note the high value is
670 0x7fff + 2 as the target will be two bytes closer if we are
671 able to relax. */
672 if ((long)value < 0x8001 && (long)value > -0x8000)
673 {
674 unsigned char code;
675
676 /* Get the opcode. */
677 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
678
679 if (code != 0xe0 && code != 0xe1)
680 continue;
681
682 /* Note that we've changed the relocs, section contents, etc. */
683 elf_section_data (sec)->relocs = internal_relocs;
684 free_relocs = NULL;
685
686 elf_section_data (sec)->this_hdr.contents = contents;
687 free_contents = NULL;
688
689 symtab_hdr->contents = (bfd_byte *) extsyms;
690 free_extsyms = NULL;
691
692 /* Fix the opcode. */
693 if (code == 0xe0)
694 bfd_put_8 (abfd, 0xfc, contents + irel->r_offset - 2);
695 else if (code == 0xe1)
696 bfd_put_8 (abfd, 0xfd, contents + irel->r_offset - 2);
697
698 /* Fix the relocation's type. */
699 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
700 R_MN10200_PCREL16);
701
702 /* The opcode got shorter too, so we have to fix the offset. */
703 irel->r_offset -= 1;
704
705 /* Delete two bytes of data. */
706 if (!mn10200_elf_relax_delete_bytes (abfd, sec,
707 irel->r_offset + 1, 2))
708 goto error_return;
709
710 /* That will change things, so, we should relax again.
711 Note that this is not required, and it may be slow. */
712 *again = true;
713 }
714 }
715
716 /* Try to turn a 16bit pc-relative branch into a 8bit pc-relative
717 branch. */
718 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_PCREL16)
719 {
720 bfd_vma value = symval;
721
722 /* Deal with pc-relative gunk. */
723 value -= (sec->output_section->vma + sec->output_offset);
724 value -= (irel->r_offset + 2);
725 value += irel->r_addend;
726
727 /* See if the value will fit in 8 bits, note the high value is
728 0x7f + 1 as the target will be one bytes closer if we are
729 able to relax. */
730 if ((long)value < 0x80 && (long)value > -0x80)
731 {
732 unsigned char code;
733
734 /* Get the opcode. */
735 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
736
737 if (code != 0xfc)
738 continue;
739
740 /* Note that we've changed the relocs, section contents, etc. */
741 elf_section_data (sec)->relocs = internal_relocs;
742 free_relocs = NULL;
743
744 elf_section_data (sec)->this_hdr.contents = contents;
745 free_contents = NULL;
746
747 symtab_hdr->contents = (bfd_byte *) extsyms;
748 free_extsyms = NULL;
749
750 /* Fix the opcode. */
751 bfd_put_8 (abfd, 0xea, contents + irel->r_offset - 1);
752
753 /* Fix the relocation's type. */
754 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
755 R_MN10200_PCREL8);
756
757 /* Delete one byte of data. */
758 if (!mn10200_elf_relax_delete_bytes (abfd, sec,
759 irel->r_offset + 1, 1))
760 goto error_return;
761
762 /* That will change things, so, we should relax again.
763 Note that this is not required, and it may be slow. */
764 *again = true;
765 }
766 }
767
768 /* Try to eliminate an unconditional 8 bit pc-relative branch
769 which immediately follows a conditional 8 bit pc-relative
770 branch around the unconditional branch.
771
772 original: new:
773 bCC lab1 bCC' lab2
774 bra lab2
775 lab1: lab1:
776
777
778 This happens when the bCC can't reach lab2 at assembly time,
779 but due to other relaxations it can reach at link time. */
780 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_PCREL8)
781 {
782 Elf_Internal_Rela *nrel;
783 bfd_vma value = symval;
784 unsigned char code;
785
786 /* Deal with pc-relative gunk. */
787 value -= (sec->output_section->vma + sec->output_offset);
788 value -= (irel->r_offset + 1);
789 value += irel->r_addend;
790
791 /* Do nothing if this reloc is the last byte in the section. */
792 if (irel->r_offset == sec->_cooked_size)
793 continue;
794
795 /* See if the next instruction is an unconditional pc-relative
796 branch, more often than not this test will fail, so we
797 test it first to speed things up. */
798 code = bfd_get_8 (abfd, contents + irel->r_offset + 1);
799 if (code != 0xea)
800 continue;
801
802 /* Also make sure the next relocation applies to the next
803 instruction and that it's a pc-relative 8 bit branch. */
804 nrel = irel + 1;
805 if (nrel == irelend
806 || irel->r_offset + 2 != nrel->r_offset
807 || ELF32_R_TYPE (nrel->r_info) != (int) R_MN10200_PCREL8)
808 continue;
809
810 /* Make sure our destination immediately follows the
811 unconditional branch. */
812 if (symval != (sec->output_section->vma + sec->output_offset
813 + irel->r_offset + 3))
814 continue;
815
816 /* Now make sure we are a conditional branch. This may not
817 be necessary, but why take the chance.
818
819 Note these checks assume that R_MN10200_PCREL8 relocs
820 only occur on bCC and bCCx insns. If they occured
821 elsewhere, we'd need to know the start of this insn
822 for this check to be accurate. */
823 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
824 if (code != 0xe0 && code != 0xe1 && code != 0xe2
825 && code != 0xe3 && code != 0xe4 && code != 0xe5
826 && code != 0xe6 && code != 0xe7 && code != 0xe8
827 && code != 0xe9 && code != 0xec && code != 0xed
828 && code != 0xee && code != 0xef && code != 0xfc
829 && code != 0xfd && code != 0xfe && code != 0xff)
830 continue;
831
832 /* We also have to be sure there is no symbol/label
833 at the unconditional branch. */
834 if (mn10200_elf_symbol_address_p (abfd, sec, extsyms,
835 irel->r_offset + 1))
836 continue;
837
838 /* Note that we've changed the relocs, section contents, etc. */
839 elf_section_data (sec)->relocs = internal_relocs;
840 free_relocs = NULL;
841
842 elf_section_data (sec)->this_hdr.contents = contents;
843 free_contents = NULL;
844
845 symtab_hdr->contents = (bfd_byte *) extsyms;
846 free_extsyms = NULL;
847
848 /* Reverse the condition of the first branch. */
849 switch (code)
850 {
851 case 0xfc:
852 code = 0xfd;
853 break;
854 case 0xfd:
855 code = 0xfc;
856 break;
857 case 0xfe:
858 code = 0xff;
859 break;
860 case 0xff:
861 code = 0xfe;
862 break;
863 case 0xe8:
864 code = 0xe9;
865 break;
866 case 0xe9:
867 code = 0xe8;
868 break;
869 case 0xe0:
870 code = 0xe2;
871 break;
872 case 0xe2:
873 code = 0xe0;
874 break;
875 case 0xe3:
876 code = 0xe1;
877 break;
878 case 0xe1:
879 code = 0xe3;
880 break;
881 case 0xe4:
882 code = 0xe6;
883 break;
884 case 0xe6:
885 code = 0xe4;
886 break;
887 case 0xe7:
888 code = 0xe5;
889 break;
890 case 0xe5:
891 code = 0xe7;
892 break;
893 case 0xec:
894 code = 0xed;
895 break;
896 case 0xed:
897 code = 0xec;
898 break;
899 case 0xee:
900 code = 0xef;
901 break;
902 case 0xef:
903 code = 0xee;
904 break;
905 }
906 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
907
908 /* Set the reloc type and symbol for the first branch
909 from the second branch. */
910 irel->r_info = nrel->r_info;
911
912 /* Make the reloc for the second branch a null reloc. */
913 nrel->r_info = ELF32_R_INFO (ELF32_R_SYM (nrel->r_info),
914 R_MN10200_NONE);
915
916 /* Delete two bytes of data. */
917 if (!mn10200_elf_relax_delete_bytes (abfd, sec,
918 irel->r_offset + 1, 2))
919 goto error_return;
920
921 /* That will change things, so, we should relax again.
922 Note that this is not required, and it may be slow. */
923 *again = true;
924 }
925
926 /* Try to turn a 24bit immediate, displacement or absolute address
927 into a 16bit immediate, displacement or absolute address. */
928 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_24)
929 {
930 bfd_vma value = symval;
931
932 /* See if the value will fit in 16 bits.
933 We allow any 16bit match here. We prune those we can't
934 handle below. */
935 if ((long)value < 0x7fff && (long)value > -0x8000)
936 {
937 unsigned char code;
938
939 /* All insns which have 24bit operands are 5 bytes long,
940 the first byte will always be 0xf4, but we double check
941 it just in case. */
942
943 /* Get the first opcode. */
944 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
945
946 if (code != 0xf4)
947 continue;
948
949 /* Get the second opcode. */
950 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
951
952 switch (code & 0xfc)
953 {
954 /* mov imm24,dn -> mov imm16,dn */
955 case 0x70:
956 /* Not safe if the high bit is on as relaxing may
957 move the value out of high mem and thus not fit
958 in a signed 16bit value. */
959 if (value & 0x8000)
960 continue;
961
962 /* Note that we've changed the reldection contents, etc. */
963 elf_section_data (sec)->relocs = internal_relocs;
964 free_relocs = NULL;
965
966 elf_section_data (sec)->this_hdr.contents = contents;
967 free_contents = NULL;
968
969 symtab_hdr->contents = (bfd_byte *) extsyms;
970 free_extsyms = NULL;
971
972 /* Fix the opcode. */
973 bfd_put_8 (abfd, 0xf8 + (code & 0x03),
974 contents + irel->r_offset - 2);
975
976 /* Fix the relocation's type. */
977 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
978 R_MN10200_16);
979
980 /* The opcode got shorter too, so we have to fix the
981 offset. */
982 irel->r_offset -= 1;
983
984 /* Delete two bytes of data. */
985 if (!mn10200_elf_relax_delete_bytes (abfd, sec,
986 irel->r_offset + 1, 2))
987 goto error_return;
988
989 /* That will change things, so, we should relax again.
990 Note that this is not required, and it may be slow. */
991 *again = true;
992 break;
993
994 /* mov imm24,an -> mov imm16,an
995 cmp imm24,an -> cmp imm16,an
996 mov (abs24),dn -> mov (abs16),dn
997 mov dn,(abs24) -> mov dn,(abs16)
998 movb dn,(abs24) -> movb dn,(abs16)
999 movbu (abs24),dn -> movbu (abs16),dn */
1000 case 0x74:
1001 case 0x7c:
1002 case 0xc0:
1003 case 0x40:
1004 case 0x44:
1005 case 0xc8:
1006 /* Note that we've changed the reldection contents, etc. */
1007 elf_section_data (sec)->relocs = internal_relocs;
1008 free_relocs = NULL;
1009
1010 elf_section_data (sec)->this_hdr.contents = contents;
1011 free_contents = NULL;
1012
1013 symtab_hdr->contents = (bfd_byte *) extsyms;
1014 free_extsyms = NULL;
1015
1016 if ((code & 0xfc) == 0x74)
1017 code = 0xdc + (code & 0x03);
1018 else if ((code & 0xfc) == 0x7c)
1019 code = 0xec + (code & 0x03);
1020 else if ((code & 0xfc) == 0xc0)
1021 code = 0xc8 + (code & 0x03);
1022 else if ((code & 0xfc) == 0x40)
1023 code = 0xc0 + (code & 0x03);
1024 else if ((code & 0xfc) == 0x44)
1025 code = 0xc4 + (code & 0x03);
1026 else if ((code & 0xfc) == 0xc8)
1027 code = 0xcc + (code & 0x03);
1028
1029 /* Fix the opcode. */
1030 bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
1031
1032 /* Fix the relocation's type. */
1033 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1034 R_MN10200_16);
1035
1036 /* The opcode got shorter too, so we have to fix the
1037 offset. */
1038 irel->r_offset -= 1;
1039
1040 /* Delete two bytes of data. */
1041 if (!mn10200_elf_relax_delete_bytes (abfd, sec,
1042 irel->r_offset + 1, 2))
1043 goto error_return;
1044
1045 /* That will change things, so, we should relax again.
1046 Note that this is not required, and it may be slow. */
1047 *again = true;
1048 break;
1049
1050 /* cmp imm24,dn -> cmp imm16,dn
1051 mov (abs24),an -> mov (abs16),an
1052 mov an,(abs24) -> mov an,(abs16)
1053 add imm24,dn -> add imm16,dn
1054 add imm24,an -> add imm16,an
1055 sub imm24,dn -> sub imm16,dn
1056 sub imm24,an -> sub imm16,an
1057 And all d24->d16 in memory ops. */
1058 case 0x78:
1059 case 0xd0:
1060 case 0x50:
1061 case 0x60:
1062 case 0x64:
1063 case 0x68:
1064 case 0x6c:
1065 case 0x80:
1066 case 0xf0:
1067 case 0x00:
1068 case 0x10:
1069 case 0xb0:
1070 case 0x30:
1071 case 0xa0:
1072 case 0x20:
1073 case 0x90:
1074 /* Not safe if the high bit is on as relaxing may
1075 move the value out of high mem and thus not fit
1076 in a signed 16bit value. */
1077 if (((code & 0xfc) == 0x78
1078 || (code & 0xfc) == 0x60
1079 || (code & 0xfc) == 0x64
1080 || (code & 0xfc) == 0x68
1081 || (code & 0xfc) == 0x6c
1082 || (code & 0xfc) == 0x80
1083 || (code & 0xfc) == 0xf0
1084 || (code & 0xfc) == 0x00
1085 || (code & 0xfc) == 0x10
1086 || (code & 0xfc) == 0xb0
1087 || (code & 0xfc) == 0x30
1088 || (code & 0xfc) == 0xa0
1089 || (code & 0xfc) == 0x20
1090 || (code & 0xfc) == 0x90)
1091 && (value & 0x8000) != 0)
1092 continue;
1093
1094 /* Note that we've changed the reldection contents, etc. */
1095 elf_section_data (sec)->relocs = internal_relocs;
1096 free_relocs = NULL;
1097
1098 elf_section_data (sec)->this_hdr.contents = contents;
1099 free_contents = NULL;
1100
1101 symtab_hdr->contents = (bfd_byte *) extsyms;
1102 free_extsyms = NULL;
1103
1104 /* Fix the opcode. */
1105 bfd_put_8 (abfd, 0xf7, contents + irel->r_offset - 2);
1106
1107 if ((code & 0xfc) == 0x78)
1108 code = 0x48 + (code & 0x03);
1109 else if ((code & 0xfc) == 0xd0)
1110 code = 0x30 + (code & 0x03);
1111 else if ((code & 0xfc) == 0x50)
1112 code = 0x20 + (code & 0x03);
1113 else if ((code & 0xfc) == 0x60)
1114 code = 0x18 + (code & 0x03);
1115 else if ((code & 0xfc) == 0x64)
1116 code = 0x08 + (code & 0x03);
1117 else if ((code & 0xfc) == 0x68)
1118 code = 0x1c + (code & 0x03);
1119 else if ((code & 0xfc) == 0x6c)
1120 code = 0x0c + (code & 0x03);
1121 else if ((code & 0xfc) == 0x80)
1122 code = 0xc0 + (code & 0x07);
1123 else if ((code & 0xfc) == 0xf0)
1124 code = 0xb0 + (code & 0x07);
1125 else if ((code & 0xfc) == 0x00)
1126 code = 0x80 + (code & 0x07);
1127 else if ((code & 0xfc) == 0x10)
1128 code = 0xa0 + (code & 0x07);
1129 else if ((code & 0xfc) == 0xb0)
1130 code = 0x70 + (code & 0x07);
1131 else if ((code & 0xfc) == 0x30)
1132 code = 0x60 + (code & 0x07);
1133 else if ((code & 0xfc) == 0xa0)
1134 code = 0xd0 + (code & 0x07);
1135 else if ((code & 0xfc) == 0x20)
1136 code = 0x90 + (code & 0x07);
1137 else if ((code & 0xfc) == 0x90)
1138 code = 0x50 + (code & 0x07);
1139
1140 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
1141
1142 /* Fix the relocation's type. */
1143 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1144 R_MN10200_16);
1145
1146 /* Delete one bytes of data. */
1147 if (!mn10200_elf_relax_delete_bytes (abfd, sec,
1148 irel->r_offset + 2, 1))
1149 goto error_return;
1150
1151 /* That will change things, so, we should relax again.
1152 Note that this is not required, and it may be slow. */
1153 *again = true;
1154 break;
1155
1156 /* movb (abs24),dn ->movbu (abs16),dn extxb bn */
1157 case 0xc4:
1158 /* Note that we've changed the reldection contents, etc. */
1159 elf_section_data (sec)->relocs = internal_relocs;
1160 free_relocs = NULL;
1161
1162 elf_section_data (sec)->this_hdr.contents = contents;
1163 free_contents = NULL;
1164
1165 symtab_hdr->contents = (bfd_byte *) extsyms;
1166 free_extsyms = NULL;
1167
1168 bfd_put_8 (abfd, 0xcc + (code & 0x03),
1169 contents + irel->r_offset - 2);
1170
1171 bfd_put_8 (abfd, 0xb8 + (code & 0x03),
1172 contents + irel->r_offset - 1);
1173
1174 /* Fix the relocation's type. */
1175 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1176 R_MN10200_16);
1177
1178 /* The reloc will be applied one byte in front of its
1179 current location. */
1180 irel->r_offset -= 1;
1181
1182 /* Delete one bytes of data. */
1183 if (!mn10200_elf_relax_delete_bytes (abfd, sec,
1184 irel->r_offset + 2, 1))
1185 goto error_return;
1186
1187 /* That will change things, so, we should relax again.
1188 Note that this is not required, and it may be slow. */
1189 *again = true;
1190 break;
1191 }
1192 }
1193 }
1194 }
1195
1196 if (free_relocs != NULL)
1197 {
1198 free (free_relocs);
1199 free_relocs = NULL;
1200 }
1201
1202 if (free_contents != NULL)
1203 {
1204 if (! link_info->keep_memory)
1205 free (free_contents);
1206 else
1207 {
1208 /* Cache the section contents for elf_link_input_bfd. */
1209 elf_section_data (sec)->this_hdr.contents = contents;
1210 }
1211 free_contents = NULL;
1212 }
1213
1214 if (free_extsyms != NULL)
1215 {
1216 if (! link_info->keep_memory)
1217 free (free_extsyms);
1218 else
1219 {
1220 /* Cache the symbols for elf_link_input_bfd. */
1221 symtab_hdr->contents = extsyms;
1222 }
1223 free_extsyms = NULL;
1224 }
1225
1226 return true;
1227
1228 error_return:
1229 if (free_relocs != NULL)
1230 free (free_relocs);
1231 if (free_contents != NULL)
1232 free (free_contents);
1233 if (free_extsyms != NULL)
1234 free (free_extsyms);
1235 return false;
1236 }
1237
1238 /* Delete some bytes from a section while relaxing. */
1239
1240 static boolean
1241 mn10200_elf_relax_delete_bytes (abfd, sec, addr, count)
1242 bfd *abfd;
1243 asection *sec;
1244 bfd_vma addr;
1245 int count;
1246 {
1247 Elf_Internal_Shdr *symtab_hdr;
1248 Elf32_External_Sym *extsyms;
1249 int shndx, index;
1250 bfd_byte *contents;
1251 Elf_Internal_Rela *irel, *irelend;
1252 Elf_Internal_Rela *irelalign;
1253 bfd_vma toaddr;
1254 Elf32_External_Sym *esym, *esymend;
1255 struct elf_link_hash_entry *sym_hash;
1256
1257 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1258 extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
1259
1260 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1261
1262 contents = elf_section_data (sec)->this_hdr.contents;
1263
1264 /* The deletion must stop at the next ALIGN reloc for an aligment
1265 power larger than the number of bytes we are deleting. */
1266
1267 irelalign = NULL;
1268 toaddr = sec->_cooked_size;
1269
1270 irel = elf_section_data (sec)->relocs;
1271 irelend = irel + sec->reloc_count;
1272
1273 /* Actually delete the bytes. */
1274 memmove (contents + addr, contents + addr + count, toaddr - addr - count);
1275 sec->_cooked_size -= count;
1276
1277 /* Adjust all the relocs. */
1278 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1279 {
1280 /* Get the new reloc address. */
1281 if ((irel->r_offset > addr
1282 && irel->r_offset < toaddr))
1283 irel->r_offset -= count;
1284 }
1285
1286 /* Adjust the local symbols defined in this section. */
1287 esym = extsyms;
1288 esymend = esym + symtab_hdr->sh_info;
1289 for (; esym < esymend; esym++)
1290 {
1291 Elf_Internal_Sym isym;
1292
1293 bfd_elf32_swap_symbol_in (abfd, esym, &isym);
1294
1295 if (isym.st_shndx == shndx
1296 && isym.st_value > addr
1297 && isym.st_value < toaddr)
1298 {
1299 isym.st_value -= count;
1300 bfd_elf32_swap_symbol_out (abfd, &isym, esym);
1301 }
1302 }
1303
1304 /* Now adjust the global symbols defined in this section. */
1305 esym = extsyms + symtab_hdr->sh_info;
1306 esymend = extsyms + (symtab_hdr->sh_size / sizeof (Elf32_External_Sym));
1307 for (index = 0; esym < esymend; esym++, index++)
1308 {
1309 Elf_Internal_Sym isym;
1310
1311 bfd_elf32_swap_symbol_in (abfd, esym, &isym);
1312 sym_hash = elf_sym_hashes (abfd)[index];
1313 if (isym.st_shndx == shndx
1314 && ((sym_hash)->root.type == bfd_link_hash_defined
1315 || (sym_hash)->root.type == bfd_link_hash_defweak)
1316 && (sym_hash)->root.u.def.section == sec
1317 && (sym_hash)->root.u.def.value > addr
1318 && (sym_hash)->root.u.def.value < toaddr)
1319 {
1320 (sym_hash)->root.u.def.value -= count;
1321 }
1322 }
1323
1324 return true;
1325 }
1326
1327 /* Return true if a symbol exists at the given address, else return
1328 false. */
1329 static boolean
1330 mn10200_elf_symbol_address_p (abfd, sec, extsyms, addr)
1331 bfd *abfd;
1332 asection *sec;
1333 Elf32_External_Sym *extsyms;
1334 bfd_vma addr;
1335 {
1336 Elf_Internal_Shdr *symtab_hdr;
1337 int shndx;
1338 Elf32_External_Sym *esym, *esymend;
1339 struct elf_link_hash_entry **sym_hash, **sym_hash_end;
1340
1341 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1342 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1343
1344 /* Examine all the symbols. */
1345 esym = extsyms;
1346 esymend = esym + symtab_hdr->sh_info;
1347 for (; esym < esymend; esym++)
1348 {
1349 Elf_Internal_Sym isym;
1350
1351 bfd_elf32_swap_symbol_in (abfd, esym, &isym);
1352
1353 if (isym.st_shndx == shndx
1354 && isym.st_value == addr)
1355 return true;
1356 }
1357
1358 sym_hash = elf_sym_hashes (abfd);
1359 sym_hash_end = (sym_hash
1360 + (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1361 - symtab_hdr->sh_info));
1362 for (; sym_hash < sym_hash_end; sym_hash++)
1363 {
1364 if (((*sym_hash)->root.type == bfd_link_hash_defined
1365 || (*sym_hash)->root.type == bfd_link_hash_defweak)
1366 && (*sym_hash)->root.u.def.section == sec
1367 && (*sym_hash)->root.u.def.value == addr)
1368 return true;
1369 }
1370 return false;
1371 }
1372
1373 /* This is a version of bfd_generic_get_relocated_section_contents
1374 which uses mn10200_elf_relocate_section. */
1375
1376 static bfd_byte *
1377 mn10200_elf_get_relocated_section_contents (output_bfd, link_info, link_order,
1378 data, relocateable, symbols)
1379 bfd *output_bfd;
1380 struct bfd_link_info *link_info;
1381 struct bfd_link_order *link_order;
1382 bfd_byte *data;
1383 boolean relocateable;
1384 asymbol **symbols;
1385 {
1386 Elf_Internal_Shdr *symtab_hdr;
1387 asection *input_section = link_order->u.indirect.section;
1388 bfd *input_bfd = input_section->owner;
1389 asection **sections = NULL;
1390 Elf_Internal_Rela *internal_relocs = NULL;
1391 Elf32_External_Sym *external_syms = NULL;
1392 Elf_Internal_Sym *internal_syms = NULL;
1393
1394 /* We only need to handle the case of relaxing, or of having a
1395 particular set of section contents, specially. */
1396 if (relocateable
1397 || elf_section_data (input_section)->this_hdr.contents == NULL)
1398 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
1399 link_order, data,
1400 relocateable,
1401 symbols);
1402
1403 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1404
1405 memcpy (data, elf_section_data (input_section)->this_hdr.contents,
1406 input_section->_raw_size);
1407
1408 if ((input_section->flags & SEC_RELOC) != 0
1409 && input_section->reloc_count > 0)
1410 {
1411 Elf_Internal_Sym *isymp;
1412 asection **secpp;
1413 Elf32_External_Sym *esym, *esymend;
1414
1415 if (symtab_hdr->contents != NULL)
1416 external_syms = (Elf32_External_Sym *) symtab_hdr->contents;
1417 else
1418 {
1419 external_syms = ((Elf32_External_Sym *)
1420 bfd_malloc (symtab_hdr->sh_info
1421 * sizeof (Elf32_External_Sym)));
1422 if (external_syms == NULL && symtab_hdr->sh_info > 0)
1423 goto error_return;
1424 if (bfd_seek (input_bfd, symtab_hdr->sh_offset, SEEK_SET) != 0
1425 || (bfd_read (external_syms, sizeof (Elf32_External_Sym),
1426 symtab_hdr->sh_info, input_bfd)
1427 != (symtab_hdr->sh_info * sizeof (Elf32_External_Sym))))
1428 goto error_return;
1429 }
1430
1431 internal_relocs = (_bfd_elf32_link_read_relocs
1432 (input_bfd, input_section, (PTR) NULL,
1433 (Elf_Internal_Rela *) NULL, false));
1434 if (internal_relocs == NULL)
1435 goto error_return;
1436
1437 internal_syms = ((Elf_Internal_Sym *)
1438 bfd_malloc (symtab_hdr->sh_info
1439 * sizeof (Elf_Internal_Sym)));
1440 if (internal_syms == NULL && symtab_hdr->sh_info > 0)
1441 goto error_return;
1442
1443 sections = (asection **) bfd_malloc (symtab_hdr->sh_info
1444 * sizeof (asection *));
1445 if (sections == NULL && symtab_hdr->sh_info > 0)
1446 goto error_return;
1447
1448 isymp = internal_syms;
1449 secpp = sections;
1450 esym = external_syms;
1451 esymend = esym + symtab_hdr->sh_info;
1452 for (; esym < esymend; ++esym, ++isymp, ++secpp)
1453 {
1454 asection *isec;
1455
1456 bfd_elf32_swap_symbol_in (input_bfd, esym, isymp);
1457
1458 if (isymp->st_shndx == SHN_UNDEF)
1459 isec = bfd_und_section_ptr;
1460 else if (isymp->st_shndx > 0 && isymp->st_shndx < SHN_LORESERVE)
1461 isec = bfd_section_from_elf_index (input_bfd, isymp->st_shndx);
1462 else if (isymp->st_shndx == SHN_ABS)
1463 isec = bfd_abs_section_ptr;
1464 else if (isymp->st_shndx == SHN_COMMON)
1465 isec = bfd_com_section_ptr;
1466 else
1467 {
1468 /* Who knows? */
1469 isec = NULL;
1470 }
1471
1472 *secpp = isec;
1473 }
1474
1475 if (! mn10200_elf_relocate_section (output_bfd, link_info, input_bfd,
1476 input_section, data, internal_relocs,
1477 internal_syms, sections))
1478 goto error_return;
1479
1480 if (sections != NULL)
1481 free (sections);
1482 sections = NULL;
1483 if (internal_syms != NULL)
1484 free (internal_syms);
1485 internal_syms = NULL;
1486 if (external_syms != NULL && symtab_hdr->contents == NULL)
1487 free (external_syms);
1488 external_syms = NULL;
1489 if (internal_relocs != elf_section_data (input_section)->relocs)
1490 free (internal_relocs);
1491 internal_relocs = NULL;
1492 }
1493
1494 return data;
1495
1496 error_return:
1497 if (internal_relocs != NULL
1498 && internal_relocs != elf_section_data (input_section)->relocs)
1499 free (internal_relocs);
1500 if (external_syms != NULL && symtab_hdr->contents == NULL)
1501 free (external_syms);
1502 if (internal_syms != NULL)
1503 free (internal_syms);
1504 if (sections != NULL)
1505 free (sections);
1506 return NULL;
1507 }
1508
1509
1510 #define TARGET_LITTLE_SYM bfd_elf32_mn10200_vec
1511 #define TARGET_LITTLE_NAME "elf32-mn10200"
1512 #define ELF_ARCH bfd_arch_mn10200
1513 #define ELF_MACHINE_CODE EM_CYGNUS_MN10200
1514 #define ELF_MAXPAGESIZE 0x1000
1515
1516 #define elf_info_to_howto mn10200_info_to_howto
1517 #define elf_info_to_howto_rel 0
1518 #define elf_backend_relocate_section mn10200_elf_relocate_section
1519 #define bfd_elf32_bfd_relax_section mn10200_elf_relax_section
1520 #define bfd_elf32_bfd_get_relocated_section_contents \
1521 mn10200_elf_get_relocated_section_contents
1522
1523 #define elf_symbol_leading_char '_'
1524
1525 #include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.058083 seconds and 5 git commands to generate.