?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
o
[binutils.git] / bfd / elf-m10300.c
blobc46dc0c796164b0ea4155dfe10dd26c53f04b9ef
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)))
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)))
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;
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;
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
1215 sym_name = bfd_elf_string_from_elf_section (input_bfd,
1216 symtab_hdr->sh_link,
1217 isym.st_name);
1218
1219 /* Tack on an ID so we can uniquely identify this
1220 local symbol in the global hash table. */
1221 new_name = bfd_malloc (strlen (sym_name) + 10);
1222 if (new_name == 0)
1223 goto error_return;
1224 sprintf (new_name, "%s_%08x", sym_name, (int)sym_sec);
1225 sym_name = new_name;
1226
1227 sym_hash = (struct elf32_mn10300_link_hash_entry *)
1228 elf_link_hash_lookup (&hash_table->static_hash_table->root,
1229 sym_name, false,
1230 false, false);
1231
1232 free (new_name);
1233 if (sym_hash == NULL)
1234 continue;
1235
1236 if (! ((sym_hash)->flags & MN10300_CONVERT_CALL_TO_CALLS)
1237 && ! ((sym_hash)->flags & MN10300_DELETED_PROLOGUE_BYTES))
1238 {
1239 int bytes = 0;
1240
1241 /* Note that we've changed things. */
1242 elf_section_data (section)->relocs = internal_relocs;
1243 free_relocs = NULL;
1244
1245 elf_section_data (section)->this_hdr.contents = contents;
1246 free_contents = NULL;
1247
1248 symtab_hdr->contents = (bfd_byte *)extsyms;
1249 free_extsyms = NULL;
1250
1251 /* Count how many bytes we're going to delete. */
1252 if (sym_hash->movm_args)
1253 bytes += 2;
1254
1255 if (sym_hash->stack_size && sym_hash->stack_size <= 128)
1256 bytes += 3;
1257 else if (sym_hash->stack_size
1258 && sym_hash->stack_size < 256)
1259 bytes += 4;
1260
1261 /* Note that we've deleted prologue bytes for this
1262 function. */
1263 sym_hash->flags |= MN10300_DELETED_PROLOGUE_BYTES;
1264
1265 /* Actually delete the bytes. */
1266 if (!mn10300_elf_relax_delete_bytes (input_bfd,
1267 section,
1268 isym.st_value,
1269 bytes))
1270 goto error_return;
1271
1272 /* Something changed. Not strictly necessary, but
1273 may lead to more relaxing opportunities. */
1274 *again = true;
1275 }
1276 }
1277
1278 /* Look for any global functions in this section which
1279 need insns deleted from their prologues. */
1280 esym = extsyms + symtab_hdr->sh_info;
1281 esymend = extsyms + (symtab_hdr->sh_size
1282 / sizeof (Elf32_External_Sym));
1283 for (idx = 0; esym < esymend; esym++, idx++)
1284 {
1285 Elf_Internal_Sym isym;
1286 struct elf32_mn10300_link_hash_entry *sym_hash;
1287
1288 bfd_elf32_swap_symbol_in (input_bfd, esym, &isym);
1289 sym_hash = (struct elf32_mn10300_link_hash_entry *)
1290 (elf_sym_hashes (input_bfd)[idx]);
1291 if (isym.st_shndx == shndx
1292 && (sym_hash)->root.root.u.def.section == section
1293 && ! ((sym_hash)->flags & MN10300_CONVERT_CALL_TO_CALLS)
1294 && ! ((sym_hash)->flags & MN10300_DELETED_PROLOGUE_BYTES))
1295 {
1296 int bytes = 0;
1297
1298 /* Note that we've changed things. */
1299 elf_section_data (section)->relocs = internal_relocs;
1300 free_relocs = NULL;
1301
1302 elf_section_data (section)->this_hdr.contents = contents;
1303 free_contents = NULL;
1304
1305 symtab_hdr->contents = (bfd_byte *)extsyms;
1306 free_extsyms = NULL;
1307
1308 /* Count how many bytes we're going to delete. */
1309 if (sym_hash->movm_args)
1310 bytes += 2;
1311
1312 if (sym_hash->stack_size && sym_hash->stack_size <= 128)
1313 bytes += 3;
1314 else if (sym_hash->stack_size
1315 && sym_hash->stack_size < 256)
1316 bytes += 4;
1317
1318 /* Note that we've deleted prologue bytes for this
1319 function. */
1320 sym_hash->flags |= MN10300_DELETED_PROLOGUE_BYTES;
1321
1322 /* Actually delete the bytes. */
1323 if (!mn10300_elf_relax_delete_bytes (input_bfd,
1324 section,
1325 (sym_hash)->root.root.u.def.value,
1326 bytes))
1327 goto error_return;
1328
1329 /* Something changed. Not strictly necessary, but
1330 may lead to more relaxing opportunities. */
1331 *again = true;
1332 }
1333 }
1334
1335 /* Cache or free any memory we allocated for the relocs. */
1336 if (free_relocs != NULL)
1337 {
1338 free (free_relocs);
1339 free_relocs = NULL;
1340 }
1341
1342 /* Cache or free any memory we allocated for the contents. */
1343 if (free_contents != NULL)
1344 {
1345 if (! link_info->keep_memory)
1346 free (free_contents);
1347 else
1348 {
1349 /* Cache the section contents for elf_link_input_bfd. */
1350 elf_section_data (section)->this_hdr.contents = contents;
1351 }
1352 free_contents = NULL;
1353 }
1354 }
1355
1356 /* Cache or free any memory we allocated for the symbols. */
1357 if (free_extsyms != NULL)
1358 {
1359 if (! link_info->keep_memory)
1360 free (free_extsyms);
1361 else
1362 {
1363 /* Cache the symbols for elf_link_input_bfd. */
1364 symtab_hdr->contents = extsyms;
1365 }
1366 free_extsyms = NULL;
1367 }
1368 }
1369 }
1370
1371
1372 /* (Re)initialize for the basic instruction shortening/relaxing pass. */
1373 contents = NULL;
1374 extsyms = NULL;
1375 internal_relocs = NULL;
1376 free_relocs = NULL;
1377 free_contents = NULL;
1378 free_extsyms = NULL;
1379
1380 /* We don't have to do anything for a relocateable link, if
1381 this section does not have relocs, or if this is not a
1382 code section. */
1383 if (link_info->relocateable
1384 || (sec->flags & SEC_RELOC) == 0
1385 || sec->reloc_count == 0
1386 || (sec->flags & SEC_CODE) == 0)
1387 return true;
1388
1389 /* If this is the first time we have been called for this section,
1390 initialize the cooked size. */
1391 if (sec->_cooked_size == 0)
1392 sec->_cooked_size = sec->_raw_size;
1393
1394 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1395
1396 /* Get a copy of the native relocations. */
1397 internal_relocs = (_bfd_elf32_link_read_relocs
1398 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
1399 link_info->keep_memory));
1400 if (internal_relocs == NULL)
1401 goto error_return;
1402 if (! link_info->keep_memory)
1403 free_relocs = internal_relocs;
1404
1405 /* Walk through them looking for relaxing opportunities. */
1406 irelend = internal_relocs + sec->reloc_count;
1407 for (irel = internal_relocs; irel < irelend; irel++)
1408 {
1409 bfd_vma symval;
1410 struct elf32_mn10300_link_hash_entry *h = NULL;
1411
1412 /* If this isn't something that can be relaxed, then ignore
1413 this reloc. */
1414 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_NONE
1415 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_8
1416 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_MAX)
1417 continue;
1418
1419 /* Get the section contents if we haven't done so already. */
1420 if (contents == NULL)
1421 {
1422 /* Get cached copy if it exists. */
1423 if (elf_section_data (sec)->this_hdr.contents != NULL)
1424 contents = elf_section_data (sec)->this_hdr.contents;
1425 else
1426 {
1427 /* Go get them off disk. */
1428 contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
1429 if (contents == NULL)
1430 goto error_return;
1431 free_contents = contents;
1432
1433 if (! bfd_get_section_contents (abfd, sec, contents,
1434 (file_ptr) 0, sec->_raw_size))
1435 goto error_return;
1436 }
1437 }
1438
1439 /* Read this BFD's symbols if we haven't done so already. */
1440 if (extsyms == NULL)
1441 {
1442 /* Get cached copy if it exists. */
1443 if (symtab_hdr->contents != NULL)
1444 extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
1445 else
1446 {
1447 /* Go get them off disk. */
1448 extsyms = ((Elf32_External_Sym *)
1449 bfd_malloc (symtab_hdr->sh_size));
1450 if (extsyms == NULL)
1451 goto error_return;
1452 free_extsyms = extsyms;
1453 if (bfd_seek (abfd, symtab_hdr->sh_offset, SEEK_SET) != 0
1454 || (bfd_read (extsyms, 1, symtab_hdr->sh_size, abfd)
1455 != symtab_hdr->sh_size))
1456 goto error_return;
1457 }
1458 }
1459
1460 /* Get the value of the symbol referred to by the reloc. */
1461 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1462 {
1463 Elf_Internal_Sym isym;
1464 asection *sym_sec;
1465 const char *sym_name;
1466 char *new_name;
1467
1468 /* A local symbol. */
1469 bfd_elf32_swap_symbol_in (abfd,
1470 extsyms + ELF32_R_SYM (irel->r_info),
1471 &isym);
1472
1473 if (isym.st_shndx == SHN_UNDEF)
1474 sym_sec = bfd_und_section_ptr;
1475 else if (isym.st_shndx > 0 && isym.st_shndx < SHN_LORESERVE)
1476 sym_sec = bfd_section_from_elf_index (abfd, isym.st_shndx);
1477 else if (isym.st_shndx == SHN_ABS)
1478 sym_sec = bfd_abs_section_ptr;
1479 else if (isym.st_shndx == SHN_COMMON)
1480 sym_sec = bfd_com_section_ptr;
1481
1482 symval = (isym.st_value
1483 + sym_sec->output_section->vma
1484 + sym_sec->output_offset);
1485 sym_name = bfd_elf_string_from_elf_section (abfd,
1486 symtab_hdr->sh_link,
1487 isym.st_name);
1488
1489 /* Tack on an ID so we can uniquely identify this
1490 local symbol in the global hash table. */
1491 new_name = bfd_malloc (strlen (sym_name) + 10);
1492 if (new_name == 0)
1493 goto error_return;
1494 sprintf (new_name, "%s_%08x", sym_name, (int)sym_sec);
1495 sym_name = new_name;
1496
1497 h = (struct elf32_mn10300_link_hash_entry *)
1498 elf_link_hash_lookup (&hash_table->static_hash_table->root,
1499 sym_name, false, false, false);
1500 free (new_name);
1501 }
1502 else
1503 {
1504 unsigned long indx;
1505
1506 /* An external symbol. */
1507 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
1508 h = (struct elf32_mn10300_link_hash_entry *)
1509 (elf_sym_hashes (abfd)[indx]);
1510 BFD_ASSERT (h != NULL);
1511 if (h->root.root.type != bfd_link_hash_defined
1512 && h->root.root.type != bfd_link_hash_defweak)
1513 {
1514 /* This appears to be a reference to an undefined
1515 symbol. Just ignore it--it will be caught by the
1516 regular reloc processing. */
1517 continue;
1518 }
1519
1520 symval = (h->root.root.u.def.value
1521 + h->root.root.u.def.section->output_section->vma
1522 + h->root.root.u.def.section->output_offset);
1523 }
1524
1525 /* For simplicity of coding, we are going to modify the section
1526 contents, the section relocs, and the BFD symbol table. We
1527 must tell the rest of the code not to free up this
1528 information. It would be possible to instead create a table
1529 of changes which have to be made, as is done in coff-mips.c;
1530 that would be more work, but would require less memory when
1531 the linker is run. */
1532
1533 /* Try to turn a 32bit pc-relative branch/call into a 16bit pc-relative
1534 branch/call, also deal with "call" -> "calls" conversions and
1535 insertion of prologue data into "call" instructions. */
1536 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL32)
1537 {
1538 bfd_vma value = symval;
1539
1540 /* If we've got a "call" instruction that needs to be turned
1541 into a "calls" instruction, do so now. It saves a byte. */
1542 if (h && (h->flags & MN10300_CONVERT_CALL_TO_CALLS))
1543 {
1544 unsigned char code;
1545
1546 /* Get the opcode. */
1547 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1548
1549 /* Make sure we're working with a "call" instruction! */
1550 if (code == 0xdd)
1551 {
1552 /* Note that we've changed the relocs, section contents,
1553 etc. */
1554 elf_section_data (sec)->relocs = internal_relocs;
1555 free_relocs = NULL;
1556
1557 elf_section_data (sec)->this_hdr.contents = contents;
1558 free_contents = NULL;
1559
1560 symtab_hdr->contents = (bfd_byte *) extsyms;
1561 free_extsyms = NULL;
1562
1563 /* Fix the opcode. */
1564 bfd_put_8 (abfd, 0xfc, contents + irel->r_offset - 1);
1565 bfd_put_8 (abfd, 0xff, contents + irel->r_offset);
1566
1567 /* Fix irel->r_offset and irel->r_addend. */
1568 irel->r_offset += 1;
1569 irel->r_addend += 1;
1570
1571 /* Delete one byte of data. */
1572 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
1573 irel->r_offset + 3, 1))
1574 goto error_return;
1575
1576 /* That will change things, so, we should relax again.
1577 Note that this is not required, and it may be slow. */
1578 *again = true;
1579 }
1580 }
1581 else if (h)
1582 {
1583 /* We've got a "call" instruction which needs some data
1584 from target function filled in. */
1585 unsigned char code;
1586
1587 /* Get the opcode. */
1588 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1589
1590 /* Insert data from the target function into the "call"
1591 instruction if needed. */
1592 if (code == 0xdd)
1593 {
1594 bfd_put_8 (abfd, h->movm_args, contents + irel->r_offset + 4);
1595 bfd_put_8 (abfd, h->stack_size + h->movm_stack_size,
1596 contents + irel->r_offset + 5);
1597 }
1598 }
1599
1600 /* Deal with pc-relative gunk. */
1601 value -= (sec->output_section->vma + sec->output_offset);
1602 value -= irel->r_offset;
1603 value += irel->r_addend;
1604
1605 /* See if the value will fit in 16 bits, note the high value is
1606 0x7fff + 2 as the target will be two bytes closer if we are
1607 able to relax. */
1608 if ((long)value < 0x8001 && (long)value > -0x8000)
1609 {
1610 unsigned char code;
1611
1612 /* Get the opcode. */
1613 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1614
1615 if (code != 0xdc && code != 0xdd && code != 0xff)
1616 continue;
1617
1618 /* Note that we've changed the relocs, section contents, etc. */
1619 elf_section_data (sec)->relocs = internal_relocs;
1620 free_relocs = NULL;
1621
1622 elf_section_data (sec)->this_hdr.contents = contents;
1623 free_contents = NULL;
1624
1625 symtab_hdr->contents = (bfd_byte *) extsyms;
1626 free_extsyms = NULL;
1627
1628 /* Fix the opcode. */
1629 if (code == 0xdc)
1630 bfd_put_8 (abfd, 0xcc, contents + irel->r_offset - 1);
1631 else if (code == 0xdd)
1632 bfd_put_8 (abfd, 0xcd, contents + irel->r_offset - 1);
1633 else if (code == 0xff)
1634 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
1635
1636 /* Fix the relocation's type. */
1637 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1638 R_MN10300_PCREL16);
1639
1640 /* Delete two bytes of data. */
1641 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
1642 irel->r_offset + 1, 2))
1643 goto error_return;
1644
1645 /* That will change things, so, we should relax again.
1646 Note that this is not required, and it may be slow. */
1647 *again = true;
1648 }
1649 }
1650
1651 /* Try to turn a 16bit pc-relative branch into a 8bit pc-relative
1652 branch. */
1653 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL16)
1654 {
1655 bfd_vma value = symval;
1656
1657 /* If we've got a "call" instruction that needs to be turned
1658 into a "calls" instruction, do so now. It saves a byte. */
1659 if (h && (h->flags & MN10300_CONVERT_CALL_TO_CALLS))
1660 {
1661 unsigned char code;
1662
1663 /* Get the opcode. */
1664 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1665
1666 /* Make sure we're working with a "call" instruction! */
1667 if (code == 0xcd)
1668 {
1669 /* Note that we've changed the relocs, section contents,
1670 etc. */
1671 elf_section_data (sec)->relocs = internal_relocs;
1672 free_relocs = NULL;
1673
1674 elf_section_data (sec)->this_hdr.contents = contents;
1675 free_contents = NULL;
1676
1677 symtab_hdr->contents = (bfd_byte *) extsyms;
1678 free_extsyms = NULL;
1679
1680 /* Fix the opcode. */
1681 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 1);
1682 bfd_put_8 (abfd, 0xff, contents + irel->r_offset);
1683
1684 /* Fix irel->r_offset and irel->r_addend. */
1685 irel->r_offset += 1;
1686 irel->r_addend += 1;
1687
1688 /* Delete one byte of data. */
1689 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
1690 irel->r_offset + 1, 1))
1691 goto error_return;
1692
1693 /* That will change things, so, we should relax again.
1694 Note that this is not required, and it may be slow. */
1695 *again = true;
1696 }
1697 }
1698 else if (h)
1699 {
1700 unsigned char code;
1701
1702 /* Get the opcode. */
1703 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1704
1705 /* Insert data from the target function into the "call"
1706 instruction if needed. */
1707 if (code == 0xcd)
1708 {
1709 bfd_put_8 (abfd, h->movm_args, contents + irel->r_offset + 2);
1710 bfd_put_8 (abfd, h->stack_size + h->movm_stack_size,
1711 contents + irel->r_offset + 3);
1712 }
1713 }
1714
1715 /* Deal with pc-relative gunk. */
1716 value -= (sec->output_section->vma + sec->output_offset);
1717 value -= irel->r_offset;
1718 value += irel->r_addend;
1719
1720 /* See if the value will fit in 8 bits, note the high value is
1721 0x7f + 1 as the target will be one bytes closer if we are
1722 able to relax. */
1723 if ((long)value < 0x80 && (long)value > -0x80)
1724 {
1725 unsigned char code;
1726
1727 /* Get the opcode. */
1728 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1729
1730 if (code != 0xcc)
1731 continue;
1732
1733 /* Note that we've changed the relocs, section contents, etc. */
1734 elf_section_data (sec)->relocs = internal_relocs;
1735 free_relocs = NULL;
1736
1737 elf_section_data (sec)->this_hdr.contents = contents;
1738 free_contents = NULL;
1739
1740 symtab_hdr->contents = (bfd_byte *) extsyms;
1741 free_extsyms = NULL;
1742
1743 /* Fix the opcode. */
1744 bfd_put_8 (abfd, 0xca, contents + irel->r_offset - 1);
1745
1746 /* Fix the relocation's type. */
1747 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1748 R_MN10300_PCREL8);
1749
1750 /* Delete one byte of data. */
1751 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
1752 irel->r_offset + 1, 1))
1753 goto error_return;
1754
1755 /* That will change things, so, we should relax again.
1756 Note that this is not required, and it may be slow. */
1757 *again = true;
1758 }
1759 }
1760
1761 /* Try to eliminate an unconditional 8 bit pc-relative branch
1762 which immediately follows a conditional 8 bit pc-relative
1763 branch around the unconditional branch.
1764
1765 original: new:
1766 bCC lab1 bCC' lab2
1767 bra lab2
1768 lab1: lab1:
1769
1770
1771 This happens when the bCC can't reach lab2 at assembly time,
1772 but due to other relaxations it can reach at link time. */
1773 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL8)
1774 {
1775 Elf_Internal_Rela *nrel;
1776 bfd_vma value = symval;
1777 unsigned char code;
1778
1779 /* Deal with pc-relative gunk. */
1780 value -= (sec->output_section->vma + sec->output_offset);
1781 value -= irel->r_offset;
1782 value += irel->r_addend;
1783
1784 /* Do nothing if this reloc is the last byte in the section. */
1785 if (irel->r_offset == sec->_cooked_size)
1786 continue;
1787
1788 /* See if the next instruction is an unconditional pc-relative
1789 branch, more often than not this test will fail, so we
1790 test it first to speed things up. */
1791 code = bfd_get_8 (abfd, contents + irel->r_offset + 1);
1792 if (code != 0xca)
1793 continue;
1794
1795 /* Also make sure the next relocation applies to the next
1796 instruction and that it's a pc-relative 8 bit branch. */
1797 nrel = irel + 1;
1798 if (nrel == irelend
1799 || irel->r_offset + 2 != nrel->r_offset
1800 || ELF32_R_TYPE (nrel->r_info) != (int) R_MN10300_PCREL8)
1801 continue;
1802
1803 /* Make sure our destination immediately follows the
1804 unconditional branch. */
1805 if (symval != (sec->output_section->vma + sec->output_offset
1806 + irel->r_offset + 3))
1807 continue;
1808
1809 /* Now make sure we are a conditional branch. This may not
1810 be necessary, but why take the chance.
1811
1812 Note these checks assume that R_MN10300_PCREL8 relocs
1813 only occur on bCC and bCCx insns. If they occured
1814 elsewhere, we'd need to know the start of this insn
1815 for this check to be accurate. */
1816 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1817 if (code != 0xc0 && code != 0xc1 && code != 0xc2
1818 && code != 0xc3 && code != 0xc4 && code != 0xc5
1819 && code != 0xc6 && code != 0xc7 && code != 0xc8
1820 && code != 0xc9 && code != 0xe8 && code != 0xe9
1821 && code != 0xea && code != 0xeb)
1822 continue;
1823
1824 /* We also have to be sure there is no symbol/label
1825 at the unconditional branch. */
1826 if (mn10300_elf_symbol_address_p (abfd, sec, extsyms,
1827 irel->r_offset + 1))
1828 continue;
1829
1830 /* Note that we've changed the relocs, section contents, etc. */
1831 elf_section_data (sec)->relocs = internal_relocs;
1832 free_relocs = NULL;
1833
1834 elf_section_data (sec)->this_hdr.contents = contents;
1835 free_contents = NULL;
1836
1837 symtab_hdr->contents = (bfd_byte *) extsyms;
1838 free_extsyms = NULL;
1839
1840 /* Reverse the condition of the first branch. */
1841 switch (code)
1842 {
1843 case 0xc8:
1844 code = 0xc9;
1845 break;
1846 case 0xc9:
1847 code = 0xc8;
1848 break;
1849 case 0xc0:
1850 code = 0xc2;
1851 break;
1852 case 0xc2:
1853 code = 0xc0;
1854 break;
1855 case 0xc3:
1856 code = 0xc1;
1857 break;
1858 case 0xc1:
1859 code = 0xc3;
1860 break;
1861 case 0xc4:
1862 code = 0xc6;
1863 break;
1864 case 0xc6:
1865 code = 0xc4;
1866 break;
1867 case 0xc7:
1868 code = 0xc5;
1869 break;
1870 case 0xc5:
1871 code = 0xc7;
1872 break;
1873 case 0xe8:
1874 code = 0xe9;
1875 break;
1876 case 0x9d:
1877 code = 0xe8;
1878 break;
1879 case 0xea:
1880 code = 0xeb;
1881 break;
1882 case 0xeb:
1883 code = 0xea;
1884 break;
1885 }
1886 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
1887
1888 /* Set the reloc type and symbol for the first branch
1889 from the second branch. */
1890 irel->r_info = nrel->r_info;
1891
1892 /* Make the reloc for the second branch a null reloc. */
1893 nrel->r_info = ELF32_R_INFO (ELF32_R_SYM (nrel->r_info),
1894 R_MN10300_NONE);
1895
1896 /* Delete two bytes of data. */
1897 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
1898 irel->r_offset + 1, 2))
1899 goto error_return;
1900
1901 /* That will change things, so, we should relax again.
1902 Note that this is not required, and it may be slow. */
1903 *again = true;
1904 }
1905
1906
1907 /* Try to turn a 32bit immediate, displacement or absolute address
1908 into a 16bit immediate, displacement or absolute address. */
1909 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_32)
1910 {
1911 bfd_vma value = symval;
1912 value += irel->r_addend;
1913
1914
1915 /* See if the value will fit in 16 bits.
1916 We allow any 16bit match here. We prune those we can't
1917 handle below. */
1918 if ((long)value < 0x7fff && (long)value > -0x8000)
1919 {
1920 unsigned char code;
1921
1922 /* Most insns which have 32bit operands are 6 bytes long;
1923 exceptions are pcrel insns and bit insns.
1924
1925 We handle pcrel insns above. We don't bother trying
1926 to handle the bit insns here.
1927
1928 The first byte of the remaining insns will be 0xfc. */
1929
1930 /* Get the first opcode. */
1931 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
1932
1933 if (code != 0xfc)
1934 continue;
1935
1936 /* Get the second opcode. */
1937 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
1938
1939 if ((code & 0xf0) < 0x80)
1940 switch (code & 0xf0)
1941 {
1942 /* mov (d32,am),dn -> mov (d32,am),dn
1943 mov dm,(d32,am) -> mov dn,(d32,am)
1944 mov (d32,am),an -> mov (d32,am),an
1945 mov dm,(d32,am) -> mov dn,(d32,am)
1946 movbu (d32,am),dn -> movbu (d32,am),dn
1947 movbu dm,(d32,am) -> movbu dn,(d32,am)
1948 movhu (d32,am),dn -> movhu (d32,am),dn
1949 movhu dm,(d32,am) -> movhu dn,(d32,am) */
1950 case 0x00:
1951 case 0x10:
1952 case 0x20:
1953 case 0x30:
1954 case 0x40:
1955 case 0x50:
1956 case 0x60:
1957 case 0x70:
1958 /* Not safe if the high bit is on as relaxing may
1959 move the value out of high mem and thus not fit
1960 in a signed 16bit value. */
1961 if (code == 0xcc
1962 && (value & 0x8000))
1963 continue;
1964
1965 /* Note that we've changed the relocation contents, etc. */
1966 elf_section_data (sec)->relocs = internal_relocs;
1967 free_relocs = NULL;
1968
1969 elf_section_data (sec)->this_hdr.contents = contents;
1970 free_contents = NULL;
1971
1972 symtab_hdr->contents = (bfd_byte *) extsyms;
1973 free_extsyms = NULL;
1974
1975 /* Fix the opcode. */
1976 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
1977 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
1978
1979 /* Fix the relocation's type. */
1980 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1981 R_MN10300_16);
1982
1983 /* Delete two bytes of data. */
1984 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
1985 irel->r_offset + 2, 2))
1986 goto error_return;
1987
1988 /* That will change things, so, we should relax again.
1989 Note that this is not required, and it may be slow. */
1990 *again = true;
1991 break;
1992 }
1993 else if ((code & 0xf0) == 0x80
1994 || (code & 0xf0) == 0x90)
1995 switch (code & 0xf3)
1996 {
1997 /* mov dn,(abs32) -> mov dn,(abs16)
1998 movbu dn,(abs32) -> movbu dn,(abs16)
1999 movhu dn,(abs32) -> movhu dn,(abs16) */
2000 case 0x81:
2001 case 0x82:
2002 case 0x83:
2003 /* Note that we've changed the relocation contents, etc. */
2004 elf_section_data (sec)->relocs = internal_relocs;
2005 free_relocs = NULL;
2006
2007 elf_section_data (sec)->this_hdr.contents = contents;
2008 free_contents = NULL;
2009
2010 symtab_hdr->contents = (bfd_byte *) extsyms;
2011 free_extsyms = NULL;
2012
2013 if ((code & 0xf3) == 0x81)
2014 code = 0x01 + (code & 0x0c);
2015 else if ((code & 0xf3) == 0x82)
2016 code = 0x02 + (code & 0x0c);
2017 else if ((code & 0xf3) == 0x83)
2018 code = 0x03 + (code & 0x0c);
2019 else
2020 abort ();
2021
2022 /* Fix the opcode. */
2023 bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
2024
2025 /* Fix the relocation's type. */
2026 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2027 R_MN10300_16);
2028
2029 /* The opcode got shorter too, so we have to fix the
2030 addend and offset too! */
2031 irel->r_offset -= 1;
2032
2033 /* Delete three bytes of data. */
2034 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2035 irel->r_offset + 1, 3))
2036 goto error_return;
2037
2038 /* That will change things, so, we should relax again.
2039 Note that this is not required, and it may be slow. */
2040 *again = true;
2041 break;
2042
2043 /* mov am,(abs32) -> mov am,(abs16)
2044 mov am,(d32,sp) -> mov am,(d16,sp)
2045 mov dm,(d32,sp) -> mov dm,(d32,sp)
2046 movbu dm,(d32,sp) -> movbu dm,(d32,sp)
2047 movhu dm,(d32,sp) -> movhu dm,(d32,sp) */
2048 case 0x80:
2049 case 0x90:
2050 case 0x91:
2051 case 0x92:
2052 case 0x93:
2053 /* Note that we've changed the relocation contents, etc. */
2054 elf_section_data (sec)->relocs = internal_relocs;
2055 free_relocs = NULL;
2056
2057 elf_section_data (sec)->this_hdr.contents = contents;
2058 free_contents = NULL;
2059
2060 symtab_hdr->contents = (bfd_byte *) extsyms;
2061 free_extsyms = NULL;
2062
2063 /* Fix the opcode. */
2064 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
2065 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
2066
2067 /* Fix the relocation's type. */
2068 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2069 R_MN10300_16);
2070
2071 /* Delete two bytes of data. */
2072 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2073 irel->r_offset + 2, 2))
2074 goto error_return;
2075
2076 /* That will change things, so, we should relax again.
2077 Note that this is not required, and it may be slow. */
2078 *again = true;
2079 break;
2080 }
2081 else if ((code & 0xf0) < 0xf0)
2082 switch (code & 0xfc)
2083 {
2084 /* mov imm32,dn -> mov imm16,dn
2085 mov imm32,an -> mov imm16,an
2086 mov (abs32),dn -> mov (abs16),dn
2087 movbu (abs32),dn -> movbu (abs16),dn
2088 movhu (abs32),dn -> movhu (abs16),dn */
2089 case 0xcc:
2090 case 0xdc:
2091 case 0xa4:
2092 case 0xa8:
2093 case 0xac:
2094 /* Not safe if the high bit is on as relaxing may
2095 move the value out of high mem and thus not fit
2096 in a signed 16bit value. */
2097 if (code == 0xcc
2098 && (value & 0x8000))
2099 continue;
2100
2101 /* Note that we've changed the relocation contents, etc. */
2102 elf_section_data (sec)->relocs = internal_relocs;
2103 free_relocs = NULL;
2104
2105 elf_section_data (sec)->this_hdr.contents = contents;
2106 free_contents = NULL;
2107
2108 symtab_hdr->contents = (bfd_byte *) extsyms;
2109 free_extsyms = NULL;
2110
2111 if ((code & 0xfc) == 0xcc)
2112 code = 0x2c + (code & 0x03);
2113 else if ((code & 0xfc) == 0xdc)
2114 code = 0x24 + (code & 0x03);
2115 else if ((code & 0xfc) == 0xa4)
2116 code = 0x30 + (code & 0x03);
2117 else if ((code & 0xfc) == 0xa8)
2118 code = 0x34 + (code & 0x03);
2119 else if ((code & 0xfc) == 0xac)
2120 code = 0x38 + (code & 0x03);
2121 else
2122 abort ();
2123
2124 /* Fix the opcode. */
2125 bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
2126
2127 /* Fix the relocation's type. */
2128 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2129 R_MN10300_16);
2130
2131 /* The opcode got shorter too, so we have to fix the
2132 addend and offset too! */
2133 irel->r_offset -= 1;
2134
2135 /* Delete three bytes of data. */
2136 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2137 irel->r_offset + 1, 3))
2138 goto error_return;
2139
2140 /* That will change things, so, we should relax again.
2141 Note that this is not required, and it may be slow. */
2142 *again = true;
2143 break;
2144
2145 /* mov (abs32),an -> mov (abs16),an
2146 mov (d32,sp),an -> mov (d32,sp),an
2147 mov (d32,sp),dn -> mov (d32,sp),dn
2148 movbu (d32,sp),dn -> movbu (d32,sp),dn
2149 movhu (d32,sp),dn -> movhu (d32,sp),dn
2150 add imm32,dn -> add imm16,dn
2151 cmp imm32,dn -> cmp imm16,dn
2152 add imm32,an -> add imm16,an
2153 cmp imm32,an -> cmp imm16,an
2154 and imm32,dn -> and imm32,dn
2155 or imm32,dn -> or imm32,dn
2156 xor imm32,dn -> xor imm32,dn
2157 btst imm32,dn -> btst imm32,dn */
2158
2159 case 0xa0:
2160 case 0xb0:
2161 case 0xb1:
2162 case 0xb2:
2163 case 0xb3:
2164 case 0xc0:
2165 case 0xc8:
2166
2167 case 0xd0:
2168 case 0xd8:
2169 case 0xe0:
2170 case 0xe1:
2171 case 0xe2:
2172 case 0xe3:
2173 /* Note that we've changed the relocation contents, etc. */
2174 elf_section_data (sec)->relocs = internal_relocs;
2175 free_relocs = NULL;
2176
2177 elf_section_data (sec)->this_hdr.contents = contents;
2178 free_contents = NULL;
2179
2180 symtab_hdr->contents = (bfd_byte *) extsyms;
2181 free_extsyms = NULL;
2182
2183 /* Fix the opcode. */
2184 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
2185 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
2186
2187 /* Fix the relocation's type. */
2188 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2189 R_MN10300_16);
2190
2191 /* Delete two bytes of data. */
2192 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2193 irel->r_offset + 2, 2))
2194 goto error_return;
2195
2196 /* That will change things, so, we should relax again.
2197 Note that this is not required, and it may be slow. */
2198 *again = true;
2199 break;
2200 }
2201 else if (code == 0xfe)
2202 {
2203 /* add imm32,sp -> add imm16,sp */
2204
2205 /* Note that we've changed the relocation contents, etc. */
2206 elf_section_data (sec)->relocs = internal_relocs;
2207 free_relocs = NULL;
2208
2209 elf_section_data (sec)->this_hdr.contents = contents;
2210 free_contents = NULL;
2211
2212 symtab_hdr->contents = (bfd_byte *) extsyms;
2213 free_extsyms = NULL;
2214
2215 /* Fix the opcode. */
2216 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
2217 bfd_put_8 (abfd, 0xfe, contents + irel->r_offset - 1);
2218
2219 /* Fix the relocation's type. */
2220 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2221 R_MN10300_16);
2222
2223 /* Delete two bytes of data. */
2224 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2225 irel->r_offset + 2, 2))
2226 goto error_return;
2227
2228 /* That will change things, so, we should relax again.
2229 Note that this is not required, and it may be slow. */
2230 *again = true;
2231 break;
2232 }
2233 }
2234 }
2235 }
2236
2237 if (free_relocs != NULL)
2238 {
2239 free (free_relocs);
2240 free_relocs = NULL;
2241 }
2242
2243 if (free_contents != NULL)
2244 {
2245 if (! link_info->keep_memory)
2246 free (free_contents);
2247 else
2248 {
2249 /* Cache the section contents for elf_link_input_bfd. */
2250 elf_section_data (sec)->this_hdr.contents = contents;
2251 }
2252 free_contents = NULL;
2253 }
2254
2255 if (free_extsyms != NULL)
2256 {
2257 if (! link_info->keep_memory)
2258 free (free_extsyms);
2259 else
2260 {
2261 /* Cache the symbols for elf_link_input_bfd. */
2262 symtab_hdr->contents = extsyms;
2263 }
2264 free_extsyms = NULL;
2265 }
2266
2267 return true;
2268
2269 error_return:
2270 if (free_relocs != NULL)
2271 free (free_relocs);
2272 if (free_contents != NULL)
2273 free (free_contents);
2274 if (free_extsyms != NULL)
2275 free (free_extsyms);
2276 return false;
2277 }
2278
2279 /* Compute the stack size and movm arguments for the function
2280 referred to by HASH at address ADDR in section with
2281 contents CONTENTS, store the information in the hash table. */
2282 static void
2283 compute_function_info (abfd, hash, addr, contents)
2284 bfd *abfd;
2285 struct elf32_mn10300_link_hash_entry *hash;
2286 bfd_vma addr;
2287 unsigned char *contents;
2288 {
2289 unsigned char byte1, byte2;
2290 /* We only care about a very small subset of the possible prologue
2291 sequences here. Basically we look for:
2292
2293 movm [d2,d3,a2,a3],sp (optional)
2294 add <size>,sp (optional, and only for sizes which fit in an unsigned
2295 8 bit number)
2296
2297 If we find anything else, we quit. */
2298
2299 /* Look for movm [regs],sp */
2300 byte1 = bfd_get_8 (abfd, contents + addr);
2301 byte2 = bfd_get_8 (abfd, contents + addr + 1);
2302
2303 if (byte1 == 0xcf)
2304 {
2305 hash->movm_args = byte2;
2306 addr += 2;
2307 byte1 = bfd_get_8 (abfd, contents + addr);
2308 byte2 = bfd_get_8 (abfd, contents + addr + 1);
2309 }
2310
2311 /* Now figure out how much stack space will be allocated by the movm
2312 instruction. We need this kept separate from the funtion's normal
2313 stack space. */
2314 if (hash->movm_args)
2315 {
2316 /* Space for d2. */
2317 if (hash->movm_args & 0x80)
2318 hash->movm_stack_size += 4;
2319
2320 /* Space for d3. */
2321 if (hash->movm_args & 0x40)
2322 hash->movm_stack_size += 4;
2323
2324 /* Space for a2. */
2325 if (hash->movm_args & 0x20)
2326 hash->movm_stack_size += 4;
2327
2328 /* Space for a3. */
2329 if (hash->movm_args & 0x10)
2330 hash->movm_stack_size += 4;
2331
2332 /* "other" space. d0, d1, a0, a1, mdr, lir, lar, 4 byte pad. */
2333 if (hash->movm_args & 0x08)
2334 hash->movm_stack_size += 8 * 4;
2335
2336 }
2337
2338 /* Now look for the two stack adjustment variants. */
2339 if (byte1 == 0xf8 && byte2 == 0xfe)
2340 {
2341 int temp = bfd_get_8 (abfd, contents + addr + 2);
2342 temp = ((temp & 0xff) ^ (~0x7f)) + 0x80;
2343
2344 hash->stack_size = -temp;
2345 }
2346 else if (byte1 == 0xfa && byte2 == 0xfe)
2347 {
2348 int temp = bfd_get_16 (abfd, contents + addr + 2);
2349 temp = ((temp & 0xffff) ^ (~0x7fff)) + 0x8000;
2350 temp = -temp;
2351
2352 if (temp < 255)
2353 hash->stack_size = temp;
2354 }
2355
2356 /* If the total stack to be allocated by the call instruction is more
2357 than 255 bytes, then we can't remove the stack adjustment by using
2358 "call" (we might still be able to remove the "movm" instruction. */
2359 if (hash->stack_size + hash->movm_stack_size > 255)
2360 hash->stack_size = 0;
2361
2362 return;
2363 }
2364
2365 /* Delete some bytes from a section while relaxing. */
2366
2367 static boolean
2368 mn10300_elf_relax_delete_bytes (abfd, sec, addr, count)
2369 bfd *abfd;
2370 asection *sec;
2371 bfd_vma addr;
2372 int count;
2373 {
2374 Elf_Internal_Shdr *symtab_hdr;
2375 Elf32_External_Sym *extsyms;
2376 int shndx, index;
2377 bfd_byte *contents;
2378 Elf_Internal_Rela *irel, *irelend;
2379 Elf_Internal_Rela *irelalign;
2380 bfd_vma toaddr;
2381 Elf32_External_Sym *esym, *esymend;
2382 struct elf32_mn10300_link_hash_entry *sym_hash;
2383
2384 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2385 extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
2386
2387 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
2388
2389 contents = elf_section_data (sec)->this_hdr.contents;
2390
2391 /* The deletion must stop at the next ALIGN reloc for an aligment
2392 power larger than the number of bytes we are deleting. */
2393
2394 irelalign = NULL;
2395 toaddr = sec->_cooked_size;
2396
2397 irel = elf_section_data (sec)->relocs;
2398 irelend = irel + sec->reloc_count;
2399
2400 /* Actually delete the bytes. */
2401 memmove (contents + addr, contents + addr + count, toaddr - addr - count);
2402 sec->_cooked_size -= count;
2403
2404 /* Adjust all the relocs. */
2405 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
2406 {
2407 /* Get the new reloc address. */
2408 if ((irel->r_offset > addr
2409 && irel->r_offset < toaddr))
2410 irel->r_offset -= count;
2411 }
2412
2413 /* Adjust the local symbols defined in this section. */
2414 esym = extsyms;
2415 esymend = esym + symtab_hdr->sh_info;
2416 for (; esym < esymend; esym++)
2417 {
2418 Elf_Internal_Sym isym;
2419
2420 bfd_elf32_swap_symbol_in (abfd, esym, &isym);
2421
2422 if (isym.st_shndx == shndx
2423 && isym.st_value > addr
2424 && isym.st_value < toaddr)
2425 {
2426 isym.st_value -= count;
2427 bfd_elf32_swap_symbol_out (abfd, &isym, esym);
2428 }
2429 }
2430
2431 /* Now adjust the global symbols defined in this section. */
2432 esym = extsyms + symtab_hdr->sh_info;
2433 esymend = extsyms + (symtab_hdr->sh_size / sizeof (Elf32_External_Sym));
2434 for (index = 0; esym < esymend; esym++, index++)
2435 {
2436 Elf_Internal_Sym isym;
2437
2438 bfd_elf32_swap_symbol_in (abfd, esym, &isym);
2439 sym_hash = (struct elf32_mn10300_link_hash_entry *)
2440 (elf_sym_hashes (abfd)[index]);
2441 if (isym.st_shndx == shndx
2442 && ((sym_hash)->root.root.type == bfd_link_hash_defined
2443 || (sym_hash)->root.root.type == bfd_link_hash_defweak)
2444 && (sym_hash)->root.root.u.def.section == sec
2445 && (sym_hash)->root.root.u.def.value > addr
2446 && (sym_hash)->root.root.u.def.value < toaddr)
2447 {
2448 (sym_hash)->root.root.u.def.value -= count;
2449 }
2450 }
2451
2452 return true;
2453 }
2454
2455 /* Return true if a symbol exists at the given address, else return
2456 false. */
2457 static boolean
2458 mn10300_elf_symbol_address_p (abfd, sec, extsyms, addr)
2459 bfd *abfd;
2460 asection *sec;
2461 Elf32_External_Sym *extsyms;
2462 bfd_vma addr;
2463 {
2464 Elf_Internal_Shdr *symtab_hdr;
2465 int shndx;
2466 Elf32_External_Sym *esym, *esymend;
2467 struct elf32_mn10300_link_hash_entry **sym_hash, **sym_hash_end;
2468
2469 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2470 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
2471
2472 /* Examine all the symbols. */
2473 esym = extsyms;
2474 esymend = esym + symtab_hdr->sh_info;
2475 for (; esym < esymend; esym++)
2476 {
2477 Elf_Internal_Sym isym;
2478
2479 bfd_elf32_swap_symbol_in (abfd, esym, &isym);
2480
2481 if (isym.st_shndx == shndx
2482 && isym.st_value == addr)
2483 return true;
2484 }
2485
2486 sym_hash = (struct elf32_mn10300_link_hash_entry **)(elf_sym_hashes (abfd));
2487 sym_hash_end = (sym_hash
2488 + (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
2489 - symtab_hdr->sh_info));
2490 for (; sym_hash < sym_hash_end; sym_hash++)
2491 {
2492 if (((*sym_hash)->root.root.type == bfd_link_hash_defined
2493 || (*sym_hash)->root.root.type == bfd_link_hash_defweak)
2494 && (*sym_hash)->root.root.u.def.section == sec
2495 && (*sym_hash)->root.root.u.def.value == addr)
2496 return true;
2497 }
2498 return false;
2499 }
2500
2501 /* This is a version of bfd_generic_get_relocated_section_contents
2502 which uses mn10300_elf_relocate_section. */
2503
2504 static bfd_byte *
2505 mn10300_elf_get_relocated_section_contents (output_bfd, link_info, link_order,
2506 data, relocateable, symbols)
2507 bfd *output_bfd;
2508 struct bfd_link_info *link_info;
2509 struct bfd_link_order *link_order;
2510 bfd_byte *data;
2511 boolean relocateable;
2512 asymbol **symbols;
2513 {
2514 Elf_Internal_Shdr *symtab_hdr;
2515 asection *input_section = link_order->u.indirect.section;
2516 bfd *input_bfd = input_section->owner;
2517 asection **sections = NULL;
2518 Elf_Internal_Rela *internal_relocs = NULL;
2519 Elf32_External_Sym *external_syms = NULL;
2520 Elf_Internal_Sym *internal_syms = NULL;
2521
2522 /* We only need to handle the case of relaxing, or of having a
2523 particular set of section contents, specially. */
2524 if (relocateable
2525 || elf_section_data (input_section)->this_hdr.contents == NULL)
2526 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
2527 link_order, data,
2528 relocateable,
2529 symbols);
2530
2531 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2532
2533 memcpy (data, elf_section_data (input_section)->this_hdr.contents,
2534 input_section->_raw_size);
2535
2536 if ((input_section->flags & SEC_RELOC) != 0
2537 && input_section->reloc_count > 0)
2538 {
2539 Elf_Internal_Sym *isymp;
2540 asection **secpp;
2541 Elf32_External_Sym *esym, *esymend;
2542
2543 if (symtab_hdr->contents != NULL)
2544 external_syms = (Elf32_External_Sym *) symtab_hdr->contents;
2545 else
2546 {
2547 external_syms = ((Elf32_External_Sym *)
2548 bfd_malloc (symtab_hdr->sh_info
2549 * sizeof (Elf32_External_Sym)));
2550 if (external_syms == NULL && symtab_hdr->sh_info > 0)
2551 goto error_return;
2552 if (bfd_seek (input_bfd, symtab_hdr->sh_offset, SEEK_SET) != 0
2553 || (bfd_read (external_syms, sizeof (Elf32_External_Sym),
2554 symtab_hdr->sh_info, input_bfd)
2555 != (symtab_hdr->sh_info * sizeof (Elf32_External_Sym))))
2556 goto error_return;
2557 }
2558
2559 internal_relocs = (_bfd_elf32_link_read_relocs
2560 (input_bfd, input_section, (PTR) NULL,
2561 (Elf_Internal_Rela *) NULL, false));
2562 if (internal_relocs == NULL)
2563 goto error_return;
2564
2565 internal_syms = ((Elf_Internal_Sym *)
2566 bfd_malloc (symtab_hdr->sh_info
2567 * sizeof (Elf_Internal_Sym)));
2568 if (internal_syms == NULL && symtab_hdr->sh_info > 0)
2569 goto error_return;
2570
2571 sections = (asection **) bfd_malloc (symtab_hdr->sh_info
2572 * sizeof (asection *));
2573 if (sections == NULL && symtab_hdr->sh_info > 0)
2574 goto error_return;
2575
2576 isymp = internal_syms;
2577 secpp = sections;
2578 esym = external_syms;
2579 esymend = esym + symtab_hdr->sh_info;
2580 for (; esym < esymend; ++esym, ++isymp, ++secpp)
2581 {
2582 asection *isec;
2583
2584 bfd_elf32_swap_symbol_in (input_bfd, esym, isymp);
2585
2586 if (isymp->st_shndx == SHN_UNDEF)
2587 isec = bfd_und_section_ptr;
2588 else if (isymp->st_shndx > 0 && isymp->st_shndx < SHN_LORESERVE)
2589 isec = bfd_section_from_elf_index (input_bfd, isymp->st_shndx);
2590 else if (isymp->st_shndx == SHN_ABS)
2591 isec = bfd_abs_section_ptr;
2592 else if (isymp->st_shndx == SHN_COMMON)
2593 isec = bfd_com_section_ptr;
2594 else
2595 {
2596 /* Who knows? */
2597 isec = NULL;
2598 }
2599
2600 *secpp = isec;
2601 }
2602
2603 if (! mn10300_elf_relocate_section (output_bfd, link_info, input_bfd,
2604 input_section, data, internal_relocs,
2605 internal_syms, sections))
2606 goto error_return;
2607
2608 if (sections != NULL)
2609 free (sections);
2610 sections = NULL;
2611 if (internal_syms != NULL)
2612 free (internal_syms);
2613 internal_syms = NULL;
2614 if (external_syms != NULL && symtab_hdr->contents == NULL)
2615 free (external_syms);
2616 external_syms = NULL;
2617 if (internal_relocs != elf_section_data (input_section)->relocs)
2618 free (internal_relocs);
2619 internal_relocs = NULL;
2620 }
2621
2622 return data;
2623
2624 error_return:
2625 if (internal_relocs != NULL
2626 && internal_relocs != elf_section_data (input_section)->relocs)
2627 free (internal_relocs);
2628 if (external_syms != NULL && symtab_hdr->contents == NULL)
2629 free (external_syms);
2630 if (internal_syms != NULL)
2631 free (internal_syms);
2632 if (sections != NULL)
2633 free (sections);
2634 return NULL;
2635 }
2636
2637 /* Assorted hash table functions. */
2638
2639 /* Initialize an entry in the link hash table. */
2640
2641 /* Create an entry in an MN10300 ELF linker hash table. */
2642
2643 static struct bfd_hash_entry *
2644 elf32_mn10300_link_hash_newfunc (entry, table, string)
2645 struct bfd_hash_entry *entry;
2646 struct bfd_hash_table *table;
2647 const char *string;
2648 {
2649 struct elf32_mn10300_link_hash_entry *ret =
2650 (struct elf32_mn10300_link_hash_entry *) entry;
2651
2652 /* Allocate the structure if it has not already been allocated by a
2653 subclass. */
2654 if (ret == (struct elf32_mn10300_link_hash_entry *) NULL)
2655 ret = ((struct elf32_mn10300_link_hash_entry *)
2656 bfd_hash_allocate (table,
2657 sizeof (struct elf32_mn10300_link_hash_entry)));
2658 if (ret == (struct elf32_mn10300_link_hash_entry *) NULL)
2659 return (struct bfd_hash_entry *) ret;
2660
2661 /* Call the allocation method of the superclass. */
2662 ret = ((struct elf32_mn10300_link_hash_entry *)
2663 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
2664 table, string));
2665 if (ret != (struct elf32_mn10300_link_hash_entry *) NULL)
2666 {
2667 ret->direct_calls = 0;
2668 ret->stack_size = 0;
2669 ret->movm_stack_size = 0;
2670 ret->flags = 0;
2671 ret->movm_args = 0;
2672 }
2673
2674 return (struct bfd_hash_entry *) ret;
2675 }
2676
2677 /* Create an mn10300 ELF linker hash table. */
2678
2679 static struct bfd_link_hash_table *
2680 elf32_mn10300_link_hash_table_create (abfd)
2681 bfd *abfd;
2682 {
2683 struct elf32_mn10300_link_hash_table *ret;
2684
2685 ret = ((struct elf32_mn10300_link_hash_table *)
2686 bfd_alloc (abfd, sizeof (struct elf32_mn10300_link_hash_table)));
2687 if (ret == (struct elf32_mn10300_link_hash_table *) NULL)
2688 return NULL;
2689
2690 if (! _bfd_elf_link_hash_table_init (&ret->root, abfd,
2691 elf32_mn10300_link_hash_newfunc))
2692 {
2693 bfd_release (abfd, ret);
2694 return NULL;
2695 }
2696
2697 ret->flags = 0;
2698 ret->static_hash_table
2699 = ((struct elf32_mn10300_link_hash_table *)
2700 bfd_alloc (abfd, sizeof (struct elf_link_hash_table)));
2701 if (ret->static_hash_table == NULL)
2702 {
2703 bfd_release (abfd, ret);
2704 return NULL;
2705 }
2706
2707 if (! _bfd_elf_link_hash_table_init (&ret->static_hash_table->root, abfd,
2708 elf32_mn10300_link_hash_newfunc))
2709 {
2710 bfd_release (abfd, ret->static_hash_table);
2711 bfd_release (abfd, ret);
2712 return NULL;
2713 }
2714 return &ret->root.root;
2715 }
2716
2717 static int
2718 elf_mn10300_mach (flags)
2719 flagword flags;
2720 {
2721 switch (flags & EF_MN10300_MACH)
2722 {
2723 case E_MN10300_MACH_MN10300:
2724 default:
2725 return bfd_mach_mn10300;
2726
2727 }
2728 }
2729
2730 /* The final processing done just before writing out a MN10300 ELF object
2731 file. This gets the MN10300 architecture right based on the machine
2732 number. */
2733
2734 /*ARGSUSED*/
2735 void
2736 _bfd_mn10300_elf_final_write_processing (abfd, linker)
2737 bfd *abfd;
2738 boolean linker ATTRIBUTE_UNUSED;
2739 {
2740 unsigned long val;
2741
2742 switch (bfd_get_mach (abfd))
2743 {
2744 default:
2745 case bfd_mach_mn10300:
2746 val = E_MN10300_MACH_MN10300;
2747 break;
2748
2749 }
2750
2751 elf_elfheader (abfd)->e_flags &= ~ (EF_MN10300_MACH);
2752 elf_elfheader (abfd)->e_flags |= val;
2753 }
2754
2755 boolean
2756 _bfd_mn10300_elf_object_p (abfd)
2757 bfd *abfd;
2758 {
2759 bfd_default_set_arch_mach (abfd, bfd_arch_mn10300,
2760 elf_mn10300_mach (elf_elfheader (abfd)->e_flags));
2761 return true;
2762 }
2763
2764 /* Merge backend specific data from an object file to the output
2765 object file when linking. */
2766
2767 boolean
2768 _bfd_mn10300_elf_merge_private_bfd_data (ibfd, obfd)
2769 bfd *ibfd;
2770 bfd *obfd;
2771 {
2772 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2773 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2774 return true;
2775
2776 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
2777 && bfd_get_mach (obfd) < bfd_get_mach (ibfd))
2778 {
2779 if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
2780 bfd_get_mach (ibfd)))
2781 return false;
2782 }
2783
2784 return true;
2785 }
2786
2787
2788 #define TARGET_LITTLE_SYM bfd_elf32_mn10300_vec
2789 #define TARGET_LITTLE_NAME "elf32-mn10300"
2790 #define ELF_ARCH bfd_arch_mn10300
2791 #define ELF_MACHINE_CODE EM_CYGNUS_MN10300
2792 #define ELF_MAXPAGESIZE 0x1000
2793
2794 #define elf_info_to_howto mn10300_info_to_howto
2795 #define elf_info_to_howto_rel 0
2796 #define elf_backend_can_gc_sections 1
2797 #define elf_backend_check_relocs mn10300_elf_check_relocs
2798 #define elf_backend_gc_mark_hook mn10300_elf_gc_mark_hook
2799 #define elf_backend_relocate_section mn10300_elf_relocate_section
2800 #define bfd_elf32_bfd_relax_section mn10300_elf_relax_section
2801 #define bfd_elf32_bfd_get_relocated_section_contents \
2802 mn10300_elf_get_relocated_section_contents
2803 #define bfd_elf32_bfd_link_hash_table_create \
2804 elf32_mn10300_link_hash_table_create
2805
2806 #define elf_symbol_leading_char '_'
2807
2808 /* So we can set bits in e_flags. */
2809 #define elf_backend_final_write_processing \
2810 _bfd_mn10300_elf_final_write_processing
2811 #define elf_backend_object_p _bfd_mn10300_elf_object_p
2812
2813 #define bfd_elf32_bfd_merge_private_bfd_data \
2814 _bfd_mn10300_elf_merge_private_bfd_data
2815
2816
2817 #include "elf32-target.h"
git-cvsimport of binutils cvsroot