?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2001-03-26 H.J. Lu <hjl@gnu.org>
[binutils.git] / bfd / elf-m10300.c
blob268deba3be4f4d18a0498180248476b57b8b5d2f
1 /* Matsushita 10300 specific support for 32-bit ELF
2 Copyright 1996, 1997, 1998, 1999, 2000, 2001
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 #include "elf/mn10300.h"
26
27 struct elf32_mn10300_link_hash_entry {
28 /* The basic elf link hash table entry. */
29 struct elf_link_hash_entry root;
30
31 /* For function symbols, the number of times this function is
32 called directly (ie by name). */
33 unsigned int direct_calls;
34
35 /* For function symbols, the size of this function's stack
36 (if <= 255 bytes). We stuff this into "call" instructions
37 to this target when it's valid and profitable to do so.
38
39 This does not include stack allocated by movm! */
40 unsigned char stack_size;
41
42 /* For function symbols, arguments (if any) for movm instruction
43 in the prologue. We stuff this value into "call" instructions
44 to the target when it's valid and profitable to do so. */
45 unsigned char movm_args;
46
47 /* For funtion symbols, the amount of stack space that would be allocated
48 by the movm instruction. This is redundant with movm_args, but we
49 add it to the hash table to avoid computing it over and over. */
50 unsigned char movm_stack_size;
51
52 /* When set, convert all "call" instructions to this target into "calls"
53 instructions. */
54 #define MN10300_CONVERT_CALL_TO_CALLS 0x1
55
56 /* Used to mark functions which have had redundant parts of their
57 prologue deleted. */
58 #define MN10300_DELETED_PROLOGUE_BYTES 0x2
59 unsigned char flags;
60 };
61
62 /* We derive a hash table from the main elf linker hash table so
63 we can store state variables and a secondary hash table without
64 resorting to global variables. */
65 struct elf32_mn10300_link_hash_table {
66 /* The main hash table. */
67 struct elf_link_hash_table root;
68
69 /* A hash table for static functions. We could derive a new hash table
70 instead of using the full elf32_mn10300_link_hash_table if we wanted
71 to save some memory. */
72 struct elf32_mn10300_link_hash_table *static_hash_table;
73
74 /* Random linker state flags. */
75 #define MN10300_HASH_ENTRIES_INITIALIZED 0x1
76 char flags;
77 };
78
79 /* For MN10300 linker hash table. */
80
81 /* Get the MN10300 ELF linker hash table from a link_info structure. */
82
83 #define elf32_mn10300_hash_table(p) \
84 ((struct elf32_mn10300_link_hash_table *) ((p)->hash))
85
86 #define elf32_mn10300_link_hash_traverse(table, func, info) \
87 (elf_link_hash_traverse \
88 (&(table)->root, \
89 (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
90 (info)))
91
92 static struct bfd_hash_entry *elf32_mn10300_link_hash_newfunc
93 PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
94 static struct bfd_link_hash_table *elf32_mn10300_link_hash_table_create
95 PARAMS ((bfd *));
96
97 static reloc_howto_type *bfd_elf32_bfd_reloc_type_lookup
98 PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
99 static void mn10300_info_to_howto
100 PARAMS ((bfd *, arelent *, Elf32_Internal_Rela *));
101 static boolean mn10300_elf_check_relocs
102 PARAMS ((bfd *, struct bfd_link_info *, asection *,
103 const Elf_Internal_Rela *));
104 static asection *mn10300_elf_gc_mark_hook
105 PARAMS ((bfd *, struct bfd_link_info *info, Elf_Internal_Rela *,
106 struct elf_link_hash_entry *, Elf_Internal_Sym *));
107 static boolean mn10300_elf_relax_delete_bytes
108 PARAMS ((bfd *, asection *, bfd_vma, int));
109 static boolean mn10300_elf_symbol_address_p
110 PARAMS ((bfd *, asection *, Elf32_External_Sym *, bfd_vma));
111 static boolean elf32_mn10300_finish_hash_table_entry
112 PARAMS ((struct bfd_hash_entry *, PTR));
113 static void compute_function_info
114 PARAMS ((bfd *, struct elf32_mn10300_link_hash_entry *,
115 bfd_vma, unsigned char *));
116
117 /* We have to use RELA instructions since md_apply_fix3 in the assembler
118 does absolutely nothing. */
119 #define USE_RELA
120
121 static reloc_howto_type elf_mn10300_howto_table[] = {
122 /* Dummy relocation. Does nothing. */
123 HOWTO (R_MN10300_NONE,
124 0,
125 2,
126 16,
127 false,
128 0,
129 complain_overflow_bitfield,
130 bfd_elf_generic_reloc,
131 "R_MN10300_NONE",
132 false,
133 0,
134 0,
135 false),
136 /* Standard 32 bit reloc. */
137 HOWTO (R_MN10300_32,
138 0,
139 2,
140 32,
141 false,
142 0,
143 complain_overflow_bitfield,
144 bfd_elf_generic_reloc,
145 "R_MN10300_32",
146 false,
147 0xffffffff,
148 0xffffffff,
149 false),
150 /* Standard 16 bit reloc. */
151 HOWTO (R_MN10300_16,
152 0,
153 1,
154 16,
155 false,
156 0,
157 complain_overflow_bitfield,
158 bfd_elf_generic_reloc,
159 "R_MN10300_16",
160 false,
161 0xffff,
162 0xffff,
163 false),
164 /* Standard 8 bit reloc. */
165 HOWTO (R_MN10300_8,
166 0,
167 0,
168 8,
169 false,
170 0,
171 complain_overflow_bitfield,
172 bfd_elf_generic_reloc,
173 "R_MN10300_8",
174 false,
175 0xff,
176 0xff,
177 false),
178 /* Standard 32bit pc-relative reloc. */
179 HOWTO (R_MN10300_PCREL32,
180 0,
181 2,
182 32,
183 true,
184 0,
185 complain_overflow_bitfield,
186 bfd_elf_generic_reloc,
187 "R_MN10300_PCREL32",
188 false,
189 0xffffffff,
190 0xffffffff,
191 true),
192 /* Standard 16bit pc-relative reloc. */
193 HOWTO (R_MN10300_PCREL16,
194 0,
195 1,
196 16,
197 true,
198 0,
199 complain_overflow_bitfield,
200 bfd_elf_generic_reloc,
201 "R_MN10300_PCREL16",
202 false,
203 0xffff,
204 0xffff,
205 true),
206 /* Standard 8 pc-relative reloc. */
207 HOWTO (R_MN10300_PCREL8,
208 0,
209 0,
210 8,
211 true,
212 0,
213 complain_overflow_bitfield,
214 bfd_elf_generic_reloc,
215 "R_MN10300_PCREL8",
216 false,
217 0xff,
218 0xff,
219 true),
220
221 /* GNU extension to record C++ vtable hierarchy */
222 HOWTO (R_MN10300_GNU_VTINHERIT, /* type */
223 0, /* rightshift */
224 0, /* size (0 = byte, 1 = short, 2 = long) */
225 0, /* bitsize */
226 false, /* pc_relative */
227 0, /* bitpos */
228 complain_overflow_dont, /* complain_on_overflow */
229 NULL, /* special_function */
230 "R_MN10300_GNU_VTINHERIT", /* name */
231 false, /* partial_inplace */
232 0, /* src_mask */
233 0, /* dst_mask */
234 false), /* pcrel_offset */
235
236 /* GNU extension to record C++ vtable member usage */
237 HOWTO (R_MN10300_GNU_VTENTRY, /* type */
238 0, /* rightshift */
239 0, /* size (0 = byte, 1 = short, 2 = long) */
240 0, /* bitsize */
241 false, /* pc_relative */
242 0, /* bitpos */
243 complain_overflow_dont, /* complain_on_overflow */
244 NULL, /* special_function */
245 "R_MN10300_GNU_VTENTRY", /* name */
246 false, /* partial_inplace */
247 0, /* src_mask */
248 0, /* dst_mask */
249 false), /* pcrel_offset */
250
251 /* Standard 24 bit reloc. */
252 HOWTO (R_MN10300_24,
253 0,
254 2,
255 24,
256 false,
257 0,
258 complain_overflow_bitfield,
259 bfd_elf_generic_reloc,
260 "R_MN10300_24",
261 false,
262 0xffffff,
263 0xffffff,
264 false),
265 };
266
267 struct mn10300_reloc_map {
268 bfd_reloc_code_real_type bfd_reloc_val;
269 unsigned char elf_reloc_val;
270 };
271
272 static const struct mn10300_reloc_map mn10300_reloc_map[] = {
273 { BFD_RELOC_NONE, R_MN10300_NONE, },
274 { BFD_RELOC_32, R_MN10300_32, },
275 { BFD_RELOC_16, R_MN10300_16, },
276 { BFD_RELOC_8, R_MN10300_8, },
277 { BFD_RELOC_32_PCREL, R_MN10300_PCREL32, },
278 { BFD_RELOC_16_PCREL, R_MN10300_PCREL16, },
279 { BFD_RELOC_8_PCREL, R_MN10300_PCREL8, },
280 { BFD_RELOC_24, R_MN10300_24, },
281 { BFD_RELOC_VTABLE_INHERIT, R_MN10300_GNU_VTINHERIT },
282 { BFD_RELOC_VTABLE_ENTRY, R_MN10300_GNU_VTENTRY },
283 };
284
285 static reloc_howto_type *
286 bfd_elf32_bfd_reloc_type_lookup (abfd, code)
287 bfd *abfd ATTRIBUTE_UNUSED;
288 bfd_reloc_code_real_type code;
289 {
290 unsigned int i;
291
292 for (i = 0;
293 i < sizeof (mn10300_reloc_map) / sizeof (struct mn10300_reloc_map);
294 i++)
295 {
296 if (mn10300_reloc_map[i].bfd_reloc_val == code)
297 return &elf_mn10300_howto_table[mn10300_reloc_map[i].elf_reloc_val];
298 }
299
300 return NULL;
301 }
302
303 /* Set the howto pointer for an MN10300 ELF reloc. */
304
305 static void
306 mn10300_info_to_howto (abfd, cache_ptr, dst)
307 bfd *abfd ATTRIBUTE_UNUSED;
308 arelent *cache_ptr;
309 Elf32_Internal_Rela *dst;
310 {
311 unsigned int r_type;
312
313 r_type = ELF32_R_TYPE (dst->r_info);
314 BFD_ASSERT (r_type < (unsigned int) R_MN10300_MAX);
315 cache_ptr->howto = &elf_mn10300_howto_table[r_type];
316 }
317
318 /* Look through the relocs for a section during the first phase.
319 Since we don't do .gots or .plts, we just need to consider the
320 virtual table relocs for gc. */
321
322 static boolean
323 mn10300_elf_check_relocs (abfd, info, sec, relocs)
324 bfd *abfd;
325 struct bfd_link_info *info;
326 asection *sec;
327 const Elf_Internal_Rela *relocs;
328 {
329 Elf_Internal_Shdr *symtab_hdr;
330 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
331 const Elf_Internal_Rela *rel;
332 const Elf_Internal_Rela *rel_end;
333
334 if (info->relocateable)
335 return true;
336
337 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
338 sym_hashes = elf_sym_hashes (abfd);
339 sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof (Elf32_External_Sym);
340 if (!elf_bad_symtab (abfd))
341 sym_hashes_end -= symtab_hdr->sh_info;
342
343 rel_end = relocs + sec->reloc_count;
344 for (rel = relocs; rel < rel_end; rel++)
345 {
346 struct elf_link_hash_entry *h;
347 unsigned long r_symndx;
348
349 r_symndx = ELF32_R_SYM (rel->r_info);
350 if (r_symndx < symtab_hdr->sh_info)
351 h = NULL;
352 else
353 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
354
355 switch (ELF32_R_TYPE (rel->r_info))
356 {
357 /* This relocation describes the C++ object vtable hierarchy.
358 Reconstruct it for later use during GC. */
359 case R_MN10300_GNU_VTINHERIT:
360 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
361 return false;
362 break;
363
364 /* This relocation describes which C++ vtable entries are actually
365 used. Record for later use during GC. */
366 case R_MN10300_GNU_VTENTRY:
367 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
368 return false;
369 break;
370 }
371 }
372
373 return true;
374 }
375
376 /* Return the section that should be marked against GC for a given
377 relocation. */
378
379 static asection *
380 mn10300_elf_gc_mark_hook (abfd, info, rel, h, sym)
381 bfd *abfd;
382 struct bfd_link_info *info ATTRIBUTE_UNUSED;
383 Elf_Internal_Rela *rel;
384 struct elf_link_hash_entry *h;
385 Elf_Internal_Sym *sym;
386 {
387 if (h != NULL)
388 {
389 switch (ELF32_R_TYPE (rel->r_info))
390 {
391 case R_MN10300_GNU_VTINHERIT:
392 case R_MN10300_GNU_VTENTRY:
393 break;
394
395 default:
396 switch (h->root.type)
397 {
398 case bfd_link_hash_defined:
399 case bfd_link_hash_defweak:
400 return h->root.u.def.section;
401
402 case bfd_link_hash_common:
403 return h->root.u.c.p->section;
404
405 default:
406 break;
407 }
408 }
409 }
410 else
411 {
412 if (!(elf_bad_symtab (abfd)
413 && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
414 && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
415 && sym->st_shndx != SHN_COMMON))
416 {
417 return bfd_section_from_elf_index (abfd, sym->st_shndx);
418 }
419 }
420
421 return NULL;
422 }
423
424 /* Perform a relocation as part of a final link. */
425 static bfd_reloc_status_type
426 mn10300_elf_final_link_relocate (howto, input_bfd, output_bfd,
427 input_section, contents, offset, value,
428 addend, info, sym_sec, is_local)
429 reloc_howto_type *howto;
430 bfd *input_bfd;
431 bfd *output_bfd ATTRIBUTE_UNUSED;
432 asection *input_section;
433 bfd_byte *contents;
434 bfd_vma offset;
435 bfd_vma value;
436 bfd_vma addend;
437 struct bfd_link_info *info ATTRIBUTE_UNUSED;
438 asection *sym_sec ATTRIBUTE_UNUSED;
439 int is_local ATTRIBUTE_UNUSED;
440 {
441 unsigned long r_type = howto->type;
442 bfd_byte *hit_data = contents + offset;
443
444 switch (r_type)
445 {
446 case R_MN10300_NONE:
447 return bfd_reloc_ok;
448
449 case R_MN10300_32:
450 value += addend;
451 bfd_put_32 (input_bfd, value, hit_data);
452 return bfd_reloc_ok;
453
454 case R_MN10300_24:
455 value += addend;
456
457 if ((long) value > 0x7fffff || (long) value < -0x800000)
458 return bfd_reloc_overflow;
459
460 bfd_put_8 (input_bfd, value & 0xff, hit_data);
461 bfd_put_8 (input_bfd, (value >> 8) & 0xff, hit_data + 1);
462 bfd_put_8 (input_bfd, (value >> 16) & 0xff, hit_data + 2);
463 return bfd_reloc_ok;
464
465 case R_MN10300_16:
466 value += addend;
467
468 if ((long) value > 0x7fff || (long) value < -0x8000)
469 return bfd_reloc_overflow;
470
471 bfd_put_16 (input_bfd, value, hit_data);
472 return bfd_reloc_ok;
473
474 case R_MN10300_8:
475 value += addend;
476
477 if ((long) value > 0x7f || (long) value < -0x80)
478 return bfd_reloc_overflow;
479
480 bfd_put_8 (input_bfd, value, hit_data);
481 return bfd_reloc_ok;
482
483 case R_MN10300_PCREL8:
484 value -= (input_section->output_section->vma
485 + input_section->output_offset);
486 value -= offset;
487 value += addend;
488
489 if ((long) value > 0xff || (long) value < -0x100)
490 return bfd_reloc_overflow;
491
492 bfd_put_8 (input_bfd, value, hit_data);
493 return bfd_reloc_ok;
494
495 case R_MN10300_PCREL16:
496 value -= (input_section->output_section->vma
497 + input_section->output_offset);
498 value -= offset;
499 value += addend;
500
501 if ((long) value > 0xffff || (long) value < -0x10000)
502 return bfd_reloc_overflow;
503
504 bfd_put_16 (input_bfd, value, hit_data);
505 return bfd_reloc_ok;
506
507 case R_MN10300_PCREL32:
508 value -= (input_section->output_section->vma
509 + input_section->output_offset);
510 value -= offset;
511 value += addend;
512
513 bfd_put_32 (input_bfd, value, hit_data);
514 return bfd_reloc_ok;
515
516 case R_MN10300_GNU_VTINHERIT:
517 case R_MN10300_GNU_VTENTRY:
518 return bfd_reloc_ok;
519
520 default:
521 return bfd_reloc_notsupported;
522 }
523 }
524 \f
525 /* Relocate an MN10300 ELF section. */
526 static boolean
527 mn10300_elf_relocate_section (output_bfd, info, input_bfd, input_section,
528 contents, relocs, local_syms, local_sections)
529 bfd *output_bfd;
530 struct bfd_link_info *info;
531 bfd *input_bfd;
532 asection *input_section;
533 bfd_byte *contents;
534 Elf_Internal_Rela *relocs;
535 Elf_Internal_Sym *local_syms;
536 asection **local_sections;
537 {
538 Elf_Internal_Shdr *symtab_hdr;
539 struct elf32_mn10300_link_hash_entry **sym_hashes;
540 Elf_Internal_Rela *rel, *relend;
541
542 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
543 sym_hashes = (struct elf32_mn10300_link_hash_entry **)
544 (elf_sym_hashes (input_bfd));
545
546 rel = relocs;
547 relend = relocs + input_section->reloc_count;
548 for (; rel < relend; rel++)
549 {
550 int r_type;
551 reloc_howto_type *howto;
552 unsigned long r_symndx;
553 Elf_Internal_Sym *sym;
554 asection *sec;
555 struct elf32_mn10300_link_hash_entry *h;
556 bfd_vma relocation;
557 bfd_reloc_status_type r;
558
559 r_symndx = ELF32_R_SYM (rel->r_info);
560 r_type = ELF32_R_TYPE (rel->r_info);
561 howto = elf_mn10300_howto_table + r_type;
562
563 /* Just skip the vtable gc relocs. */
564 if (r_type == R_MN10300_GNU_VTINHERIT
565 || r_type == R_MN10300_GNU_VTENTRY)
566 continue;
567
568 if (info->relocateable)
569 {
570 /* This is a relocateable link. We don't have to change
571 anything, unless the reloc is against a section symbol,
572 in which case we have to adjust according to where the
573 section symbol winds up in the output section. */
574 if (r_symndx < symtab_hdr->sh_info)
575 {
576 sym = local_syms + r_symndx;
577 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
578 {
579 sec = local_sections[r_symndx];
580 rel->r_addend += sec->output_offset + sym->st_value;
581 }
582 }
583
584 continue;
585 }
586
587 /* This is a final link. */
588 h = NULL;
589 sym = NULL;
590 sec = NULL;
591 if (r_symndx < symtab_hdr->sh_info)
592 {
593 sym = local_syms + r_symndx;
594 sec = local_sections[r_symndx];
595 relocation = (sec->output_section->vma
596 + sec->output_offset
597 + sym->st_value);
598 }
599 else
600 {
601 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
602 while (h->root.type == bfd_link_hash_indirect
603 || h->root.type == bfd_link_hash_warning)
604 h = (struct elf32_mn10300_link_hash_entry *) h->root.root.u.i.link;
605 if (h->root.root.type == bfd_link_hash_defined
606 || h->root.root.type == bfd_link_hash_defweak)
607 {
608 sec = h->root.root.u.def.section;
609 relocation = (h->root.root.u.def.value
610 + sec->output_section->vma
611 + sec->output_offset);
612 }
613 else if (h->root.root.type == bfd_link_hash_undefweak)
614 relocation = 0;
615 else
616 {
617 if (! ((*info->callbacks->undefined_symbol)
618 (info, h->root.root.root.string, input_bfd,
619 input_section, rel->r_offset, true)))
620 return false;
621 relocation = 0;
622 }
623 }
624
625 r = mn10300_elf_final_link_relocate (howto, input_bfd, output_bfd,
626 input_section,
627 contents, rel->r_offset,
628 relocation, rel->r_addend,
629 info, sec, h == NULL);
630
631 if (r != bfd_reloc_ok)
632 {
633 const char *name;
634 const char *msg = (const char *) 0;
635
636 if (h != NULL)
637 name = h->root.root.root.string;
638 else
639 {
640 name = (bfd_elf_string_from_elf_section
641 (input_bfd, symtab_hdr->sh_link, sym->st_name));
642 if (name == NULL || *name == '\0')
643 name = bfd_section_name (input_bfd, sec);
644 }
645
646 switch (r)
647 {
648 case bfd_reloc_overflow:
649 if (! ((*info->callbacks->reloc_overflow)
650 (info, name, howto->name, (bfd_vma) 0,
651 input_bfd, input_section, rel->r_offset)))
652 return false;
653 break;
654
655 case bfd_reloc_undefined:
656 if (! ((*info->callbacks->undefined_symbol)
657 (info, name, input_bfd, input_section,
658 rel->r_offset, true)))
659 return false;
660 break;
661
662 case bfd_reloc_outofrange:
663 msg = _("internal error: out of range error");
664 goto common_error;
665
666 case bfd_reloc_notsupported:
667 msg = _("internal error: unsupported relocation error");
668 goto common_error;
669
670 case bfd_reloc_dangerous:
671 msg = _("internal error: dangerous error");
672 goto common_error;
673
674 default:
675 msg = _("internal error: unknown error");
676 /* fall through */
677
678 common_error:
679 if (!((*info->callbacks->warning)
680 (info, msg, name, input_bfd, input_section,
681 rel->r_offset)))
682 return false;
683 break;
684 }
685 }
686 }
687
688 return true;
689 }
690
691 /* Finish initializing one hash table entry. */
692 static boolean
693 elf32_mn10300_finish_hash_table_entry (gen_entry, in_args)
694 struct bfd_hash_entry *gen_entry;
695 PTR in_args ATTRIBUTE_UNUSED;
696 {
697 struct elf32_mn10300_link_hash_entry *entry;
698 unsigned int byte_count = 0;
699
700 entry = (struct elf32_mn10300_link_hash_entry *) gen_entry;
701
702 /* If we already know we want to convert "call" to "calls" for calls
703 to this symbol, then return now. */
704 if (entry->flags == MN10300_CONVERT_CALL_TO_CALLS)
705 return true;
706
707 /* If there are no named calls to this symbol, or there's nothing we
708 can move from the function itself into the "call" instruction, then
709 note that all "call" instructions should be converted into "calls"
710 instructions and return. */
711 if (entry->direct_calls == 0
712 || (entry->stack_size == 0 && entry->movm_args == 0))
713 {
714 /* Make a note that we should convert "call" instructions to "calls"
715 instructions for calls to this symbol. */
716 entry->flags |= MN10300_CONVERT_CALL_TO_CALLS;
717 return true;
718 }
719
720 /* We may be able to move some instructions from the function itself into
721 the "call" instruction. Count how many bytes we might be able to
722 eliminate in the function itself. */
723
724 /* A movm instruction is two bytes. */
725 if (entry->movm_args)
726 byte_count += 2;
727
728 /* Count the insn to allocate stack space too. */
729 if (entry->stack_size > 0 && entry->stack_size <= 128)
730 byte_count += 3;
731 else if (entry->stack_size > 0 && entry->stack_size < 256)
732 byte_count += 4;
733
734 /* If using "call" will result in larger code, then turn all
735 the associated "call" instructions into "calls" instrutions. */
736 if (byte_count < entry->direct_calls)
737 entry->flags |= MN10300_CONVERT_CALL_TO_CALLS;
738
739 /* This routine never fails. */
740 return true;
741 }
742
743 /* This function handles relaxing for the mn10300.
744
745 There's quite a few relaxing opportunites available on the mn10300:
746
747 * calls:32 -> calls:16 2 bytes
748 * call:32 -> call:16 2 bytes
749
750 * call:32 -> calls:32 1 byte
751 * call:16 -> calls:16 1 byte
752 * These are done anytime using "calls" would result
753 in smaller code, or when necessary to preserve the
754 meaning of the program.
755
756 * call:32 varies
757 * call:16
758 * In some circumstances we can move instructions
759 from a function prologue into a "call" instruction.
760 This is only done if the resulting code is no larger
761 than the original code.
762
763 * jmp:32 -> jmp:16 2 bytes
764 * jmp:16 -> bra:8 1 byte
765
766 * If the previous instruction is a conditional branch
767 around the jump/bra, we may be able to reverse its condition
768 and change its target to the jump's target. The jump/bra
769 can then be deleted. 2 bytes
770
771 * mov abs32 -> mov abs16 1 or 2 bytes
772
773 * Most instructions which accept imm32 can relax to imm16 1 or 2 bytes
774 - Most instructions which accept imm16 can relax to imm8 1 or 2 bytes
775
776 * Most instructions which accept d32 can relax to d16 1 or 2 bytes
777 - Most instructions which accept d16 can relax to d8 1 or 2 bytes
778
779 We don't handle imm16->imm8 or d16->d8 as they're very rare
780 and somewhat more difficult to support. */
781
782 static boolean
783 mn10300_elf_relax_section (abfd, sec, link_info, again)
784 bfd *abfd;
785 asection *sec;
786 struct bfd_link_info *link_info;
787 boolean *again;
788 {
789 Elf_Internal_Shdr *symtab_hdr;
790 Elf_Internal_Rela *internal_relocs = NULL;
791 Elf_Internal_Rela *free_relocs = NULL;
792 Elf_Internal_Rela *irel, *irelend;
793 bfd_byte *contents = NULL;
794 bfd_byte *free_contents = NULL;
795 Elf32_External_Sym *extsyms = NULL;
796 Elf32_External_Sym *free_extsyms = NULL;
797 struct elf32_mn10300_link_hash_table *hash_table;
798
799 /* Assume nothing changes. */
800 *again = false;
801
802 /* We need a pointer to the mn10300 specific hash table. */
803 hash_table = elf32_mn10300_hash_table (link_info);
804
805 /* Initialize fields in each hash table entry the first time through. */
806 if ((hash_table->flags & MN10300_HASH_ENTRIES_INITIALIZED) == 0)
807 {
808 bfd *input_bfd;
809
810 /* Iterate over all the input bfds. */
811 for (input_bfd = link_info->input_bfds;
812 input_bfd != NULL;
813 input_bfd = input_bfd->link_next)
814 {
815 asection *section;
816
817 /* We're going to need all the symbols for each bfd. */
818 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
819
820 /* Get cached copy if it exists. */
821 if (symtab_hdr->contents != NULL)
822 extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
823 else
824 {
825 /* Go get them off disk. */
826 extsyms = ((Elf32_External_Sym *)
827 bfd_malloc (symtab_hdr->sh_size));
828 if (extsyms == NULL)
829 goto error_return;
830 free_extsyms = extsyms;
831 if (bfd_seek (input_bfd, symtab_hdr->sh_offset, SEEK_SET) != 0
832 || (bfd_read (extsyms, 1, symtab_hdr->sh_size, input_bfd)
833 != symtab_hdr->sh_size))
834 goto error_return;
835 }
836
837 /* Iterate over each section in this bfd. */
838 for (section = input_bfd->sections;
839 section != NULL;
840 section = section->next)
841 {
842 struct elf32_mn10300_link_hash_entry *hash;
843 Elf_Internal_Sym *sym;
844 asection *sym_sec = NULL;
845 const char *sym_name;
846 char *new_name;
847
848 /* Get cached copy of section contents if it exists. */
849 if (elf_section_data (section)->this_hdr.contents != NULL)
850 contents = elf_section_data (section)->this_hdr.contents;
851 else if (section->_raw_size != 0)
852 {
853 /* Go get them off disk. */
854 contents = (bfd_byte *) bfd_malloc (section->_raw_size);
855 if (contents == NULL)
856 goto error_return;
857 free_contents = contents;
858
859 if (!bfd_get_section_contents (input_bfd, section,
860 contents, (file_ptr) 0,
861 section->_raw_size))
862 goto error_return;
863 }
864 else
865 {
866 contents = NULL;
867 free_contents = NULL;
868 }
869
870 /* If there aren't any relocs, then there's nothing to do. */
871 if ((section->flags & SEC_RELOC) != 0
872 && section->reloc_count != 0)
873 {
874
875 /* Get a copy of the native relocations. */
876 internal_relocs = (_bfd_elf32_link_read_relocs
877 (input_bfd, section, (PTR) NULL,
878 (Elf_Internal_Rela *) NULL,
879 link_info->keep_memory));
880 if (internal_relocs == NULL)
881 goto error_return;
882 if (! link_info->keep_memory)
883 free_relocs = internal_relocs;
884
885 /* Now examine each relocation. */
886 irel = internal_relocs;
887 irelend = irel + section->reloc_count;
888 for (; irel < irelend; irel++)
889 {
890 long r_type;
891 unsigned long r_index;
892 unsigned char code;
893
894 r_type = ELF32_R_TYPE (irel->r_info);
895 r_index = ELF32_R_SYM (irel->r_info);
896
897 if (r_type < 0 || r_type >= (int) R_MN10300_MAX)
898 goto error_return;
899
900 /* We need the name and hash table entry of the target
901 symbol! */
902 hash = NULL;
903 sym = NULL;
904 sym_sec = NULL;
905
906 if (r_index < symtab_hdr->sh_info)
907 {
908 /* A local symbol. */
909 Elf_Internal_Sym isym;
910
911 bfd_elf32_swap_symbol_in (input_bfd,
912 extsyms + r_index, &isym);
913
914 if (isym.st_shndx == SHN_UNDEF)
915 sym_sec = bfd_und_section_ptr;
916 else if (isym.st_shndx > 0
917 && isym.st_shndx < SHN_LORESERVE)
918 sym_sec
919 = bfd_section_from_elf_index (input_bfd,
920 isym.st_shndx);
921 else if (isym.st_shndx == SHN_ABS)
922 sym_sec = bfd_abs_section_ptr;
923 else if (isym.st_shndx == SHN_COMMON)
924 sym_sec = bfd_com_section_ptr;
925
926 sym_name = bfd_elf_string_from_elf_section (input_bfd,
927 symtab_hdr->sh_link,
928 isym.st_name);
929
930 /* If it isn't a function, then we don't care
931 about it. */
932 if (r_index < symtab_hdr->sh_info
933 && ELF_ST_TYPE (isym.st_info) != STT_FUNC)
934 continue;
935
936 /* Tack on an ID so we can uniquely identify this
937 local symbol in the global hash table. */
938 new_name = bfd_malloc (strlen (sym_name) + 10);
939 if (new_name == 0)
940 goto error_return;
941
942 sprintf (new_name, "%s_%08x",
943 sym_name, (int) sym_sec);
944 sym_name = new_name;
945
946 hash = (struct elf32_mn10300_link_hash_entry *)
947 elf_link_hash_lookup (&hash_table->static_hash_table->root,
948 sym_name, true,
949 true, false);
950 free (new_name);
951 }
952 else
953 {
954 r_index -= symtab_hdr->sh_info;
955 hash = (struct elf32_mn10300_link_hash_entry *)
956 elf_sym_hashes (input_bfd)[r_index];
957 }
958
959 /* If this is not a "call" instruction, then we
960 should convert "call" instructions to "calls"
961 instructions. */
962 code = bfd_get_8 (input_bfd,
963 contents + irel->r_offset - 1);
964 if (code != 0xdd && code != 0xcd)
965 hash->flags |= MN10300_CONVERT_CALL_TO_CALLS;
966
967 /* If this is a jump/call, then bump the direct_calls
968 counter. Else force "call" to "calls" conversions. */
969 if (r_type == R_MN10300_PCREL32
970 || r_type == R_MN10300_PCREL16)
971 hash->direct_calls++;
972 else
973 hash->flags |= MN10300_CONVERT_CALL_TO_CALLS;
974 }
975 }
976
977 /* Now look at the actual contents to get the stack size,
978 and a list of what registers were saved in the prologue
979 (ie movm_args). */
980 if ((section->flags & SEC_CODE) != 0)
981 {
982
983 Elf32_External_Sym *esym, *esymend;
984 int idx, shndx;
985
986 shndx = _bfd_elf_section_from_bfd_section (input_bfd,
987 section);
988
989 /* Look at each function defined in this section and
990 update info for that function. */
991 esym = extsyms;
992 esymend = esym + symtab_hdr->sh_info;
993 for (; esym < esymend; esym++)
994 {
995 Elf_Internal_Sym isym;
996
997 bfd_elf32_swap_symbol_in (input_bfd, esym, &isym);
998 if (isym.st_shndx == shndx
999 && ELF_ST_TYPE (isym.st_info) == STT_FUNC)
1000 {
1001 if (isym.st_shndx == SHN_UNDEF)
1002 sym_sec = bfd_und_section_ptr;
1003 else if (isym.st_shndx > 0
1004 && isym.st_shndx < SHN_LORESERVE)
1005 sym_sec
1006 = bfd_section_from_elf_index (input_bfd,
1007 isym.st_shndx);
1008 else if (isym.st_shndx == SHN_ABS)
1009 sym_sec = bfd_abs_section_ptr;
1010 else if (isym.st_shndx == SHN_COMMON)
1011 sym_sec = bfd_com_section_ptr;
1012
1013 sym_name = bfd_elf_string_from_elf_section (input_bfd,
1014 symtab_hdr->sh_link,
1015 isym.st_name);
1016
1017 /* Tack on an ID so we can uniquely identify this
1018 local symbol in the global hash table. */
1019 new_name = bfd_malloc (strlen (sym_name) + 10);
1020 if (new_name == 0)
1021 goto error_return;
1022
1023 sprintf (new_name, "%s_%08x",
1024 sym_name, (int) sym_sec);
1025 sym_name = new_name;
1026
1027 hash = (struct elf32_mn10300_link_hash_entry *)
1028 elf_link_hash_lookup (&hash_table->static_hash_table->root,
1029 sym_name, true,
1030 true, false);
1031 free (new_name);
1032 compute_function_info (input_bfd, hash,
1033 isym.st_value, contents);
1034 }
1035 }
1036
1037 esym = extsyms + symtab_hdr->sh_info;
1038 esymend = extsyms + (symtab_hdr->sh_size
1039 / sizeof (Elf32_External_Sym));
1040 for (idx = 0; esym < esymend; esym++, idx++)
1041 {
1042 Elf_Internal_Sym isym;
1043
1044 bfd_elf32_swap_symbol_in (input_bfd, esym, &isym);
1045 hash = (struct elf32_mn10300_link_hash_entry *)
1046 elf_sym_hashes (input_bfd)[idx];
1047 if (isym.st_shndx == shndx
1048 && ELF_ST_TYPE (isym.st_info) == STT_FUNC
1049 && (hash)->root.root.u.def.section == section
1050 && ((hash)->root.root.type == bfd_link_hash_defined
1051 || (hash)->root.root.type == bfd_link_hash_defweak))
1052 compute_function_info (input_bfd, hash,
1053 (hash)->root.root.u.def.value,
1054 contents);
1055 }
1056 }
1057
1058 /* Cache or free any memory we allocated for the relocs. */
1059 if (free_relocs != NULL)
1060 {
1061 free (free_relocs);
1062 free_relocs = NULL;
1063 }
1064
1065 /* Cache or free any memory we allocated for the contents. */
1066 if (free_contents != NULL)
1067 {
1068 if (! link_info->keep_memory)
1069 free (free_contents);
1070 else
1071 {
1072 /* Cache the section contents for elf_link_input_bfd. */
1073 elf_section_data (section)->this_hdr.contents = contents;
1074 }
1075 free_contents = NULL;
1076 }
1077 }
1078
1079 /* Cache or free any memory we allocated for the symbols. */
1080 if (free_extsyms != NULL)
1081 {
1082 if (! link_info->keep_memory)
1083 free (free_extsyms);
1084 else
1085 {
1086 /* Cache the symbols for elf_link_input_bfd. */
1087 symtab_hdr->contents = extsyms;
1088 }
1089 free_extsyms = NULL;
1090 }
1091 }
1092
1093 /* Now iterate on each symbol in the hash table and perform
1094 the final initialization steps on each. */
1095 elf32_mn10300_link_hash_traverse (hash_table,
1096 elf32_mn10300_finish_hash_table_entry,
1097 NULL);
1098 elf32_mn10300_link_hash_traverse (hash_table->static_hash_table,
1099 elf32_mn10300_finish_hash_table_entry,
1100 NULL);
1101
1102 /* All entries in the hash table are fully initialized. */
1103 hash_table->flags |= MN10300_HASH_ENTRIES_INITIALIZED;
1104
1105 /* Now that everything has been initialized, go through each
1106 code section and delete any prologue insns which will be
1107 redundant because their operations will be performed by
1108 a "call" instruction. */
1109 for (input_bfd = link_info->input_bfds;
1110 input_bfd != NULL;
1111 input_bfd = input_bfd->link_next)
1112 {
1113 asection *section;
1114
1115 /* We're going to need all the symbols for each bfd. */
1116 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1117
1118 /* Get cached copy if it exists. */
1119 if (symtab_hdr->contents != NULL)
1120 extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
1121 else
1122 {
1123 /* Go get them off disk. */
1124 extsyms = ((Elf32_External_Sym *)
1125 bfd_malloc (symtab_hdr->sh_size));
1126 if (extsyms == NULL)
1127 goto error_return;
1128 free_extsyms = extsyms;
1129 if (bfd_seek (input_bfd, symtab_hdr->sh_offset, SEEK_SET) != 0
1130 || (bfd_read (extsyms, 1, symtab_hdr->sh_size, input_bfd)
1131 != symtab_hdr->sh_size))
1132 goto error_return;
1133 }
1134
1135 /* Walk over each section in this bfd. */
1136 for (section = input_bfd->sections;
1137 section != NULL;
1138 section = section->next)
1139 {
1140 int shndx;
1141 Elf32_External_Sym *esym, *esymend;
1142 int idx;
1143
1144 /* Skip non-code sections and empty sections. */
1145 if ((section->flags & SEC_CODE) == 0 || section->_raw_size == 0)
1146 continue;
1147
1148 if (section->reloc_count != 0)
1149 {
1150 /* Get a copy of the native relocations. */
1151 internal_relocs = (_bfd_elf32_link_read_relocs
1152 (input_bfd, section, (PTR) NULL,
1153 (Elf_Internal_Rela *) NULL,
1154 link_info->keep_memory));
1155 if (internal_relocs == NULL)
1156 goto error_return;
1157 if (! link_info->keep_memory)
1158 free_relocs = internal_relocs;
1159 }
1160
1161 /* Get cached copy of section contents if it exists. */
1162 if (elf_section_data (section)->this_hdr.contents != NULL)
1163 contents = elf_section_data (section)->this_hdr.contents;
1164 else
1165 {
1166 /* Go get them off disk. */
1167 contents = (bfd_byte *) bfd_malloc (section->_raw_size);
1168 if (contents == NULL)
1169 goto error_return;
1170 free_contents = contents;
1171
1172 if (!bfd_get_section_contents (input_bfd, section,
1173 contents, (file_ptr) 0,
1174 section->_raw_size))
1175 goto error_return;
1176 }
1177
1178 shndx = _bfd_elf_section_from_bfd_section (input_bfd, section);
1179
1180 /* Now look for any function in this section which needs
1181 insns deleted from its prologue. */
1182 esym = extsyms;
1183 esymend = esym + symtab_hdr->sh_info;
1184 for (; esym < esymend; esym++)
1185 {
1186 Elf_Internal_Sym isym;
1187 struct elf32_mn10300_link_hash_entry *sym_hash;
1188 asection *sym_sec = NULL;
1189 const char *sym_name;
1190 char *new_name;
1191
1192 bfd_elf32_swap_symbol_in (input_bfd, esym, &isym);
1193
1194 if (isym.st_shndx != shndx)
1195 continue;
1196
1197 if (isym.st_shndx == SHN_UNDEF)
1198 sym_sec = bfd_und_section_ptr;
1199 else if (isym.st_shndx > 0 && isym.st_shndx < SHN_LORESERVE)
1200 sym_sec
1201 = bfd_section_from_elf_index (input_bfd, isym.st_shndx);
1202 else if (isym.st_shndx == SHN_ABS)
1203 sym_sec = bfd_abs_section_ptr;
1204 else if (isym.st_shndx == SHN_COMMON)
1205 sym_sec = bfd_com_section_ptr;
1206 else
1207 abort ();
1208
1209 sym_name = bfd_elf_string_from_elf_section (input_bfd,
1210 symtab_hdr->sh_link,
1211 isym.st_name);
1212
1213 /* Tack on an ID so we can uniquely identify this
1214 local symbol in the global hash table. */
1215 new_name = bfd_malloc (strlen (sym_name) + 10);
1216 if (new_name == 0)
1217 goto error_return;
1218 sprintf (new_name, "%s_%08x", sym_name, (int) sym_sec);
1219 sym_name = new_name;
1220
1221 sym_hash = (struct elf32_mn10300_link_hash_entry *)
1222 elf_link_hash_lookup (&hash_table->static_hash_table->root,
1223 sym_name, false,
1224 false, false);
1225
1226 free (new_name);
1227 if (sym_hash == NULL)
1228 continue;
1229
1230 if (! ((sym_hash)->flags & MN10300_CONVERT_CALL_TO_CALLS)
1231 && ! ((sym_hash)->flags & MN10300_DELETED_PROLOGUE_BYTES))
1232 {
1233 int bytes = 0;
1234
1235 /* Note that we've changed things. */
1236 elf_section_data (section)->relocs = internal_relocs;
1237 free_relocs = NULL;
1238
1239 elf_section_data (section)->this_hdr.contents = contents;
1240 free_contents = NULL;
1241
1242 symtab_hdr->contents = (bfd_byte *) extsyms;
1243 free_extsyms = NULL;
1244
1245 /* Count how many bytes we're going to delete. */
1246 if (sym_hash->movm_args)
1247 bytes += 2;
1248
1249 if (sym_hash->stack_size && sym_hash->stack_size <= 128)
1250 bytes += 3;
1251 else if (sym_hash->stack_size
1252 && sym_hash->stack_size < 256)
1253 bytes += 4;
1254
1255 /* Note that we've deleted prologue bytes for this
1256 function. */
1257 sym_hash->flags |= MN10300_DELETED_PROLOGUE_BYTES;
1258
1259 /* Actually delete the bytes. */
1260 if (!mn10300_elf_relax_delete_bytes (input_bfd,
1261 section,
1262 isym.st_value,
1263 bytes))
1264 goto error_return;
1265
1266 /* Something changed. Not strictly necessary, but
1267 may lead to more relaxing opportunities. */
1268 *again = true;
1269 }
1270 }
1271
1272 /* Look for any global functions in this section which
1273 need insns deleted from their prologues. */
1274 esym = extsyms + symtab_hdr->sh_info;
1275 esymend = extsyms + (symtab_hdr->sh_size
1276 / sizeof (Elf32_External_Sym));
1277 for (idx = 0; esym < esymend; esym++, idx++)
1278 {
1279 Elf_Internal_Sym isym;
1280 struct elf32_mn10300_link_hash_entry *sym_hash;
1281
1282 bfd_elf32_swap_symbol_in (input_bfd, esym, &isym);
1283 sym_hash = (struct elf32_mn10300_link_hash_entry *)
1284 (elf_sym_hashes (input_bfd)[idx]);
1285 if (isym.st_shndx == shndx
1286 && (sym_hash)->root.root.u.def.section == section
1287 && ! ((sym_hash)->flags & MN10300_CONVERT_CALL_TO_CALLS)
1288 && ! ((sym_hash)->flags & MN10300_DELETED_PROLOGUE_BYTES))
1289 {
1290 int bytes = 0;
1291
1292 /* Note that we've changed things. */
1293 elf_section_data (section)->relocs = internal_relocs;
1294 free_relocs = NULL;
1295
1296 elf_section_data (section)->this_hdr.contents = contents;
1297 free_contents = NULL;
1298
1299 symtab_hdr->contents = (bfd_byte *) extsyms;
1300 free_extsyms = NULL;
1301
1302 /* Count how many bytes we're going to delete. */
1303 if (sym_hash->movm_args)
1304 bytes += 2;
1305
1306 if (sym_hash->stack_size && sym_hash->stack_size <= 128)
1307 bytes += 3;
1308 else if (sym_hash->stack_size
1309 && sym_hash->stack_size < 256)
1310 bytes += 4;
1311
1312 /* Note that we've deleted prologue bytes for this
1313 function. */
1314 sym_hash->flags |= MN10300_DELETED_PROLOGUE_BYTES;
1315
1316 /* Actually delete the bytes. */
1317 if (!mn10300_elf_relax_delete_bytes (input_bfd,
1318 section,
1319 (sym_hash)->root.root.u.def.value,
1320 bytes))
1321 goto error_return;
1322
1323 /* Something changed. Not strictly necessary, but
1324 may lead to more relaxing opportunities. */
1325 *again = true;
1326 }
1327 }
1328
1329 /* Cache or free any memory we allocated for the relocs. */
1330 if (free_relocs != NULL)
1331 {
1332 free (free_relocs);
1333 free_relocs = NULL;
1334 }
1335
1336 /* Cache or free any memory we allocated for the contents. */
1337 if (free_contents != NULL)
1338 {
1339 if (! link_info->keep_memory)
1340 free (free_contents);
1341 else
1342 {
1343 /* Cache the section contents for elf_link_input_bfd. */
1344 elf_section_data (section)->this_hdr.contents = contents;
1345 }
1346 free_contents = NULL;
1347 }
1348 }
1349
1350 /* Cache or free any memory we allocated for the symbols. */
1351 if (free_extsyms != NULL)
1352 {
1353 if (! link_info->keep_memory)
1354 free (free_extsyms);
1355 else
1356 {
1357 /* Cache the symbols for elf_link_input_bfd. */
1358 symtab_hdr->contents = extsyms;
1359 }
1360 free_extsyms = NULL;
1361 }
1362 }
1363 }
1364
1365 /* (Re)initialize for the basic instruction shortening/relaxing pass. */
1366 contents = NULL;
1367 extsyms = NULL;
1368 internal_relocs = NULL;
1369 free_relocs = NULL;
1370 free_contents = NULL;
1371 free_extsyms = NULL;
1372
1373 /* We don't have to do anything for a relocateable link, if
1374 this section does not have relocs, or if this is not a
1375 code section. */
1376 if (link_info->relocateable
1377 || (sec->flags & SEC_RELOC) == 0
1378 || sec->reloc_count == 0
1379 || (sec->flags & SEC_CODE) == 0)
1380 return true;
1381
1382 /* If this is the first time we have been called for this section,
1383 initialize the cooked size. */
1384 if (sec->_cooked_size == 0)
1385 sec->_cooked_size = sec->_raw_size;
1386
1387 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1388
1389 /* Get a copy of the native relocations. */
1390 internal_relocs = (_bfd_elf32_link_read_relocs
1391 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
1392 link_info->keep_memory));
1393 if (internal_relocs == NULL)
1394 goto error_return;
1395 if (! link_info->keep_memory)
1396 free_relocs = internal_relocs;
1397
1398 /* Walk through them looking for relaxing opportunities. */
1399 irelend = internal_relocs + sec->reloc_count;
1400 for (irel = internal_relocs; irel < irelend; irel++)
1401 {
1402 bfd_vma symval;
1403 struct elf32_mn10300_link_hash_entry *h = NULL;
1404
1405 /* If this isn't something that can be relaxed, then ignore
1406 this reloc. */
1407 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_NONE
1408 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_8
1409 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_MAX)
1410 continue;
1411
1412 /* Get the section contents if we haven't done so already. */
1413 if (contents == NULL)
1414 {
1415 /* Get cached copy if it exists. */
1416 if (elf_section_data (sec)->this_hdr.contents != NULL)
1417 contents = elf_section_data (sec)->this_hdr.contents;
1418 else
1419 {
1420 /* Go get them off disk. */
1421 contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
1422 if (contents == NULL)
1423 goto error_return;
1424 free_contents = contents;
1425
1426 if (! bfd_get_section_contents (abfd, sec, contents,
1427 (file_ptr) 0, sec->_raw_size))
1428 goto error_return;
1429 }
1430 }
1431
1432 /* Read this BFD's symbols if we haven't done so already. */
1433 if (extsyms == NULL)
1434 {
1435 /* Get cached copy if it exists. */
1436 if (symtab_hdr->contents != NULL)
1437 extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
1438 else
1439 {
1440 /* Go get them off disk. */
1441 extsyms = ((Elf32_External_Sym *)
1442 bfd_malloc (symtab_hdr->sh_size));
1443 if (extsyms == NULL)
1444 goto error_return;
1445 free_extsyms = extsyms;
1446 if (bfd_seek (abfd, symtab_hdr->sh_offset, SEEK_SET) != 0
1447 || (bfd_read (extsyms, 1, symtab_hdr->sh_size, abfd)
1448 != symtab_hdr->sh_size))
1449 goto error_return;
1450 }
1451 }
1452
1453 /* Get the value of the symbol referred to by the reloc. */
1454 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1455 {
1456 Elf_Internal_Sym isym;
1457 asection *sym_sec = NULL;
1458 const char *sym_name;
1459 char *new_name;
1460
1461 /* A local symbol. */
1462 bfd_elf32_swap_symbol_in (abfd,
1463 extsyms + ELF32_R_SYM (irel->r_info),
1464 &isym);
1465
1466 if (isym.st_shndx == SHN_UNDEF)
1467 sym_sec = bfd_und_section_ptr;
1468 else if (isym.st_shndx > 0 && isym.st_shndx < SHN_LORESERVE)
1469 sym_sec = bfd_section_from_elf_index (abfd, isym.st_shndx);
1470 else if (isym.st_shndx == SHN_ABS)
1471 sym_sec = bfd_abs_section_ptr;
1472 else if (isym.st_shndx == SHN_COMMON)
1473 sym_sec = bfd_com_section_ptr;
1474 else
1475 abort ();
1476
1477 symval = (isym.st_value
1478 + sym_sec->output_section->vma
1479 + sym_sec->output_offset);
1480 sym_name = bfd_elf_string_from_elf_section (abfd,
1481 symtab_hdr->sh_link,
1482 isym.st_name);
1483
1484 /* Tack on an ID so we can uniquely identify this
1485 local symbol in the global hash table. */
1486 new_name = bfd_malloc (strlen (sym_name) + 10);
1487 if (new_name == 0)
1488 goto error_return;
1489 sprintf (new_name, "%s_%08x", sym_name, (int) sym_sec);
1490 sym_name = new_name;
1491
1492 h = (struct elf32_mn10300_link_hash_entry *)
1493 elf_link_hash_lookup (&hash_table->static_hash_table->root,
1494 sym_name, false, false, false);
1495 free (new_name);
1496 }
1497 else
1498 {
1499 unsigned long indx;
1500
1501 /* An external symbol. */
1502 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
1503 h = (struct elf32_mn10300_link_hash_entry *)
1504 (elf_sym_hashes (abfd)[indx]);
1505 BFD_ASSERT (h != NULL);
1506 if (h->root.root.type != bfd_link_hash_defined
1507 && h->root.root.type != bfd_link_hash_defweak)
1508 {
1509 /* This appears to be a reference to an undefined
1510 symbol. Just ignore it--it will be caught by the
1511 regular reloc processing. */
1512 continue;
1513 }
1514
1515 symval = (h->root.root.u.def.value
1516 + h->root.root.u.def.section->output_section->vma
1517 + h->root.root.u.def.section->output_offset);
1518 }
1519
1520 /* For simplicity of coding, we are going to modify the section
1521 contents, the section relocs, and the BFD symbol table. We
1522 must tell the rest of the code not to free up this
1523 information. It would be possible to instead create a table
1524 of changes which have to be made, as is done in coff-mips.c;
1525 that would be more work, but would require less memory when
1526 the linker is run. */
1527
1528 /* Try to turn a 32bit pc-relative branch/call into a 16bit pc-relative
1529 branch/call, also deal with "call" -> "calls" conversions and
1530 insertion of prologue data into "call" instructions. */
1531 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL32)
1532 {
1533 bfd_vma value = symval;
1534
1535 /* If we've got a "call" instruction that needs to be turned
1536 into a "calls" instruction, do so now. It saves a byte. */
1537 if (h && (h->flags & MN10300_CONVERT_CALL_TO_CALLS))
1538 {
1539 unsigned char code;
1540
1541 /* Get the opcode. */
1542 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1543
1544 /* Make sure we're working with a "call" instruction! */
1545 if (code == 0xdd)
1546 {
1547 /* Note that we've changed the relocs, section contents,
1548 etc. */
1549 elf_section_data (sec)->relocs = internal_relocs;
1550 free_relocs = NULL;
1551
1552 elf_section_data (sec)->this_hdr.contents = contents;
1553 free_contents = NULL;
1554
1555 symtab_hdr->contents = (bfd_byte *) extsyms;
1556 free_extsyms = NULL;
1557
1558 /* Fix the opcode. */
1559 bfd_put_8 (abfd, 0xfc, contents + irel->r_offset - 1);
1560 bfd_put_8 (abfd, 0xff, contents + irel->r_offset);
1561
1562 /* Fix irel->r_offset and irel->r_addend. */
1563 irel->r_offset += 1;
1564 irel->r_addend += 1;
1565
1566 /* Delete one byte of data. */
1567 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
1568 irel->r_offset + 3, 1))
1569 goto error_return;
1570
1571 /* That will change things, so, we should relax again.
1572 Note that this is not required, and it may be slow. */
1573 *again = true;
1574 }
1575 }
1576 else if (h)
1577 {
1578 /* We've got a "call" instruction which needs some data
1579 from target function filled in. */
1580 unsigned char code;
1581
1582 /* Get the opcode. */
1583 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1584
1585 /* Insert data from the target function into the "call"
1586 instruction if needed. */
1587 if (code == 0xdd)
1588 {
1589 bfd_put_8 (abfd, h->movm_args, contents + irel->r_offset + 4);
1590 bfd_put_8 (abfd, h->stack_size + h->movm_stack_size,
1591 contents + irel->r_offset + 5);
1592 }
1593 }
1594
1595 /* Deal with pc-relative gunk. */
1596 value -= (sec->output_section->vma + sec->output_offset);
1597 value -= irel->r_offset;
1598 value += irel->r_addend;
1599
1600 /* See if the value will fit in 16 bits, note the high value is
1601 0x7fff + 2 as the target will be two bytes closer if we are
1602 able to relax. */
1603 if ((long) value < 0x8001 && (long) value > -0x8000)
1604 {
1605 unsigned char code;
1606
1607 /* Get the opcode. */
1608 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1609
1610 if (code != 0xdc && code != 0xdd && code != 0xff)
1611 continue;
1612
1613 /* Note that we've changed the relocs, section contents, etc. */
1614 elf_section_data (sec)->relocs = internal_relocs;
1615 free_relocs = NULL;
1616
1617 elf_section_data (sec)->this_hdr.contents = contents;
1618 free_contents = NULL;
1619
1620 symtab_hdr->contents = (bfd_byte *) extsyms;
1621 free_extsyms = NULL;
1622
1623 /* Fix the opcode. */
1624 if (code == 0xdc)
1625 bfd_put_8 (abfd, 0xcc, contents + irel->r_offset - 1);
1626 else if (code == 0xdd)
1627 bfd_put_8 (abfd, 0xcd, contents + irel->r_offset - 1);
1628 else if (code == 0xff)
1629 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
1630
1631 /* Fix the relocation's type. */
1632 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1633 R_MN10300_PCREL16);
1634
1635 /* Delete two bytes of data. */
1636 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
1637 irel->r_offset + 1, 2))
1638 goto error_return;
1639
1640 /* That will change things, so, we should relax again.
1641 Note that this is not required, and it may be slow. */
1642 *again = true;
1643 }
1644 }
1645
1646 /* Try to turn a 16bit pc-relative branch into a 8bit pc-relative
1647 branch. */
1648 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL16)
1649 {
1650 bfd_vma value = symval;
1651
1652 /* If we've got a "call" instruction that needs to be turned
1653 into a "calls" instruction, do so now. It saves a byte. */
1654 if (h && (h->flags & MN10300_CONVERT_CALL_TO_CALLS))
1655 {
1656 unsigned char code;
1657
1658 /* Get the opcode. */
1659 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1660
1661 /* Make sure we're working with a "call" instruction! */
1662 if (code == 0xcd)
1663 {
1664 /* Note that we've changed the relocs, section contents,
1665 etc. */
1666 elf_section_data (sec)->relocs = internal_relocs;
1667 free_relocs = NULL;
1668
1669 elf_section_data (sec)->this_hdr.contents = contents;
1670 free_contents = NULL;
1671
1672 symtab_hdr->contents = (bfd_byte *) extsyms;
1673 free_extsyms = NULL;
1674
1675 /* Fix the opcode. */
1676 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 1);
1677 bfd_put_8 (abfd, 0xff, contents + irel->r_offset);
1678
1679 /* Fix irel->r_offset and irel->r_addend. */
1680 irel->r_offset += 1;
1681 irel->r_addend += 1;
1682
1683 /* Delete one byte of data. */
1684 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
1685 irel->r_offset + 1, 1))
1686 goto error_return;
1687
1688 /* That will change things, so, we should relax again.
1689 Note that this is not required, and it may be slow. */
1690 *again = true;
1691 }
1692 }
1693 else if (h)
1694 {
1695 unsigned char code;
1696
1697 /* Get the opcode. */
1698 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1699
1700 /* Insert data from the target function into the "call"
1701 instruction if needed. */
1702 if (code == 0xcd)
1703 {
1704 bfd_put_8 (abfd, h->movm_args, contents + irel->r_offset + 2);
1705 bfd_put_8 (abfd, h->stack_size + h->movm_stack_size,
1706 contents + irel->r_offset + 3);
1707 }
1708 }
1709
1710 /* Deal with pc-relative gunk. */
1711 value -= (sec->output_section->vma + sec->output_offset);
1712 value -= irel->r_offset;
1713 value += irel->r_addend;
1714
1715 /* See if the value will fit in 8 bits, note the high value is
1716 0x7f + 1 as the target will be one bytes closer if we are
1717 able to relax. */
1718 if ((long) value < 0x80 && (long) value > -0x80)
1719 {
1720 unsigned char code;
1721
1722 /* Get the opcode. */
1723 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1724
1725 if (code != 0xcc)
1726 continue;
1727
1728 /* Note that we've changed the relocs, section contents, etc. */
1729 elf_section_data (sec)->relocs = internal_relocs;
1730 free_relocs = NULL;
1731
1732 elf_section_data (sec)->this_hdr.contents = contents;
1733 free_contents = NULL;
1734
1735 symtab_hdr->contents = (bfd_byte *) extsyms;
1736 free_extsyms = NULL;
1737
1738 /* Fix the opcode. */
1739 bfd_put_8 (abfd, 0xca, contents + irel->r_offset - 1);
1740
1741 /* Fix the relocation's type. */
1742 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1743 R_MN10300_PCREL8);
1744
1745 /* Delete one byte of data. */
1746 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
1747 irel->r_offset + 1, 1))
1748 goto error_return;
1749
1750 /* That will change things, so, we should relax again.
1751 Note that this is not required, and it may be slow. */
1752 *again = true;
1753 }
1754 }
1755
1756 /* Try to eliminate an unconditional 8 bit pc-relative branch
1757 which immediately follows a conditional 8 bit pc-relative
1758 branch around the unconditional branch.
1759
1760 original: new:
1761 bCC lab1 bCC' lab2
1762 bra lab2
1763 lab1: lab1:
1764
1765 This happens when the bCC can't reach lab2 at assembly time,
1766 but due to other relaxations it can reach at link time. */
1767 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL8)
1768 {
1769 Elf_Internal_Rela *nrel;
1770 bfd_vma value = symval;
1771 unsigned char code;
1772
1773 /* Deal with pc-relative gunk. */
1774 value -= (sec->output_section->vma + sec->output_offset);
1775 value -= irel->r_offset;
1776 value += irel->r_addend;
1777
1778 /* Do nothing if this reloc is the last byte in the section. */
1779 if (irel->r_offset == sec->_cooked_size)
1780 continue;
1781
1782 /* See if the next instruction is an unconditional pc-relative
1783 branch, more often than not this test will fail, so we
1784 test it first to speed things up. */
1785 code = bfd_get_8 (abfd, contents + irel->r_offset + 1);
1786 if (code != 0xca)
1787 continue;
1788
1789 /* Also make sure the next relocation applies to the next
1790 instruction and that it's a pc-relative 8 bit branch. */
1791 nrel = irel + 1;
1792 if (nrel == irelend
1793 || irel->r_offset + 2 != nrel->r_offset
1794 || ELF32_R_TYPE (nrel->r_info) != (int) R_MN10300_PCREL8)
1795 continue;
1796
1797 /* Make sure our destination immediately follows the
1798 unconditional branch. */
1799 if (symval != (sec->output_section->vma + sec->output_offset
1800 + irel->r_offset + 3))
1801 continue;
1802
1803 /* Now make sure we are a conditional branch. This may not
1804 be necessary, but why take the chance.
1805
1806 Note these checks assume that R_MN10300_PCREL8 relocs
1807 only occur on bCC and bCCx insns. If they occured
1808 elsewhere, we'd need to know the start of this insn
1809 for this check to be accurate. */
1810 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1811 if (code != 0xc0 && code != 0xc1 && code != 0xc2
1812 && code != 0xc3 && code != 0xc4 && code != 0xc5
1813 && code != 0xc6 && code != 0xc7 && code != 0xc8
1814 && code != 0xc9 && code != 0xe8 && code != 0xe9
1815 && code != 0xea && code != 0xeb)
1816 continue;
1817
1818 /* We also have to be sure there is no symbol/label
1819 at the unconditional branch. */
1820 if (mn10300_elf_symbol_address_p (abfd, sec, extsyms,
1821 irel->r_offset + 1))
1822 continue;
1823
1824 /* Note that we've changed the relocs, section contents, etc. */
1825 elf_section_data (sec)->relocs = internal_relocs;
1826 free_relocs = NULL;
1827
1828 elf_section_data (sec)->this_hdr.contents = contents;
1829 free_contents = NULL;
1830
1831 symtab_hdr->contents = (bfd_byte *) extsyms;
1832 free_extsyms = NULL;
1833
1834 /* Reverse the condition of the first branch. */
1835 switch (code)
1836 {
1837 case 0xc8:
1838 code = 0xc9;
1839 break;
1840 case 0xc9:
1841 code = 0xc8;
1842 break;
1843 case 0xc0:
1844 code = 0xc2;
1845 break;
1846 case 0xc2:
1847 code = 0xc0;
1848 break;
1849 case 0xc3:
1850 code = 0xc1;
1851 break;
1852 case 0xc1:
1853 code = 0xc3;
1854 break;
1855 case 0xc4:
1856 code = 0xc6;
1857 break;
1858 case 0xc6:
1859 code = 0xc4;
1860 break;
1861 case 0xc7:
1862 code = 0xc5;
1863 break;
1864 case 0xc5:
1865 code = 0xc7;
1866 break;
1867 case 0xe8:
1868 code = 0xe9;
1869 break;
1870 case 0x9d:
1871 code = 0xe8;
1872 break;
1873 case 0xea:
1874 code = 0xeb;
1875 break;
1876 case 0xeb:
1877 code = 0xea;
1878 break;
1879 }
1880 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
1881
1882 /* Set the reloc type and symbol for the first branch
1883 from the second branch. */
1884 irel->r_info = nrel->r_info;
1885
1886 /* Make the reloc for the second branch a null reloc. */
1887 nrel->r_info = ELF32_R_INFO (ELF32_R_SYM (nrel->r_info),
1888 R_MN10300_NONE);
1889
1890 /* Delete two bytes of data. */
1891 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
1892 irel->r_offset + 1, 2))
1893 goto error_return;
1894
1895 /* That will change things, so, we should relax again.
1896 Note that this is not required, and it may be slow. */
1897 *again = true;
1898 }
1899
1900 /* Try to turn a 24 immediate, displacement or absolute address
1901 into a 8 immediate, displacement or absolute address. */
1902 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_24)
1903 {
1904 bfd_vma value = symval;
1905 value += irel->r_addend;
1906
1907 /* See if the value will fit in 8 bits. */
1908 if ((long) value < 0x7f && (long) value > -0x80)
1909 {
1910 unsigned char code;
1911
1912 /* AM33 insns which have 24 operands are 6 bytes long and
1913 will have 0xfd as the first byte. */
1914
1915 /* Get the first opcode. */
1916 code = bfd_get_8 (abfd, contents + irel->r_offset - 3);
1917
1918 if (code == 0xfd)
1919 {
1920 /* Get the second opcode. */
1921 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
1922
1923 /* We can not relax 0x6b, 0x7b, 0x8b, 0x9b as no 24bit
1924 equivalent instructions exists. */
1925 if (code != 0x6b && code != 0x7b
1926 && code != 0x8b && code != 0x9b
1927 && ((code & 0x0f) == 0x09 || (code & 0x0f) == 0x08
1928 || (code & 0x0f) == 0x0a || (code & 0x0f) == 0x0b
1929 || (code & 0x0f) == 0x0e))
1930 {
1931 /* Not safe if the high bit is on as relaxing may
1932 move the value out of high mem and thus not fit
1933 in a signed 8bit value. This is currently over
1934 conservative. */
1935 if ((value & 0x80) == 0)
1936 {
1937 /* Note that we've changed the relocation contents,
1938 etc. */
1939 elf_section_data (sec)->relocs = internal_relocs;
1940 free_relocs = NULL;
1941
1942 elf_section_data (sec)->this_hdr.contents = contents;
1943 free_contents = NULL;
1944
1945 symtab_hdr->contents = (bfd_byte *) extsyms;
1946 free_extsyms = NULL;
1947
1948 /* Fix the opcode. */
1949 bfd_put_8 (abfd, 0xfb, contents + irel->r_offset - 3);
1950 bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
1951
1952 /* Fix the relocation's type. */
1953 irel->r_info =
1954 ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1955 R_MN10300_8);
1956
1957 /* Delete two bytes of data. */
1958 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
1959 irel->r_offset + 1, 2))
1960 goto error_return;
1961
1962 /* That will change things, so, we should relax
1963 again. Note that this is not required, and it
1964 may be slow. */
1965 *again = true;
1966 break;
1967 }
1968 }
1969 }
1970 }
1971 }
1972
1973 /* Try to turn a 32bit immediate, displacement or absolute address
1974 into a 16bit immediate, displacement or absolute address. */
1975 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_32)
1976 {
1977 bfd_vma value = symval;
1978 value += irel->r_addend;
1979
1980 /* See if the value will fit in 24 bits.
1981 We allow any 16bit match here. We prune those we can't
1982 handle below. */
1983 if ((long) value < 0x7fffff && (long) value > -0x800000)
1984 {
1985 unsigned char code;
1986
1987 /* AM33 insns which have 32bit operands are 7 bytes long and
1988 will have 0xfe as the first byte. */
1989
1990 /* Get the first opcode. */
1991 code = bfd_get_8 (abfd, contents + irel->r_offset - 3);
1992
1993 if (code == 0xfe)
1994 {
1995 /* Get the second opcode. */
1996 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
1997
1998 /* All the am33 32 -> 24 relaxing possibilities. */
1999 /* We can not relax 0x6b, 0x7b, 0x8b, 0x9b as no 24bit
2000 equivalent instructions exists. */
2001 if (code != 0x6b && code != 0x7b
2002 && code != 0x8b && code != 0x9b
2003 && ((code & 0x0f) == 0x09 || (code & 0x0f) == 0x08
2004 || (code & 0x0f) == 0x0a || (code & 0x0f) == 0x0b
2005 || (code & 0x0f) == 0x0e))
2006 {
2007 /* Not safe if the high bit is on as relaxing may
2008 move the value out of high mem and thus not fit
2009 in a signed 16bit value. This is currently over
2010 conservative. */
2011 if ((value & 0x8000) == 0)
2012 {
2013 /* Note that we've changed the relocation contents,
2014 etc. */
2015 elf_section_data (sec)->relocs = internal_relocs;
2016 free_relocs = NULL;
2017
2018 elf_section_data (sec)->this_hdr.contents = contents;
2019 free_contents = NULL;
2020
2021 symtab_hdr->contents = (bfd_byte *) extsyms;
2022 free_extsyms = NULL;
2023
2024 /* Fix the opcode. */
2025 bfd_put_8 (abfd, 0xfd, contents + irel->r_offset - 3);
2026 bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
2027
2028 /* Fix the relocation's type. */
2029 irel->r_info =
2030 ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2031 R_MN10300_24);
2032
2033 /* Delete one byte of data. */
2034 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2035 irel->r_offset + 3, 1))
2036 goto error_return;
2037
2038 /* That will change things, so, we should relax
2039 again. Note that this is not required, and it
2040 may be slow. */
2041 *again = true;
2042 break;
2043 }
2044 }
2045 }
2046 }
2047
2048 /* See if the value will fit in 16 bits.
2049 We allow any 16bit match here. We prune those we can't
2050 handle below. */
2051 if ((long) value < 0x7fff && (long) value > -0x8000)
2052 {
2053 unsigned char code;
2054
2055 /* Most insns which have 32bit operands are 6 bytes long;
2056 exceptions are pcrel insns and bit insns.
2057
2058 We handle pcrel insns above. We don't bother trying
2059 to handle the bit insns here.
2060
2061 The first byte of the remaining insns will be 0xfc. */
2062
2063 /* Get the first opcode. */
2064 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
2065
2066 if (code != 0xfc)
2067 continue;
2068
2069 /* Get the second opcode. */
2070 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
2071
2072 if ((code & 0xf0) < 0x80)
2073 switch (code & 0xf0)
2074 {
2075 /* mov (d32,am),dn -> mov (d32,am),dn
2076 mov dm,(d32,am) -> mov dn,(d32,am)
2077 mov (d32,am),an -> mov (d32,am),an
2078 mov dm,(d32,am) -> mov dn,(d32,am)
2079 movbu (d32,am),dn -> movbu (d32,am),dn
2080 movbu dm,(d32,am) -> movbu dn,(d32,am)
2081 movhu (d32,am),dn -> movhu (d32,am),dn
2082 movhu dm,(d32,am) -> movhu dn,(d32,am) */
2083 case 0x00:
2084 case 0x10:
2085 case 0x20:
2086 case 0x30:
2087 case 0x40:
2088 case 0x50:
2089 case 0x60:
2090 case 0x70:
2091 /* Not safe if the high bit is on as relaxing may
2092 move the value out of high mem and thus not fit
2093 in a signed 16bit value. */
2094 if (code == 0xcc
2095 && (value & 0x8000))
2096 continue;
2097
2098 /* Note that we've changed the relocation contents, etc. */
2099 elf_section_data (sec)->relocs = internal_relocs;
2100 free_relocs = NULL;
2101
2102 elf_section_data (sec)->this_hdr.contents = contents;
2103 free_contents = NULL;
2104
2105 symtab_hdr->contents = (bfd_byte *) extsyms;
2106 free_extsyms = NULL;
2107
2108 /* Fix the opcode. */
2109 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
2110 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
2111
2112 /* Fix the relocation's type. */
2113 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2114 R_MN10300_16);
2115
2116 /* Delete two bytes of data. */
2117 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2118 irel->r_offset + 2, 2))
2119 goto error_return;
2120
2121 /* That will change things, so, we should relax again.
2122 Note that this is not required, and it may be slow. */
2123 *again = true;
2124 break;
2125 }
2126 else if ((code & 0xf0) == 0x80
2127 || (code & 0xf0) == 0x90)
2128 switch (code & 0xf3)
2129 {
2130 /* mov dn,(abs32) -> mov dn,(abs16)
2131 movbu dn,(abs32) -> movbu dn,(abs16)
2132 movhu dn,(abs32) -> movhu dn,(abs16) */
2133 case 0x81:
2134 case 0x82:
2135 case 0x83:
2136 /* Note that we've changed the relocation contents, etc. */
2137 elf_section_data (sec)->relocs = internal_relocs;
2138 free_relocs = NULL;
2139
2140 elf_section_data (sec)->this_hdr.contents = contents;
2141 free_contents = NULL;
2142
2143 symtab_hdr->contents = (bfd_byte *) extsyms;
2144 free_extsyms = NULL;
2145
2146 if ((code & 0xf3) == 0x81)
2147 code = 0x01 + (code & 0x0c);
2148 else if ((code & 0xf3) == 0x82)
2149 code = 0x02 + (code & 0x0c);
2150 else if ((code & 0xf3) == 0x83)
2151 code = 0x03 + (code & 0x0c);
2152 else
2153 abort ();
2154
2155 /* Fix the opcode. */
2156 bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
2157
2158 /* Fix the relocation's type. */
2159 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2160 R_MN10300_16);
2161
2162 /* The opcode got shorter too, so we have to fix the
2163 addend and offset too! */
2164 irel->r_offset -= 1;
2165
2166 /* Delete three bytes of data. */
2167 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2168 irel->r_offset + 1, 3))
2169 goto error_return;
2170
2171 /* That will change things, so, we should relax again.
2172 Note that this is not required, and it may be slow. */
2173 *again = true;
2174 break;
2175
2176 /* mov am,(abs32) -> mov am,(abs16)
2177 mov am,(d32,sp) -> mov am,(d16,sp)
2178 mov dm,(d32,sp) -> mov dm,(d32,sp)
2179 movbu dm,(d32,sp) -> movbu dm,(d32,sp)
2180 movhu dm,(d32,sp) -> movhu dm,(d32,sp) */
2181 case 0x80:
2182 case 0x90:
2183 case 0x91:
2184 case 0x92:
2185 case 0x93:
2186 /* Note that we've changed the relocation contents, etc. */
2187 elf_section_data (sec)->relocs = internal_relocs;
2188 free_relocs = NULL;
2189
2190 elf_section_data (sec)->this_hdr.contents = contents;
2191 free_contents = NULL;
2192
2193 symtab_hdr->contents = (bfd_byte *) extsyms;
2194 free_extsyms = NULL;
2195
2196 /* Fix the opcode. */
2197 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
2198 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
2199
2200 /* Fix the relocation's type. */
2201 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2202 R_MN10300_16);
2203
2204 /* Delete two bytes of data. */
2205 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2206 irel->r_offset + 2, 2))
2207 goto error_return;
2208
2209 /* That will change things, so, we should relax again.
2210 Note that this is not required, and it may be slow. */
2211 *again = true;
2212 break;
2213 }
2214 else if ((code & 0xf0) < 0xf0)
2215 switch (code & 0xfc)
2216 {
2217 /* mov imm32,dn -> mov imm16,dn
2218 mov imm32,an -> mov imm16,an
2219 mov (abs32),dn -> mov (abs16),dn
2220 movbu (abs32),dn -> movbu (abs16),dn
2221 movhu (abs32),dn -> movhu (abs16),dn */
2222 case 0xcc:
2223 case 0xdc:
2224 case 0xa4:
2225 case 0xa8:
2226 case 0xac:
2227 /* Not safe if the high bit is on as relaxing may
2228 move the value out of high mem and thus not fit
2229 in a signed 16bit value. */
2230 if (code == 0xcc
2231 && (value & 0x8000))
2232 continue;
2233
2234 /* Note that we've changed the relocation contents, etc. */
2235 elf_section_data (sec)->relocs = internal_relocs;
2236 free_relocs = NULL;
2237
2238 elf_section_data (sec)->this_hdr.contents = contents;
2239 free_contents = NULL;
2240
2241 symtab_hdr->contents = (bfd_byte *) extsyms;
2242 free_extsyms = NULL;
2243
2244 if ((code & 0xfc) == 0xcc)
2245 code = 0x2c + (code & 0x03);
2246 else if ((code & 0xfc) == 0xdc)
2247 code = 0x24 + (code & 0x03);
2248 else if ((code & 0xfc) == 0xa4)
2249 code = 0x30 + (code & 0x03);
2250 else if ((code & 0xfc) == 0xa8)
2251 code = 0x34 + (code & 0x03);
2252 else if ((code & 0xfc) == 0xac)
2253 code = 0x38 + (code & 0x03);
2254 else
2255 abort ();
2256
2257 /* Fix the opcode. */
2258 bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
2259
2260 /* Fix the relocation's type. */
2261 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2262 R_MN10300_16);
2263
2264 /* The opcode got shorter too, so we have to fix the
2265 addend and offset too! */
2266 irel->r_offset -= 1;
2267
2268 /* Delete three bytes of data. */
2269 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2270 irel->r_offset + 1, 3))
2271 goto error_return;
2272
2273 /* That will change things, so, we should relax again.
2274 Note that this is not required, and it may be slow. */
2275 *again = true;
2276 break;
2277
2278 /* mov (abs32),an -> mov (abs16),an
2279 mov (d32,sp),an -> mov (d32,sp),an
2280 mov (d32,sp),dn -> mov (d32,sp),dn
2281 movbu (d32,sp),dn -> movbu (d32,sp),dn
2282 movhu (d32,sp),dn -> movhu (d32,sp),dn
2283 add imm32,dn -> add imm16,dn
2284 cmp imm32,dn -> cmp imm16,dn
2285 add imm32,an -> add imm16,an
2286 cmp imm32,an -> cmp imm16,an
2287 and imm32,dn -> and imm32,dn
2288 or imm32,dn -> or imm32,dn
2289 xor imm32,dn -> xor imm32,dn
2290 btst imm32,dn -> btst imm32,dn */
2291
2292 case 0xa0:
2293 case 0xb0:
2294 case 0xb1:
2295 case 0xb2:
2296 case 0xb3:
2297 case 0xc0:
2298 case 0xc8:
2299
2300 case 0xd0:
2301 case 0xd8:
2302 case 0xe0:
2303 case 0xe1:
2304 case 0xe2:
2305 case 0xe3:
2306 /* Note that we've changed the relocation contents, etc. */
2307 elf_section_data (sec)->relocs = internal_relocs;
2308 free_relocs = NULL;
2309
2310 elf_section_data (sec)->this_hdr.contents = contents;
2311 free_contents = NULL;
2312
2313 symtab_hdr->contents = (bfd_byte *) extsyms;
2314 free_extsyms = NULL;
2315
2316 /* Fix the opcode. */
2317 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
2318 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
2319
2320 /* Fix the relocation's type. */
2321 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2322 R_MN10300_16);
2323
2324 /* Delete two bytes of data. */
2325 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2326 irel->r_offset + 2, 2))
2327 goto error_return;
2328
2329 /* That will change things, so, we should relax again.
2330 Note that this is not required, and it may be slow. */
2331 *again = true;
2332 break;
2333 }
2334 else if (code == 0xfe)
2335 {
2336 /* add imm32,sp -> add imm16,sp */
2337
2338 /* Note that we've changed the relocation contents, etc. */
2339 elf_section_data (sec)->relocs = internal_relocs;
2340 free_relocs = NULL;
2341
2342 elf_section_data (sec)->this_hdr.contents = contents;
2343 free_contents = NULL;
2344
2345 symtab_hdr->contents = (bfd_byte *) extsyms;
2346 free_extsyms = NULL;
2347
2348 /* Fix the opcode. */
2349 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
2350 bfd_put_8 (abfd, 0xfe, contents + irel->r_offset - 1);
2351
2352 /* Fix the relocation's type. */
2353 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2354 R_MN10300_16);
2355
2356 /* Delete two bytes of data. */
2357 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2358 irel->r_offset + 2, 2))
2359 goto error_return;
2360
2361 /* That will change things, so, we should relax again.
2362 Note that this is not required, and it may be slow. */
2363 *again = true;
2364 break;
2365 }
2366 }
2367 }
2368 }
2369
2370 if (free_relocs != NULL)
2371 {
2372 free (free_relocs);
2373 free_relocs = NULL;
2374 }
2375
2376 if (free_contents != NULL)
2377 {
2378 if (! link_info->keep_memory)
2379 free (free_contents);
2380 else
2381 {
2382 /* Cache the section contents for elf_link_input_bfd. */
2383 elf_section_data (sec)->this_hdr.contents = contents;
2384 }
2385 free_contents = NULL;
2386 }
2387
2388 if (free_extsyms != NULL)
2389 {
2390 if (! link_info->keep_memory)
2391 free (free_extsyms);
2392 else
2393 {
2394 /* Cache the symbols for elf_link_input_bfd. */
2395 symtab_hdr->contents = extsyms;
2396 }
2397 free_extsyms = NULL;
2398 }
2399
2400 return true;
2401
2402 error_return:
2403 if (free_relocs != NULL)
2404 free (free_relocs);
2405 if (free_contents != NULL)
2406 free (free_contents);
2407 if (free_extsyms != NULL)
2408 free (free_extsyms);
2409 return false;
2410 }
2411
2412 /* Compute the stack size and movm arguments for the function
2413 referred to by HASH at address ADDR in section with
2414 contents CONTENTS, store the information in the hash table. */
2415 static void
2416 compute_function_info (abfd, hash, addr, contents)
2417 bfd *abfd;
2418 struct elf32_mn10300_link_hash_entry *hash;
2419 bfd_vma addr;
2420 unsigned char *contents;
2421 {
2422 unsigned char byte1, byte2;
2423 /* We only care about a very small subset of the possible prologue
2424 sequences here. Basically we look for:
2425
2426 movm [d2,d3,a2,a3],sp (optional)
2427 add <size>,sp (optional, and only for sizes which fit in an unsigned
2428 8 bit number)
2429
2430 If we find anything else, we quit. */
2431
2432 /* Look for movm [regs],sp */
2433 byte1 = bfd_get_8 (abfd, contents + addr);
2434 byte2 = bfd_get_8 (abfd, contents + addr + 1);
2435
2436 if (byte1 == 0xcf)
2437 {
2438 hash->movm_args = byte2;
2439 addr += 2;
2440 byte1 = bfd_get_8 (abfd, contents + addr);
2441 byte2 = bfd_get_8 (abfd, contents + addr + 1);
2442 }
2443
2444 /* Now figure out how much stack space will be allocated by the movm
2445 instruction. We need this kept separate from the funtion's normal
2446 stack space. */
2447 if (hash->movm_args)
2448 {
2449 /* Space for d2. */
2450 if (hash->movm_args & 0x80)
2451 hash->movm_stack_size += 4;
2452
2453 /* Space for d3. */
2454 if (hash->movm_args & 0x40)
2455 hash->movm_stack_size += 4;
2456
2457 /* Space for a2. */
2458 if (hash->movm_args & 0x20)
2459 hash->movm_stack_size += 4;
2460
2461 /* Space for a3. */
2462 if (hash->movm_args & 0x10)
2463 hash->movm_stack_size += 4;
2464
2465 /* "other" space. d0, d1, a0, a1, mdr, lir, lar, 4 byte pad. */
2466 if (hash->movm_args & 0x08)
2467 hash->movm_stack_size += 8 * 4;
2468
2469 if (bfd_get_mach (abfd) == bfd_mach_am33)
2470 {
2471 /* "exother" space. e0, e1, mdrq, mcrh, mcrl, mcvf */
2472 if (hash->movm_args & 0x1)
2473 hash->movm_stack_size += 6 * 4;
2474
2475 /* exreg1 space. e4, e5, e6, e7 */
2476 if (hash->movm_args & 0x2)
2477 hash->movm_stack_size += 4 * 4;
2478
2479 /* exreg0 space. e2, e3 */
2480 if (hash->movm_args & 0x4)
2481 hash->movm_stack_size += 2 * 4;
2482 }
2483 }
2484
2485 /* Now look for the two stack adjustment variants. */
2486 if (byte1 == 0xf8 && byte2 == 0xfe)
2487 {
2488 int temp = bfd_get_8 (abfd, contents + addr + 2);
2489 temp = ((temp & 0xff) ^ (~0x7f)) + 0x80;
2490
2491 hash->stack_size = -temp;
2492 }
2493 else if (byte1 == 0xfa && byte2 == 0xfe)
2494 {
2495 int temp = bfd_get_16 (abfd, contents + addr + 2);
2496 temp = ((temp & 0xffff) ^ (~0x7fff)) + 0x8000;
2497 temp = -temp;
2498
2499 if (temp < 255)
2500 hash->stack_size = temp;
2501 }
2502
2503 /* If the total stack to be allocated by the call instruction is more
2504 than 255 bytes, then we can't remove the stack adjustment by using
2505 "call" (we might still be able to remove the "movm" instruction. */
2506 if (hash->stack_size + hash->movm_stack_size > 255)
2507 hash->stack_size = 0;
2508
2509 return;
2510 }
2511
2512 /* Delete some bytes from a section while relaxing. */
2513
2514 static boolean
2515 mn10300_elf_relax_delete_bytes (abfd, sec, addr, count)
2516 bfd *abfd;
2517 asection *sec;
2518 bfd_vma addr;
2519 int count;
2520 {
2521 Elf_Internal_Shdr *symtab_hdr;
2522 Elf32_External_Sym *extsyms;
2523 int shndx, index;
2524 bfd_byte *contents;
2525 Elf_Internal_Rela *irel, *irelend;
2526 Elf_Internal_Rela *irelalign;
2527 bfd_vma toaddr;
2528 Elf32_External_Sym *esym, *esymend;
2529 struct elf32_mn10300_link_hash_entry *sym_hash;
2530
2531 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2532 extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
2533
2534 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
2535
2536 contents = elf_section_data (sec)->this_hdr.contents;
2537
2538 /* The deletion must stop at the next ALIGN reloc for an aligment
2539 power larger than the number of bytes we are deleting. */
2540
2541 irelalign = NULL;
2542 toaddr = sec->_cooked_size;
2543
2544 irel = elf_section_data (sec)->relocs;
2545 irelend = irel + sec->reloc_count;
2546
2547 /* Actually delete the bytes. */
2548 memmove (contents + addr, contents + addr + count, toaddr - addr - count);
2549 sec->_cooked_size -= count;
2550
2551 /* Adjust all the relocs. */
2552 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
2553 {
2554 /* Get the new reloc address. */
2555 if ((irel->r_offset > addr
2556 && irel->r_offset < toaddr))
2557 irel->r_offset -= count;
2558 }
2559
2560 /* Adjust the local symbols defined in this section. */
2561 esym = extsyms;
2562 esymend = esym + symtab_hdr->sh_info;
2563 for (; esym < esymend; esym++)
2564 {
2565 Elf_Internal_Sym isym;
2566
2567 bfd_elf32_swap_symbol_in (abfd, esym, &isym);
2568
2569 if (isym.st_shndx == shndx
2570 && isym.st_value > addr
2571 && isym.st_value < toaddr)
2572 {
2573 isym.st_value -= count;
2574 bfd_elf32_swap_symbol_out (abfd, &isym, esym);
2575 }
2576 }
2577
2578 /* Now adjust the global symbols defined in this section. */
2579 esym = extsyms + symtab_hdr->sh_info;
2580 esymend = extsyms + (symtab_hdr->sh_size / sizeof (Elf32_External_Sym));
2581 for (index = 0; esym < esymend; esym++, index++)
2582 {
2583 Elf_Internal_Sym isym;
2584
2585 bfd_elf32_swap_symbol_in (abfd, esym, &isym);
2586 sym_hash = (struct elf32_mn10300_link_hash_entry *)
2587 (elf_sym_hashes (abfd)[index]);
2588 if (isym.st_shndx == shndx
2589 && ((sym_hash)->root.root.type == bfd_link_hash_defined
2590 || (sym_hash)->root.root.type == bfd_link_hash_defweak)
2591 && (sym_hash)->root.root.u.def.section == sec
2592 && (sym_hash)->root.root.u.def.value > addr
2593 && (sym_hash)->root.root.u.def.value < toaddr)
2594 {
2595 (sym_hash)->root.root.u.def.value -= count;
2596 }
2597 }
2598
2599 return true;
2600 }
2601
2602 /* Return true if a symbol exists at the given address, else return
2603 false. */
2604 static boolean
2605 mn10300_elf_symbol_address_p (abfd, sec, extsyms, addr)
2606 bfd *abfd;
2607 asection *sec;
2608 Elf32_External_Sym *extsyms;
2609 bfd_vma addr;
2610 {
2611 Elf_Internal_Shdr *symtab_hdr;
2612 int shndx;
2613 Elf32_External_Sym *esym, *esymend;
2614 struct elf32_mn10300_link_hash_entry **sym_hash, **sym_hash_end;
2615
2616 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2617 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
2618
2619 /* Examine all the symbols. */
2620 esym = extsyms;
2621 esymend = esym + symtab_hdr->sh_info;
2622 for (; esym < esymend; esym++)
2623 {
2624 Elf_Internal_Sym isym;
2625
2626 bfd_elf32_swap_symbol_in (abfd, esym, &isym);
2627
2628 if (isym.st_shndx == shndx
2629 && isym.st_value == addr)
2630 return true;
2631 }
2632
2633 sym_hash = (struct elf32_mn10300_link_hash_entry **) (elf_sym_hashes (abfd));
2634 sym_hash_end = (sym_hash
2635 + (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
2636 - symtab_hdr->sh_info));
2637 for (; sym_hash < sym_hash_end; sym_hash++)
2638 {
2639 if (((*sym_hash)->root.root.type == bfd_link_hash_defined
2640 || (*sym_hash)->root.root.type == bfd_link_hash_defweak)
2641 && (*sym_hash)->root.root.u.def.section == sec
2642 && (*sym_hash)->root.root.u.def.value == addr)
2643 return true;
2644 }
2645 return false;
2646 }
2647
2648 /* This is a version of bfd_generic_get_relocated_section_contents
2649 which uses mn10300_elf_relocate_section. */
2650
2651 static bfd_byte *
2652 mn10300_elf_get_relocated_section_contents (output_bfd, link_info, link_order,
2653 data, relocateable, symbols)
2654 bfd *output_bfd;
2655 struct bfd_link_info *link_info;
2656 struct bfd_link_order *link_order;
2657 bfd_byte *data;
2658 boolean relocateable;
2659 asymbol **symbols;
2660 {
2661 Elf_Internal_Shdr *symtab_hdr;
2662 asection *input_section = link_order->u.indirect.section;
2663 bfd *input_bfd = input_section->owner;
2664 asection **sections = NULL;
2665 Elf_Internal_Rela *internal_relocs = NULL;
2666 Elf32_External_Sym *external_syms = NULL;
2667 Elf_Internal_Sym *internal_syms = NULL;
2668
2669 /* We only need to handle the case of relaxing, or of having a
2670 particular set of section contents, specially. */
2671 if (relocateable
2672 || elf_section_data (input_section)->this_hdr.contents == NULL)
2673 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
2674 link_order, data,
2675 relocateable,
2676 symbols);
2677
2678 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2679
2680 memcpy (data, elf_section_data (input_section)->this_hdr.contents,
2681 input_section->_raw_size);
2682
2683 if ((input_section->flags & SEC_RELOC) != 0
2684 && input_section->reloc_count > 0)
2685 {
2686 Elf_Internal_Sym *isymp;
2687 asection **secpp;
2688 Elf32_External_Sym *esym, *esymend;
2689
2690 if (symtab_hdr->contents != NULL)
2691 external_syms = (Elf32_External_Sym *) symtab_hdr->contents;
2692 else
2693 {
2694 external_syms = ((Elf32_External_Sym *)
2695 bfd_malloc (symtab_hdr->sh_info
2696 * sizeof (Elf32_External_Sym)));
2697 if (external_syms == NULL && symtab_hdr->sh_info > 0)
2698 goto error_return;
2699 if (bfd_seek (input_bfd, symtab_hdr->sh_offset, SEEK_SET) != 0
2700 || (bfd_read (external_syms, sizeof (Elf32_External_Sym),
2701 symtab_hdr->sh_info, input_bfd)
2702 != (symtab_hdr->sh_info * sizeof (Elf32_External_Sym))))
2703 goto error_return;
2704 }
2705
2706 internal_relocs = (_bfd_elf32_link_read_relocs
2707 (input_bfd, input_section, (PTR) NULL,
2708 (Elf_Internal_Rela *) NULL, false));
2709 if (internal_relocs == NULL)
2710 goto error_return;
2711
2712 internal_syms = ((Elf_Internal_Sym *)
2713 bfd_malloc (symtab_hdr->sh_info
2714 * sizeof (Elf_Internal_Sym)));
2715 if (internal_syms == NULL && symtab_hdr->sh_info > 0)
2716 goto error_return;
2717
2718 sections = (asection **) bfd_malloc (symtab_hdr->sh_info
2719 * sizeof (asection *));
2720 if (sections == NULL && symtab_hdr->sh_info > 0)
2721 goto error_return;
2722
2723 isymp = internal_syms;
2724 secpp = sections;
2725 esym = external_syms;
2726 esymend = esym + symtab_hdr->sh_info;
2727 for (; esym < esymend; ++esym, ++isymp, ++secpp)
2728 {
2729 asection *isec;
2730
2731 bfd_elf32_swap_symbol_in (input_bfd, esym, isymp);
2732
2733 if (isymp->st_shndx == SHN_UNDEF)
2734 isec = bfd_und_section_ptr;
2735 else if (isymp->st_shndx > 0 && isymp->st_shndx < SHN_LORESERVE)
2736 isec = bfd_section_from_elf_index (input_bfd, isymp->st_shndx);
2737 else if (isymp->st_shndx == SHN_ABS)
2738 isec = bfd_abs_section_ptr;
2739 else if (isymp->st_shndx == SHN_COMMON)
2740 isec = bfd_com_section_ptr;
2741 else
2742 {
2743 /* Who knows? */
2744 isec = NULL;
2745 }
2746
2747 *secpp = isec;
2748 }
2749
2750 if (! mn10300_elf_relocate_section (output_bfd, link_info, input_bfd,
2751 input_section, data, internal_relocs,
2752 internal_syms, sections))
2753 goto error_return;
2754
2755 if (sections != NULL)
2756 free (sections);
2757 sections = NULL;
2758 if (internal_syms != NULL)
2759 free (internal_syms);
2760 internal_syms = NULL;
2761 if (external_syms != NULL && symtab_hdr->contents == NULL)
2762 free (external_syms);
2763 external_syms = NULL;
2764 if (internal_relocs != elf_section_data (input_section)->relocs)
2765 free (internal_relocs);
2766 internal_relocs = NULL;
2767 }
2768
2769 return data;
2770
2771 error_return:
2772 if (internal_relocs != NULL
2773 && internal_relocs != elf_section_data (input_section)->relocs)
2774 free (internal_relocs);
2775 if (external_syms != NULL && symtab_hdr->contents == NULL)
2776 free (external_syms);
2777 if (internal_syms != NULL)
2778 free (internal_syms);
2779 if (sections != NULL)
2780 free (sections);
2781 return NULL;
2782 }
2783
2784 /* Assorted hash table functions. */
2785
2786 /* Initialize an entry in the link hash table. */
2787
2788 /* Create an entry in an MN10300 ELF linker hash table. */
2789
2790 static struct bfd_hash_entry *
2791 elf32_mn10300_link_hash_newfunc (entry, table, string)
2792 struct bfd_hash_entry *entry;
2793 struct bfd_hash_table *table;
2794 const char *string;
2795 {
2796 struct elf32_mn10300_link_hash_entry *ret =
2797 (struct elf32_mn10300_link_hash_entry *) entry;
2798
2799 /* Allocate the structure if it has not already been allocated by a
2800 subclass. */
2801 if (ret == (struct elf32_mn10300_link_hash_entry *) NULL)
2802 ret = ((struct elf32_mn10300_link_hash_entry *)
2803 bfd_hash_allocate (table,
2804 sizeof (struct elf32_mn10300_link_hash_entry)));
2805 if (ret == (struct elf32_mn10300_link_hash_entry *) NULL)
2806 return (struct bfd_hash_entry *) ret;
2807
2808 /* Call the allocation method of the superclass. */
2809 ret = ((struct elf32_mn10300_link_hash_entry *)
2810 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
2811 table, string));
2812 if (ret != (struct elf32_mn10300_link_hash_entry *) NULL)
2813 {
2814 ret->direct_calls = 0;
2815 ret->stack_size = 0;
2816 ret->movm_stack_size = 0;
2817 ret->flags = 0;
2818 ret->movm_args = 0;
2819 }
2820
2821 return (struct bfd_hash_entry *) ret;
2822 }
2823
2824 /* Create an mn10300 ELF linker hash table. */
2825
2826 static struct bfd_link_hash_table *
2827 elf32_mn10300_link_hash_table_create (abfd)
2828 bfd *abfd;
2829 {
2830 struct elf32_mn10300_link_hash_table *ret;
2831
2832 ret = ((struct elf32_mn10300_link_hash_table *)
2833 bfd_alloc (abfd, sizeof (struct elf32_mn10300_link_hash_table)));
2834 if (ret == (struct elf32_mn10300_link_hash_table *) NULL)
2835 return NULL;
2836
2837 if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
2838 elf32_mn10300_link_hash_newfunc))
2839 {
2840 bfd_release (abfd, ret);
2841 return NULL;
2842 }
2843
2844 ret->flags = 0;
2845 ret->static_hash_table
2846 = ((struct elf32_mn10300_link_hash_table *)
2847 bfd_alloc (abfd, sizeof (struct elf_link_hash_table)));
2848 if (ret->static_hash_table == NULL)
2849 {
2850 bfd_release (abfd, ret);
2851 return NULL;
2852 }
2853
2854 if (! _bfd_elf_link_hash_table_init (&ret->static_hash_table->root, abfd,
2855 elf32_mn10300_link_hash_newfunc))
2856 {
2857 bfd_release (abfd, ret->static_hash_table);
2858 bfd_release (abfd, ret);
2859 return NULL;
2860 }
2861 return &ret->root.root;
2862 }
2863
2864 static int
2865 elf_mn10300_mach (flags)
2866 flagword flags;
2867 {
2868 switch (flags & EF_MN10300_MACH)
2869 {
2870 case E_MN10300_MACH_MN10300:
2871 default:
2872 return bfd_mach_mn10300;
2873
2874 case E_MN10300_MACH_AM33:
2875 return bfd_mach_am33;
2876 }
2877 }
2878
2879 /* The final processing done just before writing out a MN10300 ELF object
2880 file. This gets the MN10300 architecture right based on the machine
2881 number. */
2882
2883 void
2884 _bfd_mn10300_elf_final_write_processing (abfd, linker)
2885 bfd *abfd;
2886 boolean linker ATTRIBUTE_UNUSED;
2887 {
2888 unsigned long val;
2889
2890 switch (bfd_get_mach (abfd))
2891 {
2892 default:
2893 case bfd_mach_mn10300:
2894 val = E_MN10300_MACH_MN10300;
2895 break;
2896
2897 case bfd_mach_am33:
2898 val = E_MN10300_MACH_AM33;
2899 break;
2900 }
2901
2902 elf_elfheader (abfd)->e_flags &= ~ (EF_MN10300_MACH);
2903 elf_elfheader (abfd)->e_flags |= val;
2904 }
2905
2906 boolean
2907 _bfd_mn10300_elf_object_p (abfd)
2908 bfd *abfd;
2909 {
2910 bfd_default_set_arch_mach (abfd, bfd_arch_mn10300,
2911 elf_mn10300_mach (elf_elfheader (abfd)->e_flags));
2912 return true;
2913 }
2914
2915 /* Merge backend specific data from an object file to the output
2916 object file when linking. */
2917
2918 boolean
2919 _bfd_mn10300_elf_merge_private_bfd_data (ibfd, obfd)
2920 bfd *ibfd;
2921 bfd *obfd;
2922 {
2923 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2924 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2925 return true;
2926
2927 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
2928 && bfd_get_mach (obfd) < bfd_get_mach (ibfd))
2929 {
2930 if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
2931 bfd_get_mach (ibfd)))
2932 return false;
2933 }
2934
2935 return true;
2936 }
2937
2938 #define TARGET_LITTLE_SYM bfd_elf32_mn10300_vec
2939 #define TARGET_LITTLE_NAME "elf32-mn10300"
2940 #define ELF_ARCH bfd_arch_mn10300
2941 #define ELF_MACHINE_CODE EM_CYGNUS_MN10300
2942 #define ELF_MAXPAGESIZE 0x1000
2943
2944 #define elf_info_to_howto mn10300_info_to_howto
2945 #define elf_info_to_howto_rel 0
2946 #define elf_backend_can_gc_sections 1
2947 #define elf_backend_check_relocs mn10300_elf_check_relocs
2948 #define elf_backend_gc_mark_hook mn10300_elf_gc_mark_hook
2949 #define elf_backend_relocate_section mn10300_elf_relocate_section
2950 #define bfd_elf32_bfd_relax_section mn10300_elf_relax_section
2951 #define bfd_elf32_bfd_get_relocated_section_contents \
2952 mn10300_elf_get_relocated_section_contents
2953 #define bfd_elf32_bfd_link_hash_table_create \
2954 elf32_mn10300_link_hash_table_create
2955
2956 #define elf_symbol_leading_char '_'
2957
2958 /* So we can set bits in e_flags. */
2959 #define elf_backend_final_write_processing \
2960 _bfd_mn10300_elf_final_write_processing
2961 #define elf_backend_object_p _bfd_mn10300_elf_object_p
2962
2963 #define bfd_elf32_bfd_merge_private_bfd_data \
2964 _bfd_mn10300_elf_merge_private_bfd_data
2965
2966 #include "elf32-target.h"
git-cvsimport of binutils cvsroot