projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
bfd/
[deliverable/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, 2003
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 *
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
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
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 \f
329 /* Relocate an MN10200 ELF section. */
330 static bfd_boolean
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 (h, sym_hashes, r_symndx, symtab_hdr,
383 relocation, sec, unresolved_reloc,
384 info, warned);
385 }
386
387 r = mn10200_elf_final_link_relocate (howto, input_bfd, output_bfd,
388 input_section,
389 contents, rel->r_offset,
390 relocation, rel->r_addend,
391 info, sec, h == NULL);
392
393 if (r != bfd_reloc_ok)
394 {
395 const char *name;
396 const char *msg = (const char *) 0;
397
398 if (h != NULL)
399 name = h->root.root.string;
400 else
401 {
402 name = (bfd_elf_string_from_elf_section
403 (input_bfd, symtab_hdr->sh_link, sym->st_name));
404 if (name == NULL || *name == '\0')
405 name = bfd_section_name (input_bfd, sec);
406 }
407
408 switch (r)
409 {
410 case bfd_reloc_overflow:
411 if (! ((*info->callbacks->reloc_overflow)
412 (info, name, howto->name, (bfd_vma) 0,
413 input_bfd, input_section, rel->r_offset)))
414 return FALSE;
415 break;
416
417 case bfd_reloc_undefined:
418 if (! ((*info->callbacks->undefined_symbol)
419 (info, name, input_bfd, input_section,
420 rel->r_offset, TRUE)))
421 return FALSE;
422 break;
423
424 case bfd_reloc_outofrange:
425 msg = _("internal error: out of range error");
426 goto common_error;
427
428 case bfd_reloc_notsupported:
429 msg = _("internal error: unsupported relocation error");
430 goto common_error;
431
432 case bfd_reloc_dangerous:
433 msg = _("internal error: dangerous error");
434 goto common_error;
435
436 default:
437 msg = _("internal error: unknown error");
438 /* fall through */
439
440 common_error:
441 if (!((*info->callbacks->warning)
442 (info, msg, name, input_bfd, input_section,
443 rel->r_offset)))
444 return FALSE;
445 break;
446 }
447 }
448 }
449
450 return TRUE;
451 }
452
453 /* This function handles relaxing for the mn10200.
454
455 There are quite a few relaxing opportunities available on the mn10200:
456
457 * jsr:24 -> jsr:16 2 bytes
458
459 * jmp:24 -> jmp:16 2 bytes
460 * jmp:16 -> bra:8 1 byte
461
462 * If the previous instruction is a conditional branch
463 around the jump/bra, we may be able to reverse its condition
464 and change its target to the jump's target. The jump/bra
465 can then be deleted. 2 bytes
466
467 * mov abs24 -> mov abs16 2 byte savings
468
469 * Most instructions which accept imm24 can relax to imm16 2 bytes
470 - Most instructions which accept imm16 can relax to imm8 1 byte
471
472 * Most instructions which accept d24 can relax to d16 2 bytes
473 - Most instructions which accept d16 can relax to d8 1 byte
474
475 abs24, imm24, d24 all look the same at the reloc level. It
476 might make the code simpler if we had different relocs for
477 the various relaxable operand types.
478
479 We don't handle imm16->imm8 or d16->d8 as they're very rare
480 and somewhat more difficult to support. */
481
482 static bfd_boolean
483 mn10200_elf_relax_section (abfd, sec, link_info, again)
484 bfd *abfd;
485 asection *sec;
486 struct bfd_link_info *link_info;
487 bfd_boolean *again;
488 {
489 Elf_Internal_Shdr *symtab_hdr;
490 Elf_Internal_Rela *internal_relocs;
491 Elf_Internal_Rela *irel, *irelend;
492 bfd_byte *contents = NULL;
493 Elf_Internal_Sym *isymbuf = NULL;
494
495 /* Assume nothing changes. */
496 *again = FALSE;
497
498 /* We don't have to do anything for a relocatable link, if
499 this section does not have relocs, or if this is not a
500 code section. */
501 if (link_info->relocatable
502 || (sec->flags & SEC_RELOC) == 0
503 || sec->reloc_count == 0
504 || (sec->flags & SEC_CODE) == 0)
505 return TRUE;
506
507 /* If this is the first time we have been called for this section,
508 initialize the cooked size. */
509 if (sec->_cooked_size == 0)
510 sec->_cooked_size = sec->_raw_size;
511
512 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
513
514 /* Get a copy of the native relocations. */
515 internal_relocs = (_bfd_elf_link_read_relocs
516 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
517 link_info->keep_memory));
518 if (internal_relocs == NULL)
519 goto error_return;
520
521 /* Walk through them looking for relaxing opportunities. */
522 irelend = internal_relocs + sec->reloc_count;
523 for (irel = internal_relocs; irel < irelend; irel++)
524 {
525 bfd_vma symval;
526
527 /* If this isn't something that can be relaxed, then ignore
528 this reloc. */
529 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_NONE
530 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_8
531 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_MAX)
532 continue;
533
534 /* Get the section contents if we haven't done so already. */
535 if (contents == NULL)
536 {
537 /* Get cached copy if it exists. */
538 if (elf_section_data (sec)->this_hdr.contents != NULL)
539 contents = elf_section_data (sec)->this_hdr.contents;
540 else
541 {
542 /* Go get them off disk. */
543 contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
544 if (contents == NULL)
545 goto error_return;
546
547 if (! bfd_get_section_contents (abfd, sec, contents,
548 (file_ptr) 0, sec->_raw_size))
549 goto error_return;
550 }
551 }
552
553 /* Read this BFD's local symbols if we haven't done so already. */
554 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
555 {
556 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
557 if (isymbuf == NULL)
558 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
559 symtab_hdr->sh_info, 0,
560 NULL, NULL, NULL);
561 if (isymbuf == NULL)
562 goto error_return;
563 }
564
565 /* Get the value of the symbol referred to by the reloc. */
566 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
567 {
568 /* A local symbol. */
569 Elf_Internal_Sym *isym;
570 asection *sym_sec;
571
572 isym = isymbuf + ELF32_R_SYM (irel->r_info);
573 if (isym->st_shndx == SHN_UNDEF)
574 sym_sec = bfd_und_section_ptr;
575 else if (isym->st_shndx == SHN_ABS)
576 sym_sec = bfd_abs_section_ptr;
577 else if (isym->st_shndx == SHN_COMMON)
578 sym_sec = bfd_com_section_ptr;
579 else
580 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
581 symval = (isym->st_value
582 + sym_sec->output_section->vma
583 + sym_sec->output_offset);
584 }
585 else
586 {
587 unsigned long indx;
588 struct elf_link_hash_entry *h;
589
590 /* An external symbol. */
591 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
592 h = elf_sym_hashes (abfd)[indx];
593 BFD_ASSERT (h != NULL);
594 if (h->root.type != bfd_link_hash_defined
595 && h->root.type != bfd_link_hash_defweak)
596 {
597 /* This appears to be a reference to an undefined
598 symbol. Just ignore it--it will be caught by the
599 regular reloc processing. */
600 continue;
601 }
602
603 symval = (h->root.u.def.value
604 + h->root.u.def.section->output_section->vma
605 + h->root.u.def.section->output_offset);
606 }
607
608 /* For simplicity of coding, we are going to modify the section
609 contents, the section relocs, and the BFD symbol table. We
610 must tell the rest of the code not to free up this
611 information. It would be possible to instead create a table
612 of changes which have to be made, as is done in coff-mips.c;
613 that would be more work, but would require less memory when
614 the linker is run. */
615
616 /* Try to turn a 24bit pc-relative branch/call into a 16bit pc-relative
617 branch/call. */
618 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_PCREL24)
619 {
620 bfd_vma value = symval;
621
622 /* Deal with pc-relative gunk. */
623 value -= (sec->output_section->vma + sec->output_offset);
624 value -= (irel->r_offset + 3);
625 value += irel->r_addend;
626
627 /* See if the value will fit in 16 bits, note the high value is
628 0x7fff + 2 as the target will be two bytes closer if we are
629 able to relax. */
630 if ((long) value < 0x8001 && (long) value > -0x8000)
631 {
632 unsigned char code;
633
634 /* Get the opcode. */
635 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
636
637 if (code != 0xe0 && code != 0xe1)
638 continue;
639
640 /* Note that we've changed the relocs, section contents, etc. */
641 elf_section_data (sec)->relocs = internal_relocs;
642 elf_section_data (sec)->this_hdr.contents = contents;
643 symtab_hdr->contents = (unsigned char *) isymbuf;
644
645 /* Fix the opcode. */
646 if (code == 0xe0)
647 bfd_put_8 (abfd, 0xfc, contents + irel->r_offset - 2);
648 else if (code == 0xe1)
649 bfd_put_8 (abfd, 0xfd, contents + irel->r_offset - 2);
650
651 /* Fix the relocation's type. */
652 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
653 R_MN10200_PCREL16);
654
655 /* The opcode got shorter too, so we have to fix the offset. */
656 irel->r_offset -= 1;
657
658 /* Delete two bytes of data. */
659 if (!mn10200_elf_relax_delete_bytes (abfd, sec,
660 irel->r_offset + 1, 2))
661 goto error_return;
662
663 /* That will change things, so, we should relax again.
664 Note that this is not required, and it may be slow. */
665 *again = TRUE;
666 }
667 }
668
669 /* Try to turn a 16bit pc-relative branch into a 8bit pc-relative
670 branch. */
671 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_PCREL16)
672 {
673 bfd_vma value = symval;
674
675 /* Deal with pc-relative gunk. */
676 value -= (sec->output_section->vma + sec->output_offset);
677 value -= (irel->r_offset + 2);
678 value += irel->r_addend;
679
680 /* See if the value will fit in 8 bits, note the high value is
681 0x7f + 1 as the target will be one bytes closer if we are
682 able to relax. */
683 if ((long) value < 0x80 && (long) value > -0x80)
684 {
685 unsigned char code;
686
687 /* Get the opcode. */
688 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
689
690 if (code != 0xfc)
691 continue;
692
693 /* Note that we've changed the relocs, section contents, etc. */
694 elf_section_data (sec)->relocs = internal_relocs;
695 elf_section_data (sec)->this_hdr.contents = contents;
696 symtab_hdr->contents = (unsigned char *) isymbuf;
697
698 /* Fix the opcode. */
699 bfd_put_8 (abfd, 0xea, contents + irel->r_offset - 1);
700
701 /* Fix the relocation's type. */
702 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
703 R_MN10200_PCREL8);
704
705 /* Delete one byte of data. */
706 if (!mn10200_elf_relax_delete_bytes (abfd, sec,
707 irel->r_offset + 1, 1))
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 eliminate an unconditional 8 bit pc-relative branch
717 which immediately follows a conditional 8 bit pc-relative
718 branch around the unconditional branch.
719
720 original: new:
721 bCC lab1 bCC' lab2
722 bra lab2
723 lab1: lab1:
724
725 This happens when the bCC can't reach lab2 at assembly time,
726 but due to other relaxations it can reach at link time. */
727 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_PCREL8)
728 {
729 Elf_Internal_Rela *nrel;
730 bfd_vma value = symval;
731 unsigned char code;
732
733 /* Deal with pc-relative gunk. */
734 value -= (sec->output_section->vma + sec->output_offset);
735 value -= (irel->r_offset + 1);
736 value += irel->r_addend;
737
738 /* Do nothing if this reloc is the last byte in the section. */
739 if (irel->r_offset == sec->_cooked_size)
740 continue;
741
742 /* See if the next instruction is an unconditional pc-relative
743 branch, more often than not this test will fail, so we
744 test it first to speed things up. */
745 code = bfd_get_8 (abfd, contents + irel->r_offset + 1);
746 if (code != 0xea)
747 continue;
748
749 /* Also make sure the next relocation applies to the next
750 instruction and that it's a pc-relative 8 bit branch. */
751 nrel = irel + 1;
752 if (nrel == irelend
753 || irel->r_offset + 2 != nrel->r_offset
754 || ELF32_R_TYPE (nrel->r_info) != (int) R_MN10200_PCREL8)
755 continue;
756
757 /* Make sure our destination immediately follows the
758 unconditional branch. */
759 if (symval != (sec->output_section->vma + sec->output_offset
760 + irel->r_offset + 3))
761 continue;
762
763 /* Now make sure we are a conditional branch. This may not
764 be necessary, but why take the chance.
765
766 Note these checks assume that R_MN10200_PCREL8 relocs
767 only occur on bCC and bCCx insns. If they occured
768 elsewhere, we'd need to know the start of this insn
769 for this check to be accurate. */
770 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
771 if (code != 0xe0 && code != 0xe1 && code != 0xe2
772 && code != 0xe3 && code != 0xe4 && code != 0xe5
773 && code != 0xe6 && code != 0xe7 && code != 0xe8
774 && code != 0xe9 && code != 0xec && code != 0xed
775 && code != 0xee && code != 0xef && code != 0xfc
776 && code != 0xfd && code != 0xfe && code != 0xff)
777 continue;
778
779 /* We also have to be sure there is no symbol/label
780 at the unconditional branch. */
781 if (mn10200_elf_symbol_address_p (abfd, sec, isymbuf,
782 irel->r_offset + 1))
783 continue;
784
785 /* Note that we've changed the relocs, section contents, etc. */
786 elf_section_data (sec)->relocs = internal_relocs;
787 elf_section_data (sec)->this_hdr.contents = contents;
788 symtab_hdr->contents = (unsigned char *) isymbuf;
789
790 /* Reverse the condition of the first branch. */
791 switch (code)
792 {
793 case 0xfc:
794 code = 0xfd;
795 break;
796 case 0xfd:
797 code = 0xfc;
798 break;
799 case 0xfe:
800 code = 0xff;
801 break;
802 case 0xff:
803 code = 0xfe;
804 break;
805 case 0xe8:
806 code = 0xe9;
807 break;
808 case 0xe9:
809 code = 0xe8;
810 break;
811 case 0xe0:
812 code = 0xe2;
813 break;
814 case 0xe2:
815 code = 0xe0;
816 break;
817 case 0xe3:
818 code = 0xe1;
819 break;
820 case 0xe1:
821 code = 0xe3;
822 break;
823 case 0xe4:
824 code = 0xe6;
825 break;
826 case 0xe6:
827 code = 0xe4;
828 break;
829 case 0xe7:
830 code = 0xe5;
831 break;
832 case 0xe5:
833 code = 0xe7;
834 break;
835 case 0xec:
836 code = 0xed;
837 break;
838 case 0xed:
839 code = 0xec;
840 break;
841 case 0xee:
842 code = 0xef;
843 break;
844 case 0xef:
845 code = 0xee;
846 break;
847 }
848 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
849
850 /* Set the reloc type and symbol for the first branch
851 from the second branch. */
852 irel->r_info = nrel->r_info;
853
854 /* Make the reloc for the second branch a null reloc. */
855 nrel->r_info = ELF32_R_INFO (ELF32_R_SYM (nrel->r_info),
856 R_MN10200_NONE);
857
858 /* Delete two bytes of data. */
859 if (!mn10200_elf_relax_delete_bytes (abfd, sec,
860 irel->r_offset + 1, 2))
861 goto error_return;
862
863 /* That will change things, so, we should relax again.
864 Note that this is not required, and it may be slow. */
865 *again = TRUE;
866 }
867
868 /* Try to turn a 24bit immediate, displacement or absolute address
869 into a 16bit immediate, displacement or absolute address. */
870 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_24)
871 {
872 bfd_vma value = symval;
873
874 /* See if the value will fit in 16 bits.
875 We allow any 16bit match here. We prune those we can't
876 handle below. */
877 if ((long) value < 0x7fff && (long) value > -0x8000)
878 {
879 unsigned char code;
880
881 /* All insns which have 24bit operands are 5 bytes long,
882 the first byte will always be 0xf4, but we double check
883 it just in case. */
884
885 /* Get the first opcode. */
886 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
887
888 if (code != 0xf4)
889 continue;
890
891 /* Get the second opcode. */
892 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
893
894 switch (code & 0xfc)
895 {
896 /* mov imm24,dn -> mov imm16,dn */
897 case 0x70:
898 /* Not safe if the high bit is on as relaxing may
899 move the value out of high mem and thus not fit
900 in a signed 16bit value. */
901 if (value & 0x8000)
902 continue;
903
904 /* Note that we've changed the relocation contents, etc. */
905 elf_section_data (sec)->relocs = internal_relocs;
906 elf_section_data (sec)->this_hdr.contents = contents;
907 symtab_hdr->contents = (unsigned char *) isymbuf;
908
909 /* Fix the opcode. */
910 bfd_put_8 (abfd, 0xf8 + (code & 0x03),
911 contents + irel->r_offset - 2);
912
913 /* Fix the relocation's type. */
914 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
915 R_MN10200_16);
916
917 /* The opcode got shorter too, so we have to fix the
918 offset. */
919 irel->r_offset -= 1;
920
921 /* Delete two bytes of data. */
922 if (!mn10200_elf_relax_delete_bytes (abfd, sec,
923 irel->r_offset + 1, 2))
924 goto error_return;
925
926 /* That will change things, so, we should relax again.
927 Note that this is not required, and it may be slow. */
928 *again = TRUE;
929 break;
930
931 /* mov imm24,an -> mov imm16,an
932 cmp imm24,an -> cmp imm16,an
933 mov (abs24),dn -> mov (abs16),dn
934 mov dn,(abs24) -> mov dn,(abs16)
935 movb dn,(abs24) -> movb dn,(abs16)
936 movbu (abs24),dn -> movbu (abs16),dn */
937 case 0x74:
938 case 0x7c:
939 case 0xc0:
940 case 0x40:
941 case 0x44:
942 case 0xc8:
943 /* Note that we've changed the relocation contents, etc. */
944 elf_section_data (sec)->relocs = internal_relocs;
945 elf_section_data (sec)->this_hdr.contents = contents;
946 symtab_hdr->contents = (unsigned char *) isymbuf;
947
948 if ((code & 0xfc) == 0x74)
949 code = 0xdc + (code & 0x03);
950 else if ((code & 0xfc) == 0x7c)
951 code = 0xec + (code & 0x03);
952 else if ((code & 0xfc) == 0xc0)
953 code = 0xc8 + (code & 0x03);
954 else if ((code & 0xfc) == 0x40)
955 code = 0xc0 + (code & 0x03);
956 else if ((code & 0xfc) == 0x44)
957 code = 0xc4 + (code & 0x03);
958 else if ((code & 0xfc) == 0xc8)
959 code = 0xcc + (code & 0x03);
960
961 /* Fix the opcode. */
962 bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
963
964 /* Fix the relocation's type. */
965 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
966 R_MN10200_16);
967
968 /* The opcode got shorter too, so we have to fix the
969 offset. */
970 irel->r_offset -= 1;
971
972 /* Delete two bytes of data. */
973 if (!mn10200_elf_relax_delete_bytes (abfd, sec,
974 irel->r_offset + 1, 2))
975 goto error_return;
976
977 /* That will change things, so, we should relax again.
978 Note that this is not required, and it may be slow. */
979 *again = TRUE;
980 break;
981
982 /* cmp imm24,dn -> cmp imm16,dn
983 mov (abs24),an -> mov (abs16),an
984 mov an,(abs24) -> mov an,(abs16)
985 add imm24,dn -> add imm16,dn
986 add imm24,an -> add imm16,an
987 sub imm24,dn -> sub imm16,dn
988 sub imm24,an -> sub imm16,an
989 And all d24->d16 in memory ops. */
990 case 0x78:
991 case 0xd0:
992 case 0x50:
993 case 0x60:
994 case 0x64:
995 case 0x68:
996 case 0x6c:
997 case 0x80:
998 case 0xf0:
999 case 0x00:
1000 case 0x10:
1001 case 0xb0:
1002 case 0x30:
1003 case 0xa0:
1004 case 0x20:
1005 case 0x90:
1006 /* Not safe if the high bit is on as relaxing may
1007 move the value out of high mem and thus not fit
1008 in a signed 16bit value. */
1009 if (((code & 0xfc) == 0x78
1010 || (code & 0xfc) == 0x60
1011 || (code & 0xfc) == 0x64
1012 || (code & 0xfc) == 0x68
1013 || (code & 0xfc) == 0x6c
1014 || (code & 0xfc) == 0x80
1015 || (code & 0xfc) == 0xf0
1016 || (code & 0xfc) == 0x00
1017 || (code & 0xfc) == 0x10
1018 || (code & 0xfc) == 0xb0
1019 || (code & 0xfc) == 0x30
1020 || (code & 0xfc) == 0xa0
1021 || (code & 0xfc) == 0x20
1022 || (code & 0xfc) == 0x90)
1023 && (value & 0x8000) != 0)
1024 continue;
1025
1026 /* Note that we've changed the relocation contents, etc. */
1027 elf_section_data (sec)->relocs = internal_relocs;
1028 elf_section_data (sec)->this_hdr.contents = contents;
1029 symtab_hdr->contents = (unsigned char *) isymbuf;
1030
1031 /* Fix the opcode. */
1032 bfd_put_8 (abfd, 0xf7, contents + irel->r_offset - 2);
1033
1034 if ((code & 0xfc) == 0x78)
1035 code = 0x48 + (code & 0x03);
1036 else if ((code & 0xfc) == 0xd0)
1037 code = 0x30 + (code & 0x03);
1038 else if ((code & 0xfc) == 0x50)
1039 code = 0x20 + (code & 0x03);
1040 else if ((code & 0xfc) == 0x60)
1041 code = 0x18 + (code & 0x03);
1042 else if ((code & 0xfc) == 0x64)
1043 code = 0x08 + (code & 0x03);
1044 else if ((code & 0xfc) == 0x68)
1045 code = 0x1c + (code & 0x03);
1046 else if ((code & 0xfc) == 0x6c)
1047 code = 0x0c + (code & 0x03);
1048 else if ((code & 0xfc) == 0x80)
1049 code = 0xc0 + (code & 0x07);
1050 else if ((code & 0xfc) == 0xf0)
1051 code = 0xb0 + (code & 0x07);
1052 else if ((code & 0xfc) == 0x00)
1053 code = 0x80 + (code & 0x07);
1054 else if ((code & 0xfc) == 0x10)
1055 code = 0xa0 + (code & 0x07);
1056 else if ((code & 0xfc) == 0xb0)
1057 code = 0x70 + (code & 0x07);
1058 else if ((code & 0xfc) == 0x30)
1059 code = 0x60 + (code & 0x07);
1060 else if ((code & 0xfc) == 0xa0)
1061 code = 0xd0 + (code & 0x07);
1062 else if ((code & 0xfc) == 0x20)
1063 code = 0x90 + (code & 0x07);
1064 else if ((code & 0xfc) == 0x90)
1065 code = 0x50 + (code & 0x07);
1066
1067 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
1068
1069 /* Fix the relocation's type. */
1070 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1071 R_MN10200_16);
1072
1073 /* Delete one bytes of data. */
1074 if (!mn10200_elf_relax_delete_bytes (abfd, sec,
1075 irel->r_offset + 2, 1))
1076 goto error_return;
1077
1078 /* That will change things, so, we should relax again.
1079 Note that this is not required, and it may be slow. */
1080 *again = TRUE;
1081 break;
1082
1083 /* movb (abs24),dn ->movbu (abs16),dn extxb bn */
1084 case 0xc4:
1085 /* Note that we've changed the reldection contents, etc. */
1086 elf_section_data (sec)->relocs = internal_relocs;
1087 elf_section_data (sec)->this_hdr.contents = contents;
1088 symtab_hdr->contents = (unsigned char *) isymbuf;
1089
1090 bfd_put_8 (abfd, 0xcc + (code & 0x03),
1091 contents + irel->r_offset - 2);
1092
1093 bfd_put_8 (abfd, 0xb8 + (code & 0x03),
1094 contents + irel->r_offset - 1);
1095
1096 /* Fix the relocation's type. */
1097 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1098 R_MN10200_16);
1099
1100 /* The reloc will be applied one byte in front of its
1101 current location. */
1102 irel->r_offset -= 1;
1103
1104 /* Delete one bytes of data. */
1105 if (!mn10200_elf_relax_delete_bytes (abfd, sec,
1106 irel->r_offset + 2, 1))
1107 goto error_return;
1108
1109 /* That will change things, so, we should relax again.
1110 Note that this is not required, and it may be slow. */
1111 *again = TRUE;
1112 break;
1113 }
1114 }
1115 }
1116 }
1117
1118 if (isymbuf != NULL
1119 && symtab_hdr->contents != (unsigned char *) isymbuf)
1120 {
1121 if (! link_info->keep_memory)
1122 free (isymbuf);
1123 else
1124 {
1125 /* Cache the symbols for elf_link_input_bfd. */
1126 symtab_hdr->contents = (unsigned char *) isymbuf;
1127 }
1128 }
1129
1130 if (contents != NULL
1131 && elf_section_data (sec)->this_hdr.contents != contents)
1132 {
1133 if (! link_info->keep_memory)
1134 free (contents);
1135 else
1136 {
1137 /* Cache the section contents for elf_link_input_bfd. */
1138 elf_section_data (sec)->this_hdr.contents = contents;
1139 }
1140 }
1141
1142 if (internal_relocs != NULL
1143 && elf_section_data (sec)->relocs != internal_relocs)
1144 free (internal_relocs);
1145
1146 return TRUE;
1147
1148 error_return:
1149 if (isymbuf != NULL
1150 && symtab_hdr->contents != (unsigned char *) isymbuf)
1151 free (isymbuf);
1152 if (contents != NULL
1153 && elf_section_data (sec)->this_hdr.contents != contents)
1154 free (contents);
1155 if (internal_relocs != NULL
1156 && elf_section_data (sec)->relocs != internal_relocs)
1157 free (internal_relocs);
1158
1159 return FALSE;
1160 }
1161
1162 /* Delete some bytes from a section while relaxing. */
1163
1164 static bfd_boolean
1165 mn10200_elf_relax_delete_bytes (abfd, sec, addr, count)
1166 bfd *abfd;
1167 asection *sec;
1168 bfd_vma addr;
1169 int count;
1170 {
1171 Elf_Internal_Shdr *symtab_hdr;
1172 unsigned int sec_shndx;
1173 bfd_byte *contents;
1174 Elf_Internal_Rela *irel, *irelend;
1175 Elf_Internal_Rela *irelalign;
1176 bfd_vma toaddr;
1177 Elf_Internal_Sym *isym;
1178 Elf_Internal_Sym *isymend;
1179 struct elf_link_hash_entry **sym_hashes;
1180 struct elf_link_hash_entry **end_hashes;
1181 unsigned int symcount;
1182
1183 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1184
1185 contents = elf_section_data (sec)->this_hdr.contents;
1186
1187 /* The deletion must stop at the next ALIGN reloc for an aligment
1188 power larger than the number of bytes we are deleting. */
1189
1190 irelalign = NULL;
1191 toaddr = sec->_cooked_size;
1192
1193 irel = elf_section_data (sec)->relocs;
1194 irelend = irel + sec->reloc_count;
1195
1196 /* Actually delete the bytes. */
1197 memmove (contents + addr, contents + addr + count,
1198 (size_t) (toaddr - addr - count));
1199 sec->_cooked_size -= count;
1200
1201 /* Adjust all the relocs. */
1202 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1203 {
1204 /* Get the new reloc address. */
1205 if ((irel->r_offset > addr
1206 && irel->r_offset < toaddr))
1207 irel->r_offset -= count;
1208 }
1209
1210 /* Adjust the local symbols defined in this section. */
1211 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1212 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1213 for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
1214 {
1215 if (isym->st_shndx == sec_shndx
1216 && isym->st_value > addr
1217 && isym->st_value < toaddr)
1218 isym->st_value -= count;
1219 }
1220
1221 /* Now adjust the global symbols defined in this section. */
1222 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1223 - symtab_hdr->sh_info);
1224 sym_hashes = elf_sym_hashes (abfd);
1225 end_hashes = sym_hashes + symcount;
1226 for (; sym_hashes < end_hashes; sym_hashes++)
1227 {
1228 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1229 if ((sym_hash->root.type == bfd_link_hash_defined
1230 || sym_hash->root.type == bfd_link_hash_defweak)
1231 && sym_hash->root.u.def.section == sec
1232 && sym_hash->root.u.def.value > addr
1233 && sym_hash->root.u.def.value < toaddr)
1234 {
1235 sym_hash->root.u.def.value -= count;
1236 }
1237 }
1238
1239 return TRUE;
1240 }
1241
1242 /* Return TRUE if a symbol exists at the given address, else return
1243 FALSE. */
1244 static bfd_boolean
1245 mn10200_elf_symbol_address_p (abfd, sec, isym, addr)
1246 bfd *abfd;
1247 asection *sec;
1248 Elf_Internal_Sym *isym;
1249 bfd_vma addr;
1250 {
1251 Elf_Internal_Shdr *symtab_hdr;
1252 unsigned int sec_shndx;
1253 Elf_Internal_Sym *isymend;
1254 struct elf_link_hash_entry **sym_hashes;
1255 struct elf_link_hash_entry **end_hashes;
1256 unsigned int symcount;
1257
1258 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1259
1260 /* Examine all the local symbols. */
1261 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1262 for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
1263 {
1264 if (isym->st_shndx == sec_shndx
1265 && isym->st_value == addr)
1266 return TRUE;
1267 }
1268
1269 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1270 - symtab_hdr->sh_info);
1271 sym_hashes = elf_sym_hashes (abfd);
1272 end_hashes = sym_hashes + symcount;
1273 for (; sym_hashes < end_hashes; sym_hashes++)
1274 {
1275 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1276 if ((sym_hash->root.type == bfd_link_hash_defined
1277 || sym_hash->root.type == bfd_link_hash_defweak)
1278 && sym_hash->root.u.def.section == sec
1279 && sym_hash->root.u.def.value == addr)
1280 return TRUE;
1281 }
1282
1283 return FALSE;
1284 }
1285
1286 /* This is a version of bfd_generic_get_relocated_section_contents
1287 which uses mn10200_elf_relocate_section. */
1288
1289 static bfd_byte *
1290 mn10200_elf_get_relocated_section_contents (output_bfd, link_info, link_order,
1291 data, relocatable, symbols)
1292 bfd *output_bfd;
1293 struct bfd_link_info *link_info;
1294 struct bfd_link_order *link_order;
1295 bfd_byte *data;
1296 bfd_boolean relocatable;
1297 asymbol **symbols;
1298 {
1299 Elf_Internal_Shdr *symtab_hdr;
1300 asection *input_section = link_order->u.indirect.section;
1301 bfd *input_bfd = input_section->owner;
1302 asection **sections = NULL;
1303 Elf_Internal_Rela *internal_relocs = NULL;
1304 Elf_Internal_Sym *isymbuf = NULL;
1305
1306 /* We only need to handle the case of relaxing, or of having a
1307 particular set of section contents, specially. */
1308 if (relocatable
1309 || elf_section_data (input_section)->this_hdr.contents == NULL)
1310 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
1311 link_order, data,
1312 relocatable,
1313 symbols);
1314
1315 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1316
1317 memcpy (data, elf_section_data (input_section)->this_hdr.contents,
1318 (size_t) input_section->_raw_size);
1319
1320 if ((input_section->flags & SEC_RELOC) != 0
1321 && input_section->reloc_count > 0)
1322 {
1323 Elf_Internal_Sym *isym;
1324 Elf_Internal_Sym *isymend;
1325 asection **secpp;
1326 bfd_size_type amt;
1327
1328 internal_relocs = (_bfd_elf_link_read_relocs
1329 (input_bfd, input_section, (PTR) NULL,
1330 (Elf_Internal_Rela *) NULL, FALSE));
1331 if (internal_relocs == NULL)
1332 goto error_return;
1333
1334 if (symtab_hdr->sh_info != 0)
1335 {
1336 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1337 if (isymbuf == NULL)
1338 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
1339 symtab_hdr->sh_info, 0,
1340 NULL, NULL, NULL);
1341 if (isymbuf == NULL)
1342 goto error_return;
1343 }
1344
1345 amt = symtab_hdr->sh_info;
1346 amt *= sizeof (asection *);
1347 sections = (asection **) bfd_malloc (amt);
1348 if (sections == NULL && amt != 0)
1349 goto error_return;
1350
1351 isymend = isymbuf + symtab_hdr->sh_info;
1352 for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
1353 {
1354 asection *isec;
1355
1356 if (isym->st_shndx == SHN_UNDEF)
1357 isec = bfd_und_section_ptr;
1358 else if (isym->st_shndx == SHN_ABS)
1359 isec = bfd_abs_section_ptr;
1360 else if (isym->st_shndx == SHN_COMMON)
1361 isec = bfd_com_section_ptr;
1362 else
1363 isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
1364
1365 *secpp = isec;
1366 }
1367
1368 if (! mn10200_elf_relocate_section (output_bfd, link_info, input_bfd,
1369 input_section, data, internal_relocs,
1370 isymbuf, sections))
1371 goto error_return;
1372
1373 if (sections != NULL)
1374 free (sections);
1375 if (isymbuf != NULL
1376 && symtab_hdr->contents != (unsigned char *) isymbuf)
1377 free (isymbuf);
1378 if (elf_section_data (input_section)->relocs != internal_relocs)
1379 free (internal_relocs);
1380 }
1381
1382 return data;
1383
1384 error_return:
1385 if (sections != NULL)
1386 free (sections);
1387 if (isymbuf != NULL
1388 && symtab_hdr->contents != (unsigned char *) isymbuf)
1389 free (isymbuf);
1390 if (internal_relocs != NULL
1391 && elf_section_data (input_section)->relocs != internal_relocs)
1392 free (internal_relocs);
1393 return NULL;
1394 }
1395
1396 #define TARGET_LITTLE_SYM bfd_elf32_mn10200_vec
1397 #define TARGET_LITTLE_NAME "elf32-mn10200"
1398 #define ELF_ARCH bfd_arch_mn10200
1399 #define ELF_MACHINE_CODE EM_MN10200
1400 #define ELF_MACHINE_ALT1 EM_CYGNUS_MN10200
1401 #define ELF_MAXPAGESIZE 0x1000
1402
1403 #define elf_backend_rela_normal 1
1404 #define elf_info_to_howto mn10200_info_to_howto
1405 #define elf_info_to_howto_rel 0
1406 #define elf_backend_relocate_section mn10200_elf_relocate_section
1407 #define bfd_elf32_bfd_relax_section mn10200_elf_relax_section
1408 #define bfd_elf32_bfd_get_relocated_section_contents \
1409 mn10200_elf_get_relocated_section_contents
1410
1411 #define elf_symbol_leading_char '_'
1412
1413 #include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.081539 seconds and 5 git commands to generate.