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