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