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