1 /* Morpho Technologies MT specific support for 32-bit ELF
2 Copyright (C) 2001-2014 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 3 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,
19 MA 02111-1307, USA. */
20
21 #include "sysdep.h"
22 #include "bfd.h"
23 #include "libbfd.h"
24 #include "elf-bfd.h"
25 #include "elf/mt.h"
26
27 /* Prototypes. */
28 static reloc_howto_type * mt_reloc_type_lookup
29 (bfd *, bfd_reloc_code_real_type);
30
31 static void mt_info_to_howto_rela
32 (bfd *, arelent *, Elf_Internal_Rela *);
33
34 static bfd_reloc_status_type mt_elf_relocate_hi16
35 (bfd *, Elf_Internal_Rela *, bfd_byte *, bfd_vma);
36
37 static bfd_reloc_status_type mt_final_link_relocate
38 (reloc_howto_type *, bfd *, asection *, bfd_byte *,
39 Elf_Internal_Rela *, bfd_vma);
40
41 static bfd_boolean mt_elf_relocate_section
42 (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
43 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **);
44
45 /* Relocation tables. */
46 static reloc_howto_type mt_elf_howto_table [] =
47 {
48 /* This reloc does nothing. */
49 HOWTO (R_MT_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_MT_NONE", /* name */
58 FALSE, /* partial_inplace */
59 0 , /* src_mask */
60 0, /* dst_mask */
61 FALSE), /* pcrel_offset */
62
63 /* A 16 bit absolute relocation. */
64 HOWTO (R_MT_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_MT_16", /* name */
73 FALSE, /* partial_inplace */
74 0 , /* src_mask */
75 0xffff, /* dst_mask */
76 FALSE), /* pcrel_offset */
77
78 /* A 32 bit absolute relocation. */
79 HOWTO (R_MT_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_MT_32", /* name */
88 FALSE, /* partial_inplace */
89 0 , /* src_mask */
90 0xffffffff, /* dst_mask */
91 FALSE), /* pcrel_offset */
92
93 /* A 32 bit pc-relative relocation. */
94 HOWTO (R_MT_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_MT_32_PCREL", /* name */
103 FALSE, /* partial_inplace */
104 0 , /* src_mask */
105 0xffffffff, /* dst_mask */
106 TRUE), /* pcrel_offset */
107
108 /* A 16 bit pc-relative relocation. */
109 HOWTO (R_MT_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_MT_PC16", /* name */
118 FALSE, /* partial_inplace */
119 0, /* src_mask */
120 0xffff, /* dst_mask */
121 TRUE), /* pcrel_offset */
122
123 /* high 16 bits of symbol value. */
124 HOWTO (R_MT_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_MT_HI16", /* name */
133 FALSE, /* partial_inplace */
134 0xffff0000, /* src_mask */
135 0xffff0000, /* dst_mask */
136 FALSE), /* pcrel_offset */
137
138 /* Low 16 bits of symbol value. */
139 HOWTO (R_MT_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_MT_LO16", /* name */
148 FALSE, /* partial_inplace */
149 0xffff, /* src_mask */
150 0xffff, /* dst_mask */
151 FALSE), /* pcrel_offset */
152 };
153
154 /* Map BFD reloc types to MT ELF reloc types. */
155
156 static reloc_howto_type *
mt_reloc_type_lookup(bfd * abfd ATTRIBUTE_UNUSED,bfd_reloc_code_real_type code)157 mt_reloc_type_lookup
158 (bfd * abfd ATTRIBUTE_UNUSED,
159 bfd_reloc_code_real_type code)
160 {
161 /* Note that the mt_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/mt.h. */
165
166 switch (code)
167 {
168 case BFD_RELOC_NONE:
169 return &mt_elf_howto_table[ (int) R_MT_NONE];
170 case BFD_RELOC_16:
171 return &mt_elf_howto_table[ (int) R_MT_16];
172 case BFD_RELOC_32:
173 return &mt_elf_howto_table[ (int) R_MT_32];
174 case BFD_RELOC_32_PCREL:
175 return &mt_elf_howto_table[ (int) R_MT_32_PCREL];
176 case BFD_RELOC_16_PCREL:
177 return &mt_elf_howto_table[ (int) R_MT_PC16];
178 case BFD_RELOC_HI16:
179 return &mt_elf_howto_table[ (int) R_MT_HI16];
180 case BFD_RELOC_LO16:
181 return &mt_elf_howto_table[ (int) R_MT_LO16];
182
183 default:
184 /* Pacify gcc -Wall. */
185 return NULL;
186 }
187 return NULL;
188 }
189
190 static reloc_howto_type *
mt_reloc_name_lookup(bfd * abfd ATTRIBUTE_UNUSED,const char * r_name)191 mt_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
192 const char *r_name)
193 {
194 unsigned int i;
195
196 for (i = 0;
197 i < sizeof (mt_elf_howto_table) / sizeof (mt_elf_howto_table[0]);
198 i++)
199 if (mt_elf_howto_table[i].name != NULL
200 && strcasecmp (mt_elf_howto_table[i].name, r_name) == 0)
201 return &mt_elf_howto_table[i];
202
203 return NULL;
204 }
205
206 bfd_reloc_status_type
mt_elf_relocate_hi16(bfd * input_bfd,Elf_Internal_Rela * relhi,bfd_byte * contents,bfd_vma value)207 mt_elf_relocate_hi16
208 (bfd * input_bfd,
209 Elf_Internal_Rela * relhi,
210 bfd_byte * contents,
211 bfd_vma value)
212 {
213 bfd_vma insn;
214
215 insn = bfd_get_32 (input_bfd, contents + relhi->r_offset);
216
217 value += relhi->r_addend;
218 value >>= 16;
219 insn = ((insn & ~0xFFFF) | value);
220
221 bfd_put_32 (input_bfd, insn, contents + relhi->r_offset);
222 return bfd_reloc_ok;
223 }
224
225 /* XXX: The following code is the result of a cut&paste. This unfortunate
226 practice is very widespread in the various target back-end files. */
227
228 /* Set the howto pointer for a MT ELF reloc. */
229
230 static void
mt_info_to_howto_rela(bfd * abfd ATTRIBUTE_UNUSED,arelent * cache_ptr,Elf_Internal_Rela * dst)231 mt_info_to_howto_rela
232 (bfd * abfd ATTRIBUTE_UNUSED,
233 arelent * cache_ptr,
234 Elf_Internal_Rela * dst)
235 {
236 unsigned int r_type;
237
238 r_type = ELF32_R_TYPE (dst->r_info);
239 cache_ptr->howto = & mt_elf_howto_table [r_type];
240 }
241
242 /* Perform a single relocation. By default we use the standard BFD
243 routines. */
244
245 static bfd_reloc_status_type
mt_final_link_relocate(reloc_howto_type * howto,bfd * input_bfd,asection * input_section,bfd_byte * contents,Elf_Internal_Rela * rel,bfd_vma relocation)246 mt_final_link_relocate
247 (reloc_howto_type * howto,
248 bfd * input_bfd,
249 asection * input_section,
250 bfd_byte * contents,
251 Elf_Internal_Rela * rel,
252 bfd_vma relocation)
253 {
254 return _bfd_final_link_relocate (howto, input_bfd, input_section,
255 contents, rel->r_offset,
256 relocation, rel->r_addend);
257 }
258
259 /* Relocate a MT ELF section.
260 There is some attempt to make this function usable for many architectures,
261 both USE_REL and USE_RELA ['twould be nice if such a critter existed],
262 if only to serve as a learning tool.
263
264 The RELOCATE_SECTION function is called by the new ELF backend linker
265 to handle the relocations for a section.
266
267 The relocs are always passed as Rela structures; if the section
268 actually uses Rel structures, the r_addend field will always be
269 zero.
270
271 This function is responsible for adjusting the section contents as
272 necessary, and (if using Rela relocs and generating a relocatable
273 output file) adjusting the reloc addend as necessary.
274
275 This function does not have to worry about setting the reloc
276 address or the reloc symbol index.
277
278 LOCAL_SYMS is a pointer to the swapped in local symbols.
279
280 LOCAL_SECTIONS is an array giving the section in the input file
281 corresponding to the st_shndx field of each local symbol.
282
283 The global hash table entry for the global symbols can be found
284 via elf_sym_hashes (input_bfd).
285
286 When generating relocatable output, this function must handle
287 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
288 going to be the section symbol corresponding to the output
289 section, which means that the addend must be adjusted
290 accordingly. */
291
292 static bfd_boolean
mt_elf_relocate_section(bfd * output_bfd ATTRIBUTE_UNUSED,struct bfd_link_info * info,bfd * input_bfd,asection * input_section,bfd_byte * contents,Elf_Internal_Rela * relocs,Elf_Internal_Sym * local_syms,asection ** local_sections)293 mt_elf_relocate_section
294 (bfd * output_bfd ATTRIBUTE_UNUSED,
295 struct bfd_link_info * info,
296 bfd * input_bfd,
297 asection * input_section,
298 bfd_byte * contents,
299 Elf_Internal_Rela * relocs,
300 Elf_Internal_Sym * local_syms,
301 asection ** local_sections)
302 {
303 Elf_Internal_Shdr * symtab_hdr;
304 struct elf_link_hash_entry ** sym_hashes;
305 Elf_Internal_Rela * rel;
306 Elf_Internal_Rela * relend;
307
308 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
309 sym_hashes = elf_sym_hashes (input_bfd);
310 relend = relocs + input_section->reloc_count;
311
312 for (rel = relocs; rel < relend; rel ++)
313 {
314 reloc_howto_type * howto;
315 unsigned long r_symndx;
316 Elf_Internal_Sym * sym;
317 asection * sec;
318 struct elf_link_hash_entry * h;
319 bfd_vma relocation;
320 bfd_reloc_status_type r;
321 const char * name = NULL;
322 int r_type;
323
324 r_type = ELF32_R_TYPE (rel->r_info);
325
326 r_symndx = ELF32_R_SYM (rel->r_info);
327
328 howto = mt_elf_howto_table + ELF32_R_TYPE (rel->r_info);
329 h = NULL;
330 sym = NULL;
331 sec = NULL;
332
333 if (r_symndx < symtab_hdr->sh_info)
334 {
335 sym = local_syms + r_symndx;
336 sec = local_sections [r_symndx];
337 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
338
339 name = bfd_elf_string_from_elf_section
340 (input_bfd, symtab_hdr->sh_link, sym->st_name);
341 name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
342 }
343 else
344 {
345 bfd_boolean unresolved_reloc;
346 bfd_boolean warned, ignored;
347
348 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
349 r_symndx, symtab_hdr, sym_hashes,
350 h, sec, relocation,
351 unresolved_reloc, warned, ignored);
352
353 name = h->root.root.string;
354 }
355
356 if (sec != NULL && discarded_section (sec))
357 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
358 rel, 1, relend, howto, 0, contents);
359
360 if (info->relocatable)
361 continue;
362
363 /* Finally, the sole MT-specific part. */
364 switch (r_type)
365 {
366 case R_MT_HI16:
367 r = mt_elf_relocate_hi16 (input_bfd, rel, contents, relocation);
368 break;
369 default:
370 r = mt_final_link_relocate (howto, input_bfd, input_section,
371 contents, rel, relocation);
372 break;
373 }
374
375
376 if (r != bfd_reloc_ok)
377 {
378 const char * msg = (const char *) NULL;
379
380 switch (r)
381 {
382 case bfd_reloc_overflow:
383 r = info->callbacks->reloc_overflow
384 (info, (h ? &h->root : NULL), name, howto->name, (bfd_vma) 0,
385 input_bfd, input_section, rel->r_offset);
386 break;
387
388 case bfd_reloc_undefined:
389 r = info->callbacks->undefined_symbol
390 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
391 break;
392
393 case bfd_reloc_outofrange:
394 msg = _("internal error: out of range error");
395 break;
396
397 case bfd_reloc_dangerous:
398 msg = _("internal error: dangerous relocation");
399 break;
400
401 default:
402 msg = _("internal error: unknown error");
403 break;
404 }
405
406 if (msg)
407 r = info->callbacks->warning
408 (info, msg, name, input_bfd, input_section, rel->r_offset);
409
410 if (! r)
411 return FALSE;
412 }
413 }
414
415 return TRUE;
416 }
417
418 /* Look through the relocs for a section during the first phase.
419 Since we don't do .gots or .plts, we just need to consider the
420 virtual table relocs for gc. */
421
422 static bfd_boolean
mt_elf_check_relocs(bfd * abfd,struct bfd_link_info * info,asection * sec,const Elf_Internal_Rela * relocs)423 mt_elf_check_relocs
424 (bfd * abfd,
425 struct bfd_link_info * info,
426 asection * sec,
427 const Elf_Internal_Rela * relocs)
428 {
429 Elf_Internal_Shdr * symtab_hdr;
430 struct elf_link_hash_entry ** sym_hashes;
431 const Elf_Internal_Rela * rel;
432 const Elf_Internal_Rela * rel_end;
433
434 if (info->relocatable)
435 return TRUE;
436
437 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
438 sym_hashes = elf_sym_hashes (abfd);
439
440 rel_end = relocs + sec->reloc_count;
441 for (rel = relocs; rel < rel_end; rel++)
442 {
443 struct elf_link_hash_entry *h;
444 unsigned long r_symndx;
445
446 r_symndx = ELF32_R_SYM (rel->r_info);
447 if (r_symndx < symtab_hdr->sh_info)
448 h = NULL;
449 else
450 {
451 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
452 while (h->root.type == bfd_link_hash_indirect
453 || h->root.type == bfd_link_hash_warning)
454 h = (struct elf_link_hash_entry *) h->root.u.i.link;
455
456 /* PR15323, ref flags aren't set for references in the same
457 object. */
458 h->root.non_ir_ref = 1;
459 }
460 }
461
462 return TRUE;
463 }
464
465 /* Return the MACH for an e_flags value. */
466
467 static int
elf32_mt_machine(bfd * abfd)468 elf32_mt_machine (bfd *abfd)
469 {
470 switch (elf_elfheader (abfd)->e_flags & EF_MT_CPU_MASK)
471 {
472 case EF_MT_CPU_MRISC: return bfd_mach_ms1;
473 case EF_MT_CPU_MRISC2: return bfd_mach_mrisc2;
474 case EF_MT_CPU_MS2: return bfd_mach_ms2;
475 }
476
477 return bfd_mach_ms1;
478 }
479
480 static bfd_boolean
mt_elf_object_p(bfd * abfd)481 mt_elf_object_p (bfd * abfd)
482 {
483 bfd_default_set_arch_mach (abfd, bfd_arch_mt, elf32_mt_machine (abfd));
484
485 return TRUE;
486 }
487
488 /* Function to set the ELF flag bits. */
489
490 static bfd_boolean
mt_elf_set_private_flags(bfd * abfd,flagword flags)491 mt_elf_set_private_flags (bfd * abfd,
492 flagword flags)
493 {
494 elf_elfheader (abfd)->e_flags = flags;
495 elf_flags_init (abfd) = TRUE;
496 return TRUE;
497 }
498
499 /* Merge backend specific data from an object file to the output
500 object file when linking. */
501
502 static bfd_boolean
mt_elf_merge_private_bfd_data(bfd * ibfd,bfd * obfd)503 mt_elf_merge_private_bfd_data (bfd * ibfd, bfd * obfd)
504 {
505 flagword old_flags, new_flags;
506 bfd_boolean ok = TRUE;
507
508 /* Check if we have the same endianness. */
509 if (_bfd_generic_verify_endian_match (ibfd, obfd) == FALSE)
510 return FALSE;
511
512 /* If they're not both mt, then merging is meaningless, so just
513 don't do it. */
514 if (strcmp (ibfd->arch_info->arch_name, "mt") != 0)
515 return TRUE;
516 if (strcmp (obfd->arch_info->arch_name, "mt") != 0)
517 return TRUE;
518
519 new_flags = elf_elfheader (ibfd)->e_flags;
520 old_flags = elf_elfheader (obfd)->e_flags;
521
522 #ifdef DEBUG
523 _bfd_error_handler ("%B: old_flags = 0x%.8lx, new_flags = 0x%.8lx, init = %s",
524 ibfd, old_flags, new_flags, elf_flags_init (obfd) ? "yes" : "no");
525 #endif
526
527 if (!elf_flags_init (obfd))
528 {
529 old_flags = new_flags;
530 elf_flags_init (obfd) = TRUE;
531 }
532 else if ((new_flags & EF_MT_CPU_MASK) != (old_flags & EF_MT_CPU_MASK))
533 {
534 /* CPU has changed. This is invalid, because MRISC, MRISC2 and
535 MS2 are not subsets of each other. */
536 ok = FALSE;
537 }
538
539 if (ok)
540 {
541 obfd->arch_info = ibfd->arch_info;
542 elf_elfheader (obfd)->e_flags = old_flags;
543 }
544
545 return ok;
546 }
547
548 static bfd_boolean
mt_elf_print_private_bfd_data(bfd * abfd,void * ptr)549 mt_elf_print_private_bfd_data (bfd * abfd, void * ptr)
550 {
551 FILE * file = (FILE *) ptr;
552 flagword flags;
553
554 BFD_ASSERT (abfd != NULL && ptr != NULL);
555
556 /* Print normal ELF private data. */
557 _bfd_elf_print_private_bfd_data (abfd, ptr);
558
559 flags = elf_elfheader (abfd)->e_flags;
560 fprintf (file, _("private flags = 0x%lx:"), (unsigned long) flags);
561
562 switch (flags & EF_MT_CPU_MASK)
563 {
564 default:
565 case EF_MT_CPU_MRISC: fprintf (file, " ms1-16-002"); break;
566 case EF_MT_CPU_MRISC2: fprintf (file, " ms1-16-003"); break;
567 case EF_MT_CPU_MS2: fprintf (file, " ms2"); break;
568 }
569
570 fputc ('\n', file);
571
572 return TRUE;
573 }
574
575
576 #define TARGET_BIG_SYM mt_elf32_vec
577 #define TARGET_BIG_NAME "elf32-mt"
578
579 #define ELF_ARCH bfd_arch_mt
580 #define ELF_MACHINE_CODE EM_MT
581 #define ELF_MAXPAGESIZE 1 /* No pages on the MT. */
582
583 #define elf_info_to_howto_rel NULL
584 #define elf_info_to_howto mt_info_to_howto_rela
585
586 #define elf_backend_relocate_section mt_elf_relocate_section
587
588 #define bfd_elf32_bfd_reloc_type_lookup mt_reloc_type_lookup
589 #define bfd_elf32_bfd_reloc_name_lookup mt_reloc_name_lookup
590
591 #define elf_backend_check_relocs mt_elf_check_relocs
592 #define elf_backend_object_p mt_elf_object_p
593 #define elf_backend_rela_normal 1
594
595 #define elf_backend_can_gc_sections 1
596
597 #define bfd_elf32_bfd_set_private_flags mt_elf_set_private_flags
598 #define bfd_elf32_bfd_merge_private_bfd_data mt_elf_merge_private_bfd_data
599 #define bfd_elf32_bfd_print_private_bfd_data mt_elf_print_private_bfd_data
600
601 #include "elf32-target.h"
602