2005-09-08 Paul Brook <paul@codesourcery.com>
[binutils.git] / bfd / elf32-ms1.c
blob51841e512454e2e92b749c4e9bc0dca08e1001da
1 /* Morpho Technologies MS1 specific support for 32-bit ELF
2 Copyright 2001, 2002, 2003, 2004, 2005
3 Free Software Foundation, Inc.
5 This file is part of BFD, the Binary File Descriptor library.
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.
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.
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. */
21 #include "bfd.h"
22 #include "sysdep.h"
23 #include "libbfd.h"
24 #include "elf-bfd.h"
25 #include "elf/ms1.h"
27 /* Prototypes. */
28 static reloc_howto_type * ms1_reloc_type_lookup
29 (bfd *, bfd_reloc_code_real_type);
31 static void ms1_info_to_howto_rela
32 (bfd *, arelent *, Elf_Internal_Rela *);
34 static bfd_reloc_status_type ms1_elf_relocate_hi16
35 (bfd *, Elf_Internal_Rela *, bfd_byte *, bfd_vma);
37 static bfd_reloc_status_type ms1_final_link_relocate
38 (reloc_howto_type *, bfd *, asection *, bfd_byte *,
39 Elf_Internal_Rela *, bfd_vma);
41 static bfd_boolean ms1_elf_relocate_section
42 (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
43 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **);
45 /* Relocation tables. */
46 static reloc_howto_type ms1_elf_howto_table [] =
48 /* This reloc does nothing. */
49 HOWTO (R_MS1_NONE, /* type */
50 0, /* rightshift */
51 2, /* size (0 = byte, 1 = short, 2 = long) */
52 32, /* bitsize */
53 FALSE, /* pc_relative */
54 0, /* bitpos */
55 complain_overflow_dont, /* complain_on_overflow */
56 bfd_elf_generic_reloc, /* special_function */
57 "R_MS1_NONE", /* name */
58 FALSE, /* partial_inplace */
59 0 , /* src_mask */
60 0, /* dst_mask */
61 FALSE), /* pcrel_offset */
63 /* A 16 bit absolute relocation. */
64 HOWTO (R_MS1_16, /* type */
65 0, /* rightshift */
66 2, /* size (0 = byte, 1 = short, 2 = long) */
67 16, /* bitsize */
68 FALSE, /* pc_relative */
69 0, /* bitpos */
70 complain_overflow_dont, /* complain_on_overflow */
71 bfd_elf_generic_reloc, /* special_function */
72 "R_MS1_16", /* name */
73 FALSE, /* partial_inplace */
74 0 , /* src_mask */
75 0xffff, /* dst_mask */
76 FALSE), /* pcrel_offset */
78 /* A 32 bit absolute relocation. */
79 HOWTO (R_MS1_32, /* type */
80 0, /* rightshift */
81 2, /* size (0 = byte, 1 = short, 2 = long) */
82 32, /* bitsize */
83 FALSE, /* pc_relative */
84 0, /* bitpos */
85 complain_overflow_dont, /* complain_on_overflow */
86 bfd_elf_generic_reloc, /* special_function */
87 "R_MS1_32", /* name */
88 FALSE, /* partial_inplace */
89 0 , /* src_mask */
90 0xffffffff, /* dst_mask */
91 FALSE), /* pcrel_offset */
93 /* A 32 bit pc-relative relocation. */
94 HOWTO (R_MS1_32_PCREL, /* type */
95 0, /* rightshift */
96 2, /* size (0 = byte, 1 = short, 2 = long) */
97 32, /* bitsize */
98 TRUE, /* pc_relative */
99 0, /* bitpos */
100 complain_overflow_dont, /* complain_on_overflow */
101 bfd_elf_generic_reloc, /* special_function */
102 "R_MS1_32_PCREL", /* name */
103 FALSE, /* partial_inplace */
104 0 , /* src_mask */
105 0xffffffff, /* dst_mask */
106 TRUE), /* pcrel_offset */
108 /* A 16 bit pc-relative relocation. */
109 HOWTO (R_MS1_PC16, /* type */
110 0, /* rightshift */
111 2, /* size (0 = byte, 1 = short, 2 = long) */
112 16, /* bitsize */
113 TRUE, /* pc_relative */
114 0, /* bitpos */
115 complain_overflow_signed, /* complain_on_overflow */
116 bfd_elf_generic_reloc, /* special_function */
117 "R_MS1_PC16", /* name */
118 FALSE, /* partial_inplace */
119 0, /* src_mask */
120 0xffff, /* dst_mask */
121 TRUE), /* pcrel_offset */
123 /* high 16 bits of symbol value. */
124 HOWTO (R_MS1_HI16, /* type */
125 0, /* rightshift */
126 2, /* size (0 = byte, 1 = short, 2 = long) */
127 16, /* bitsize */
128 FALSE, /* pc_relative */
129 0, /* bitpos */
130 complain_overflow_dont, /* complain_on_overflow */
131 bfd_elf_generic_reloc, /* special_function */
132 "R_MS1_HI16", /* name */
133 FALSE, /* partial_inplace */
134 0xffff0000, /* src_mask */
135 0xffff0000, /* dst_mask */
136 FALSE), /* pcrel_offset */
138 /* Low 16 bits of symbol value. */
139 HOWTO (R_MS1_LO16, /* type */
140 0, /* rightshift */
141 2, /* size (0 = byte, 1 = short, 2 = long) */
142 16, /* bitsize */
143 FALSE, /* pc_relative */
144 0, /* bitpos */
145 complain_overflow_dont, /* complain_on_overflow */
146 bfd_elf_generic_reloc, /* special_function */
147 "R_MS1_LO16", /* name */
148 FALSE, /* partial_inplace */
149 0xffff, /* src_mask */
150 0xffff, /* dst_mask */
151 FALSE), /* pcrel_offset */
154 /* Map BFD reloc types to MS1 ELF reloc types. */
156 static reloc_howto_type *
157 ms1_reloc_type_lookup
158 (bfd * abfd ATTRIBUTE_UNUSED,
159 bfd_reloc_code_real_type code)
161 /* Note that the ms1_elf_howto_table is indxed by the R_
162 constants. Thus, the order that the howto records appear in the
163 table *must* match the order of the relocation types defined in
164 include/elf/ms1.h. */
166 switch (code)
168 case BFD_RELOC_NONE:
169 return &ms1_elf_howto_table[ (int) R_MS1_NONE];
170 case BFD_RELOC_16:
171 return &ms1_elf_howto_table[ (int) R_MS1_16];
172 case BFD_RELOC_32:
173 return &ms1_elf_howto_table[ (int) R_MS1_32];
174 case BFD_RELOC_32_PCREL:
175 return &ms1_elf_howto_table[ (int) R_MS1_32_PCREL];
176 case BFD_RELOC_16_PCREL:
177 return &ms1_elf_howto_table[ (int) R_MS1_PC16];
178 case BFD_RELOC_HI16:
179 return &ms1_elf_howto_table[ (int) R_MS1_HI16];
180 case BFD_RELOC_LO16:
181 return &ms1_elf_howto_table[ (int) R_MS1_LO16];
183 default:
184 /* Pacify gcc -Wall. */
185 return NULL;
187 return NULL;
190 bfd_reloc_status_type
191 ms1_elf_relocate_hi16
192 (bfd * input_bfd,
193 Elf_Internal_Rela * relhi,
194 bfd_byte * contents,
195 bfd_vma value)
197 bfd_vma insn;
199 insn = bfd_get_32 (input_bfd, contents + relhi->r_offset);
201 value += relhi->r_addend;
202 value >>= 16;
203 insn = ((insn & ~0xFFFF) | value);
205 bfd_put_32 (input_bfd, insn, contents + relhi->r_offset);
206 return bfd_reloc_ok;
209 /* XXX: The following code is the result of a cut&paste. This unfortunate
210 practice is very widespread in the various target back-end files. */
212 /* Set the howto pointer for a MS1 ELF reloc. */
214 static void
215 ms1_info_to_howto_rela
216 (bfd * abfd ATTRIBUTE_UNUSED,
217 arelent * cache_ptr,
218 Elf_Internal_Rela * dst)
220 unsigned int r_type;
222 r_type = ELF32_R_TYPE (dst->r_info);
223 cache_ptr->howto = & ms1_elf_howto_table [r_type];
226 /* Perform a single relocation. By default we use the standard BFD
227 routines. */
229 static bfd_reloc_status_type
230 ms1_final_link_relocate
231 (reloc_howto_type * howto,
232 bfd * input_bfd,
233 asection * input_section,
234 bfd_byte * contents,
235 Elf_Internal_Rela * rel,
236 bfd_vma relocation)
238 return _bfd_final_link_relocate (howto, input_bfd, input_section,
239 contents, rel->r_offset,
240 relocation, rel->r_addend);
243 /* Relocate a MS1 ELF section.
244 There is some attempt to make this function usable for many architectures,
245 both USE_REL and USE_RELA ['twould be nice if such a critter existed],
246 if only to serve as a learning tool.
248 The RELOCATE_SECTION function is called by the new ELF backend linker
249 to handle the relocations for a section.
251 The relocs are always passed as Rela structures; if the section
252 actually uses Rel structures, the r_addend field will always be
253 zero.
255 This function is responsible for adjusting the section contents as
256 necessary, and (if using Rela relocs and generating a relocatable
257 output file) adjusting the reloc addend as necessary.
259 This function does not have to worry about setting the reloc
260 address or the reloc symbol index.
262 LOCAL_SYMS is a pointer to the swapped in local symbols.
264 LOCAL_SECTIONS is an array giving the section in the input file
265 corresponding to the st_shndx field of each local symbol.
267 The global hash table entry for the global symbols can be found
268 via elf_sym_hashes (input_bfd).
270 When generating relocatable output, this function must handle
271 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
272 going to be the section symbol corresponding to the output
273 section, which means that the addend must be adjusted
274 accordingly. */
276 static bfd_boolean
277 ms1_elf_relocate_section
278 (bfd * output_bfd ATTRIBUTE_UNUSED,
279 struct bfd_link_info * info,
280 bfd * input_bfd,
281 asection * input_section,
282 bfd_byte * contents,
283 Elf_Internal_Rela * relocs,
284 Elf_Internal_Sym * local_syms,
285 asection ** local_sections)
287 Elf_Internal_Shdr * symtab_hdr;
288 struct elf_link_hash_entry ** sym_hashes;
289 Elf_Internal_Rela * rel;
290 Elf_Internal_Rela * relend;
292 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
293 sym_hashes = elf_sym_hashes (input_bfd);
294 relend = relocs + input_section->reloc_count;
296 for (rel = relocs; rel < relend; rel ++)
298 reloc_howto_type * howto;
299 unsigned long r_symndx;
300 Elf_Internal_Sym * sym;
301 asection * sec;
302 struct elf_link_hash_entry * h;
303 bfd_vma relocation;
304 bfd_reloc_status_type r;
305 const char * name = NULL;
306 int r_type;
308 r_type = ELF32_R_TYPE (rel->r_info);
310 r_symndx = ELF32_R_SYM (rel->r_info);
312 /* This is a final link. */
313 howto = ms1_elf_howto_table + ELF32_R_TYPE (rel->r_info);
314 h = NULL;
315 sym = NULL;
316 sec = NULL;
318 if (r_symndx < symtab_hdr->sh_info)
320 sym = local_syms + r_symndx;
321 sec = local_sections [r_symndx];
322 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
324 name = bfd_elf_string_from_elf_section
325 (input_bfd, symtab_hdr->sh_link, sym->st_name);
326 name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
328 else
330 bfd_boolean unresolved_reloc;
331 bfd_boolean warned;
333 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
334 r_symndx, symtab_hdr, sym_hashes,
335 h, sec, relocation,
336 unresolved_reloc, warned);
338 name = h->root.root.string;
342 /* Finally, the sole MS1-specific part. */
343 switch (r_type)
345 case R_MS1_HI16:
346 r = ms1_elf_relocate_hi16 (input_bfd, rel, contents, relocation);
347 break;
348 default:
349 r = ms1_final_link_relocate (howto, input_bfd, input_section,
350 contents, rel, relocation);
351 break;
355 if (r != bfd_reloc_ok)
357 const char * msg = (const char *) NULL;
359 switch (r)
361 case bfd_reloc_overflow:
362 r = info->callbacks->reloc_overflow
363 (info, (h ? &h->root : NULL), name, howto->name, (bfd_vma) 0,
364 input_bfd, input_section, rel->r_offset);
365 break;
367 case bfd_reloc_undefined:
368 r = info->callbacks->undefined_symbol
369 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
370 break;
372 case bfd_reloc_outofrange:
373 msg = _("internal error: out of range error");
374 break;
376 case bfd_reloc_dangerous:
377 msg = _("internal error: dangerous relocation");
378 break;
380 default:
381 msg = _("internal error: unknown error");
382 break;
385 if (msg)
386 r = info->callbacks->warning
387 (info, msg, name, input_bfd, input_section, rel->r_offset);
389 if (! r)
390 return FALSE;
394 return TRUE;
397 /* Return the section that should be marked against GC for a given
398 relocation. */
400 static asection *
401 ms1_elf_gc_mark_hook
402 (asection * sec,
403 struct bfd_link_info * info ATTRIBUTE_UNUSED,
404 Elf_Internal_Rela * rel ATTRIBUTE_UNUSED,
405 struct elf_link_hash_entry * h,
406 Elf_Internal_Sym * sym)
408 if (h != NULL)
410 switch (h->root.type)
412 case bfd_link_hash_defined:
413 case bfd_link_hash_defweak:
414 return h->root.u.def.section;
416 case bfd_link_hash_common:
417 return h->root.u.c.p->section;
419 default:
420 break;
423 else
425 if (!(elf_bad_symtab (sec->owner)
426 && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
427 && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
428 && sym->st_shndx != SHN_COMMON))
429 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
432 return NULL;
435 /* Update the got entry reference counts for the section being
436 removed. */
438 static bfd_boolean
439 ms1_elf_gc_sweep_hook
440 (bfd * abfd ATTRIBUTE_UNUSED,
441 struct bfd_link_info * info ATTRIBUTE_UNUSED,
442 asection * sec ATTRIBUTE_UNUSED,
443 const Elf_Internal_Rela * relocs ATTRIBUTE_UNUSED)
445 return TRUE;
448 /* Look through the relocs for a section during the first phase.
449 Since we don't do .gots or .plts, we just need to consider the
450 virtual table relocs for gc. */
452 static bfd_boolean
453 ms1_elf_check_relocs
454 (bfd * abfd,
455 struct bfd_link_info * info,
456 asection * sec,
457 const Elf_Internal_Rela * relocs)
459 Elf_Internal_Shdr * symtab_hdr;
460 struct elf_link_hash_entry ** sym_hashes;
461 struct elf_link_hash_entry ** sym_hashes_end;
462 const Elf_Internal_Rela * rel;
463 const Elf_Internal_Rela * rel_end;
465 if (info->relocatable)
466 return TRUE;
468 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
469 sym_hashes = elf_sym_hashes (abfd);
470 sym_hashes_end = sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
471 if (!elf_bad_symtab (abfd))
472 sym_hashes_end -= symtab_hdr->sh_info;
474 rel_end = relocs + sec->reloc_count;
475 for (rel = relocs; rel < rel_end; rel++)
477 struct elf_link_hash_entry *h;
478 unsigned long r_symndx;
480 r_symndx = ELF32_R_SYM (rel->r_info);
481 if (r_symndx < symtab_hdr->sh_info)
482 h = NULL;
483 else
485 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
486 while (h->root.type == bfd_link_hash_indirect
487 || h->root.type == bfd_link_hash_warning)
488 h = (struct elf_link_hash_entry *) h->root.u.i.link;
492 return TRUE;
495 /* Return the MACH for an e_flags value. */
497 static int
498 elf32_ms1_machine (bfd *abfd)
500 switch (elf_elfheader (abfd)->e_flags & EF_MS1_CPU_MASK)
502 case EF_MS1_CPU_MRISC: return bfd_mach_ms1;
503 case EF_MS1_CPU_MRISC2: return bfd_mach_mrisc2;
506 return bfd_mach_ms1;
509 static bfd_boolean
510 ms1_elf_object_p (bfd * abfd)
512 bfd_default_set_arch_mach (abfd, bfd_arch_ms1, elf32_ms1_machine (abfd));
514 return TRUE;
517 /* Function to set the ELF flag bits. */
519 static bfd_boolean
520 ms1_elf_set_private_flags (bfd * abfd,
521 flagword flags)
523 elf_elfheader (abfd)->e_flags = flags;
524 elf_flags_init (abfd) = TRUE;
525 return TRUE;
528 static bfd_boolean
529 ms1_elf_copy_private_bfd_data (bfd * ibfd, bfd * obfd)
531 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
532 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
533 return TRUE;
535 BFD_ASSERT (!elf_flags_init (obfd)
536 || elf_elfheader (obfd)->e_flags == elf_elfheader (ibfd)->e_flags);
538 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
539 elf_flags_init (obfd) = TRUE;
540 return TRUE;
543 /* Merge backend specific data from an object file to the output
544 object file when linking. */
546 static bfd_boolean
547 ms1_elf_merge_private_bfd_data (bfd * ibfd, bfd * obfd)
549 flagword old_flags, new_flags;
550 bfd_boolean error = FALSE;
551 static bfd * last_ibfd = 0;
553 /* Check if we have the same endianess. */
554 if (_bfd_generic_verify_endian_match (ibfd, obfd) == FALSE)
555 return FALSE;
557 /* If they're not both ms1, then merging is meaningless, so just
558 don't do it. */
559 if (strcmp (ibfd->arch_info->arch_name, "ms1") != 0)
560 return TRUE;
561 if (strcmp (obfd->arch_info->arch_name, "ms1") != 0)
562 return TRUE;
564 new_flags = elf_elfheader (ibfd)->e_flags;
565 old_flags = elf_elfheader (obfd)->e_flags;
567 #ifdef DEBUG
568 _bfd_error_handler ("%B: old_flags = 0x%.8lx, new_flags = 0x%.8lx, init = %s",
569 ibfd, old_flags, new_flags, elf_flags_init (obfd) ? "yes" : "no");
570 #endif
572 elf_flags_init (obfd) = TRUE;
574 if ((new_flags & EF_MS1_CPU_MASK) == EF_MS1_CPU_MRISC2)
576 elf_elfheader (obfd)->e_flags = new_flags;
577 last_ibfd = ibfd;
578 obfd->arch_info = ibfd->arch_info;
581 return !error;
584 static bfd_boolean
585 ms1_elf_print_private_bfd_data (bfd * abfd, void * ptr)
587 FILE * file = (FILE *) ptr;
588 flagword flags;
590 BFD_ASSERT (abfd != NULL && ptr != NULL);
592 /* Print normal ELF private data. */
593 _bfd_elf_print_private_bfd_data (abfd, ptr);
595 flags = elf_elfheader (abfd)->e_flags;
596 fprintf (file, _("private flags = 0x%lx:"), (long)flags);
598 switch (flags & EF_MS1_CPU_MASK)
600 default:
601 case EF_MS1_CPU_MRISC: fprintf (file, " ms1-16-002"); break;
602 case EF_MS1_CPU_MRISC2: fprintf (file, " ms1-16-003"); break;
605 fputc ('\n', file);
607 return TRUE;
611 #define TARGET_BIG_SYM bfd_elf32_ms1_vec
612 #define TARGET_BIG_NAME "elf32-ms1"
614 #define ELF_ARCH bfd_arch_ms1
615 #define ELF_MACHINE_CODE EM_MS1
616 #define ELF_MAXPAGESIZE 1 /* No pages on the MS1. */
618 #define elf_info_to_howto_rel NULL
619 #define elf_info_to_howto ms1_info_to_howto_rela
621 #define elf_backend_relocate_section ms1_elf_relocate_section
623 #define bfd_elf32_bfd_reloc_type_lookup ms1_reloc_type_lookup
625 #define elf_backend_gc_mark_hook ms1_elf_gc_mark_hook
626 #define elf_backend_gc_sweep_hook ms1_elf_gc_sweep_hook
627 #define elf_backend_check_relocs ms1_elf_check_relocs
628 #define elf_backend_object_p ms1_elf_object_p
629 #define elf_backend_rela_normal 1
631 #define elf_backend_can_gc_sections 1
633 #define bfd_elf32_bfd_set_private_flags ms1_elf_set_private_flags
634 #define bfd_elf32_bfd_copy_private_bfd_data ms1_elf_copy_private_bfd_data
635 #define bfd_elf32_bfd_merge_private_bfd_data ms1_elf_merge_private_bfd_data
636 #define bfd_elf32_bfd_print_private_bfd_data ms1_elf_print_private_bfd_data
638 #include "elf32-target.h"