?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
daily update
[binutils.git] / bfd / elf32-openrisc.c
blobbd491cc804025eb0c29dfca76ef8f3db29677157
1 /* OpenRISC-specific support for 32-bit ELF.
2 Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007
3 Free Software Foundation, Inc.
4 Contributed by Johan Rydberg, jrydberg@opencores.org
5
6 This file is part of BFD, the Binary File Descriptor library.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301,
21 USA. */
22
23 #include "bfd.h"
24 #include "sysdep.h"
25 #include "libbfd.h"
26 #include "elf-bfd.h"
27 #include "elf/openrisc.h"
28 #include "libiberty.h"
29
30 static reloc_howto_type openrisc_elf_howto_table[] =
31 {
32 /* This reloc does nothing. */
33 HOWTO (R_OPENRISC_NONE, /* type */
34 0, /* rightshift */
35 2, /* size (0 = byte, 1 = short, 2 = long) */
36 32, /* bitsize */
37 FALSE, /* pc_relative */
38 0, /* bitpos */
39 complain_overflow_bitfield, /* complain_on_overflow */
40 bfd_elf_generic_reloc, /* special_function */
41 "R_OPENRISC_NONE", /* name */
42 FALSE, /* partial_inplace */
43 0, /* src_mask */
44 0, /* dst_mask */
45 FALSE), /* pcrel_offset */
46
47 /* A PC relative 26 bit relocation, right shifted by 2. */
48 HOWTO (R_OPENRISC_INSN_REL_26, /* type */
49 2, /* rightshift */
50 2, /* size (0 = byte, 1 = short, 2 = long) */
51 26, /* bitsize */
52 TRUE, /* pc_relative */
53 0, /* bitpos */
54 complain_overflow_signed, /* complain_on_overflow */
55 bfd_elf_generic_reloc, /* special_function */
56 "R_OPENRISC_INSN_REL_26", /* name */
57 FALSE, /* partial_inplace */
58 0x00000000, /* src_mask */
59 0x03ffffff, /* dst_mask */
60 FALSE), /* pcrel_offset */
61
62 /* A absolute 26 bit relocation, right shifted by 2. */
63 HOWTO (R_OPENRISC_INSN_ABS_26, /* type */
64 2, /* rightshift */
65 2, /* size (0 = byte, 1 = short, 2 = long) */
66 26, /* bitsize */
67 FALSE, /* pc_relative */
68 0, /* bitpos */
69 complain_overflow_signed, /* complain_on_overflow */
70 bfd_elf_generic_reloc, /* special_function */
71 "R_OPENRISC_INSN_ABS_26", /* name */
72 FALSE, /* partial_inplace */
73 0x00000000, /* src_mask */
74 0x03ffffff, /* dst_mask */
75 FALSE), /* pcrel_offset */
76
77 HOWTO (R_OPENRISC_LO_16_IN_INSN, /* type */
78 0, /* rightshift */
79 1, /* size (0 = byte, 1 = short, 2 = long) */
80 16, /* bitsize */
81 FALSE, /* pc_relative */
82 0, /* bitpos */
83 complain_overflow_dont, /* complain_on_overflow */
84 bfd_elf_generic_reloc, /* special_function */
85 "R_OPENRISC_LO_16_IN_INSN", /* name */
86 FALSE, /* partial_inplace */
87 0, /* src_mask */
88 0x0000ffff, /* dst_mask */
89 FALSE), /* pcrel_offset */
90
91 HOWTO (R_OPENRISC_HI_16_IN_INSN, /* type */
92 16, /* rightshift */
93 1, /* size (0 = byte, 1 = short, 2 = long) */
94 16, /* bitsize */
95 FALSE, /* pc_relative */
96 0, /* bitpos */
97 complain_overflow_dont, /* complain_on_overflow */
98 bfd_elf_generic_reloc, /* special_function */
99 "R_OPENRISC_HI_16_IN_INSN", /* name */
100 FALSE, /* partial_inplace */
101 0, /* src_mask */
102 0x0000ffff, /* dst_mask */
103 FALSE), /* pcrel_offset */
104
105 /* An 8 bit absolute relocation. */
106 HOWTO (R_OPENRISC_8, /* type */
107 0, /* rightshift */
108 0, /* size (0 = byte, 1 = short, 2 = long) */
109 8, /* bitsize */
110 FALSE, /* pc_relative */
111 0, /* bitpos */
112 complain_overflow_bitfield, /* complain_on_overflow */
113 bfd_elf_generic_reloc, /* special_function */
114 "R_OPENRISC_8", /* name */
115 TRUE, /* partial_inplace */
116 0x0000, /* src_mask */
117 0x00ff, /* dst_mask */
118 FALSE), /* pcrel_offset */
119
120 /* A 16 bit absolute relocation. */
121 HOWTO (R_OPENRISC_16, /* type */
122 0, /* rightshift */
123 1, /* size (0 = byte, 1 = short, 2 = long) */
124 16, /* bitsize */
125 FALSE, /* pc_relative */
126 0, /* bitpos */
127 complain_overflow_bitfield, /* complain_on_overflow */
128 bfd_elf_generic_reloc, /* special_function */
129 "R_OPENRISC_16", /* name */
130 TRUE, /* partial_inplace */
131 0x00000000, /* src_mask */
132 0x0000ffff, /* dst_mask */
133 FALSE), /* pcrel_offset */
134
135 /* A 32 bit absolute relocation. */
136 HOWTO (R_OPENRISC_32, /* type */
137 0, /* rightshift */
138 2, /* size (0 = byte, 1 = short, 2 = long) */
139 32, /* bitsize */
140 FALSE, /* pc_relative */
141 0, /* bitpos */
142 complain_overflow_bitfield, /* complain_on_overflow */
143 bfd_elf_generic_reloc, /* special_function */
144 "R_OPENRISC_32", /* name */
145 TRUE, /* partial_inplace */
146 0x00000000, /* src_mask */
147 0xffffffff, /* dst_mask */
148 FALSE), /* pcrel_offset */
149
150 /* GNU extension to record C++ vtable hierarchy. */
151 HOWTO (R_OPENRISC_GNU_VTINHERIT, /* type */
152 0, /* rightshift */
153 2, /* size (0 = byte, 1 = short, 2 = long) */
154 0, /* bitsize */
155 FALSE, /* pc_relative */
156 0, /* bitpos */
157 complain_overflow_dont, /* complain_on_overflow */
158 NULL, /* special_function */
159 "R_OPENRISC_GNU_VTINHERIT", /* name */
160 FALSE, /* partial_inplace */
161 0, /* src_mask */
162 0, /* dst_mask */
163 FALSE), /* pcrel_offset */
164
165 /* GNU extension to record C++ vtable member usage. */
166 HOWTO (R_OPENRISC_GNU_VTENTRY, /* type */
167 0, /* rightshift */
168 2, /* size (0 = byte, 1 = short, 2 = long) */
169 0, /* bitsize */
170 FALSE, /* pc_relative */
171 0, /* bitpos */
172 complain_overflow_dont, /* complain_on_overflow */
173 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
174 "R_OPENRISC_GNU_VTENTRY", /* name */
175 FALSE, /* partial_inplace */
176 0, /* src_mask */
177 0, /* dst_mask */
178 FALSE), /* pcrel_offset */
179 };
180
181 /* Map BFD reloc types to OpenRISC ELF reloc types. */
182
183 struct openrisc_reloc_map
184 {
185 bfd_reloc_code_real_type bfd_reloc_val;
186 unsigned int openrisc_reloc_val;
187 };
188
189 static const struct openrisc_reloc_map openrisc_reloc_map[] =
190 {
191 { BFD_RELOC_NONE, R_OPENRISC_NONE },
192 { BFD_RELOC_32, R_OPENRISC_32 },
193 { BFD_RELOC_16, R_OPENRISC_16 },
194 { BFD_RELOC_8, R_OPENRISC_8 },
195 { BFD_RELOC_OPENRISC_REL_26, R_OPENRISC_INSN_REL_26 },
196 { BFD_RELOC_OPENRISC_ABS_26, R_OPENRISC_INSN_ABS_26 },
197 { BFD_RELOC_HI16, R_OPENRISC_HI_16_IN_INSN },
198 { BFD_RELOC_LO16, R_OPENRISC_LO_16_IN_INSN },
199 { BFD_RELOC_VTABLE_INHERIT, R_OPENRISC_GNU_VTINHERIT },
200 { BFD_RELOC_VTABLE_ENTRY, R_OPENRISC_GNU_VTENTRY }
201 };
202
203 static reloc_howto_type *
204 openrisc_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
205 bfd_reloc_code_real_type code)
206 {
207 unsigned int i;
208
209 for (i = ARRAY_SIZE (openrisc_reloc_map); --i;)
210 if (openrisc_reloc_map[i].bfd_reloc_val == code)
211 return & openrisc_elf_howto_table[openrisc_reloc_map[i].
212 openrisc_reloc_val];
213
214 return NULL;
215 }
216
217 static reloc_howto_type *
218 openrisc_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
219 const char *r_name)
220 {
221 unsigned int i;
222
223 for (i = 0;
224 i < (sizeof (openrisc_elf_howto_table)
225 / sizeof (openrisc_elf_howto_table[0]));
226 i++)
227 if (openrisc_elf_howto_table[i].name != NULL
228 && strcasecmp (openrisc_elf_howto_table[i].name, r_name) == 0)
229 return &openrisc_elf_howto_table[i];
230
231 return NULL;
232 }
233
234 /* Set the howto pointer for an OpenRISC ELF reloc. */
235
236 static void
237 openrisc_info_to_howto_rela (bfd * abfd ATTRIBUTE_UNUSED,
238 arelent * cache_ptr,
239 Elf_Internal_Rela * dst)
240 {
241 unsigned int r_type;
242
243 r_type = ELF32_R_TYPE (dst->r_info);
244 BFD_ASSERT (r_type < (unsigned int) R_OPENRISC_max);
245 cache_ptr->howto = & openrisc_elf_howto_table[r_type];
246 }
247
248 /* Perform a single relocation. By default we use the standard BFD
249 routines, but a few relocs, we have to do them ourselves. */
250
251 static bfd_reloc_status_type
252 openrisc_final_link_relocate (reloc_howto_type *howto,
253 bfd *input_bfd,
254 asection *input_section,
255 bfd_byte *contents,
256 Elf_Internal_Rela *rel,
257 bfd_vma relocation)
258 {
259 bfd_reloc_status_type r = bfd_reloc_ok;
260
261 switch (howto->type)
262 {
263 case R_OPENRISC_LO_16_IN_INSN:
264 relocation &= 0xffff;
265 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
266 contents, rel->r_offset,
267 relocation, rel->r_addend);
268 break;
269
270 default:
271 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
272 contents, rel->r_offset,
273 relocation, rel->r_addend);
274 }
275
276 return r;
277 }
278
279 /* Relocate an OpenRISC ELF section.
280
281 The RELOCATE_SECTION function is called by the new ELF backend linker
282 to handle the relocations for a section.
283
284 The relocs are always passed as Rela structures; if the section
285 actually uses Rel structures, the r_addend field will always be
286 zero.
287
288 This function is responsible for adjusting the section contents as
289 necessary, and (if using Rela relocs and generating a relocatable
290 output file) adjusting the reloc addend as necessary.
291
292 This function does not have to worry about setting the reloc
293 address or the reloc symbol index.
294
295 LOCAL_SYMS is a pointer to the swapped in local symbols.
296
297 LOCAL_SECTIONS is an array giving the section in the input file
298 corresponding to the st_shndx field of each local symbol.
299
300 The global hash table entry for the global symbols can be found
301 via elf_sym_hashes (input_bfd).
302
303 When generating relocatable output, this function must handle
304 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
305 going to be the section symbol corresponding to the output
306 section, which means that the addend must be adjusted
307 accordingly. */
308
309 static bfd_boolean
310 openrisc_elf_relocate_section (bfd *output_bfd,
311 struct bfd_link_info *info,
312 bfd *input_bfd,
313 asection *input_section,
314 bfd_byte *contents,
315 Elf_Internal_Rela *relocs,
316 Elf_Internal_Sym *local_syms,
317 asection **local_sections)
318 {
319 Elf_Internal_Shdr *symtab_hdr;
320 struct elf_link_hash_entry **sym_hashes;
321 Elf_Internal_Rela *rel;
322 Elf_Internal_Rela *relend;
323
324 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
325 sym_hashes = elf_sym_hashes (input_bfd);
326 relend = relocs + input_section->reloc_count;
327
328 for (rel = relocs; rel < relend; rel++)
329 {
330 reloc_howto_type *howto;
331 unsigned long r_symndx;
332 Elf_Internal_Sym *sym;
333 asection *sec;
334 struct elf_link_hash_entry *h;
335 bfd_vma relocation;
336 bfd_reloc_status_type r;
337 const char *name = NULL;
338 int r_type;
339
340 r_type = ELF32_R_TYPE (rel->r_info);
341 r_symndx = ELF32_R_SYM (rel->r_info);
342
343 if (r_type == R_OPENRISC_GNU_VTINHERIT
344 || r_type == R_OPENRISC_GNU_VTENTRY)
345 continue;
346
347 if ((unsigned int) r_type >
348 (sizeof openrisc_elf_howto_table / sizeof (reloc_howto_type)))
349 abort ();
350
351 howto = openrisc_elf_howto_table + ELF32_R_TYPE (rel->r_info);
352 h = NULL;
353 sym = NULL;
354 sec = NULL;
355
356 if (r_symndx < symtab_hdr->sh_info)
357 {
358 sym = local_syms + r_symndx;
359 sec = local_sections[r_symndx];
360 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
361
362 name = bfd_elf_string_from_elf_section
363 (input_bfd, symtab_hdr->sh_link, sym->st_name);
364 name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
365 }
366 else
367 {
368 bfd_boolean unresolved_reloc, warned;
369
370 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
371 r_symndx, symtab_hdr, sym_hashes,
372 h, sec, relocation,
373 unresolved_reloc, warned);
374 }
375
376 if (sec != NULL && elf_discarded_section (sec))
377 {
378 /* For relocs against symbols from removed linkonce sections,
379 or sections discarded by a linker script, we just want the
380 section contents zeroed. Avoid any special processing. */
381 _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
382 rel->r_info = 0;
383 rel->r_addend = 0;
384 continue;
385 }
386
387 if (info->relocatable)
388 continue;
389
390 r = openrisc_final_link_relocate (howto, input_bfd, input_section,
391 contents, rel, relocation);
392
393 if (r != bfd_reloc_ok)
394 {
395 const char *msg = NULL;
396
397 switch (r)
398 {
399 case bfd_reloc_overflow:
400 r = info->callbacks->reloc_overflow
401 (info, (h ? &h->root : NULL), name, howto->name,
402 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
403 break;
404
405 case bfd_reloc_undefined:
406 r = info->callbacks->undefined_symbol
407 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
408 break;
409
410 case bfd_reloc_outofrange:
411 msg = _("internal error: out of range error");
412 break;
413
414 case bfd_reloc_notsupported:
415 msg = _("internal error: unsupported relocation error");
416 break;
417
418 case bfd_reloc_dangerous:
419 msg = _("internal error: dangerous relocation");
420 break;
421
422 default:
423 msg = _("internal error: unknown error");
424 break;
425 }
426
427 if (msg)
428 r = info->callbacks->warning
429 (info, msg, name, input_bfd, input_section, rel->r_offset);
430
431 if (!r)
432 return FALSE;
433 }
434 }
435
436 return TRUE;
437 }
438
439 /* Return the section that should be marked against GC for a given
440 relocation. */
441
442 static asection *
443 openrisc_elf_gc_mark_hook (asection *sec,
444 struct bfd_link_info *info,
445 Elf_Internal_Rela *rel,
446 struct elf_link_hash_entry *h,
447 Elf_Internal_Sym *sym)
448 {
449 if (h != NULL)
450 switch (ELF32_R_TYPE (rel->r_info))
451 {
452 case R_OPENRISC_GNU_VTINHERIT:
453 case R_OPENRISC_GNU_VTENTRY:
454 return NULL;
455 }
456
457 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
458 }
459
460 /* Look through the relocs for a section during the first phase.
461 Since we don't do .gots or .plts, we just need to consider the
462 virtual table relocs for gc. */
463
464 static bfd_boolean
465 openrisc_elf_check_relocs (bfd *abfd,
466 struct bfd_link_info *info,
467 asection *sec,
468 const Elf_Internal_Rela *relocs)
469 {
470 Elf_Internal_Shdr *symtab_hdr;
471 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
472 const Elf_Internal_Rela *rel;
473 const Elf_Internal_Rela *rel_end;
474
475 if (info->relocatable)
476 return TRUE;
477
478 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
479 sym_hashes = elf_sym_hashes (abfd);
480 sym_hashes_end =
481 sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
482 if (!elf_bad_symtab (abfd))
483 sym_hashes_end -= symtab_hdr->sh_info;
484
485 rel_end = relocs + sec->reloc_count;
486 for (rel = relocs; rel < rel_end; rel++)
487 {
488 struct elf_link_hash_entry *h;
489 unsigned long r_symndx;
490
491 r_symndx = ELF32_R_SYM (rel->r_info);
492 if (r_symndx < symtab_hdr->sh_info)
493 h = NULL;
494 else
495 {
496 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
497 while (h->root.type == bfd_link_hash_indirect
498 || h->root.type == bfd_link_hash_warning)
499 h = (struct elf_link_hash_entry *) h->root.u.i.link;
500 }
501
502 switch (ELF32_R_TYPE (rel->r_info))
503 {
504 /* This relocation describes the C++ object vtable hierarchy.
505 Reconstruct it for later use during GC. */
506 case R_OPENRISC_GNU_VTINHERIT:
507 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
508 return FALSE;
509 break;
510
511 /* This relocation describes which C++ vtable entries are actually
512 used. Record for later use during GC. */
513 case R_OPENRISC_GNU_VTENTRY:
514 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
515 return FALSE;
516 break;
517 }
518 }
519
520 return TRUE;
521 }
522
523 /* Set the right machine number. */
524
525 static bfd_boolean
526 openrisc_elf_object_p (bfd *abfd)
527 {
528 bfd_default_set_arch_mach (abfd, bfd_arch_openrisc, 0);
529 return TRUE;
530 }
531
532 /* Store the machine number in the flags field. */
533
534 static void
535 openrisc_elf_final_write_processing (bfd *abfd,
536 bfd_boolean linker ATTRIBUTE_UNUSED)
537 {
538 unsigned long val;
539
540 switch (bfd_get_mach (abfd))
541 {
542 default:
543 val = 0;
544 break;
545 }
546
547 elf_elfheader (abfd)->e_flags &= ~0xf;
548 elf_elfheader (abfd)->e_flags |= val;
549 }
550
551
552 #define ELF_ARCH bfd_arch_openrisc
553 #define ELF_MACHINE_CODE EM_OPENRISC
554 #define ELF_MACHINE_ALT1 EM_OPENRISC_OLD
555 #define ELF_MAXPAGESIZE 0x1000
556
557 #define TARGET_BIG_SYM bfd_elf32_openrisc_vec
558 #define TARGET_BIG_NAME "elf32-openrisc"
559
560 #define elf_info_to_howto_rel NULL
561 #define elf_info_to_howto openrisc_info_to_howto_rela
562 #define elf_backend_relocate_section openrisc_elf_relocate_section
563 #define elf_backend_gc_mark_hook openrisc_elf_gc_mark_hook
564 #define elf_backend_check_relocs openrisc_elf_check_relocs
565
566 #define elf_backend_can_gc_sections 1
567 #define elf_backend_rela_normal 1
568
569 #define bfd_elf32_bfd_reloc_type_lookup openrisc_reloc_type_lookup
570 #define bfd_elf32_bfd_reloc_name_lookup openrisc_reloc_name_lookup
571
572 #define elf_backend_object_p openrisc_elf_object_p
573 #define elf_backend_final_write_processing openrisc_elf_final_write_processing
574
575 #include "elf32-target.h"
git-cvsimport of binutils cvsroot