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