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