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