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