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