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