projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
* elf-hppa.h (elf_hppa_relocate_section): If relocatable, return
[deliverable/binutils-gdb.git] / bfd / elf32-mcore.c
1 /* Motorola MCore specific support for 32-bit ELF
2 Copyright 1994, 1995, 1999, 2000, 2001, 2002
3 Free Software Foundation, Inc.
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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
20
21 /* This file is based on a preliminary RCE ELF ABI. The
22 information may not match the final RCE ELF ABI. */
23
24 #include "bfd.h"
25 #include "sysdep.h"
26 #include "bfdlink.h"
27 #include "libbfd.h"
28 #include "elf-bfd.h"
29 #include "elf/mcore.h"
30 #include <assert.h>
31
32 /* RELA relocs are used here... */
33
34 static void mcore_elf_howto_init
35 PARAMS ((void));
36 static reloc_howto_type * mcore_elf_reloc_type_lookup
37 PARAMS ((bfd *, bfd_reloc_code_real_type));
38 static void mcore_elf_info_to_howto
39 PARAMS ((bfd *, arelent *, Elf32_Internal_Rela *));
40 static boolean mcore_elf_set_private_flags
41 PARAMS ((bfd *, flagword));
42 static boolean mcore_elf_merge_private_bfd_data
43 PARAMS ((bfd *, bfd *));
44 static bfd_reloc_status_type mcore_elf_unsupported_reloc
45 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
46 static boolean mcore_elf_relocate_section
47 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
48 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
49 static asection * mcore_elf_gc_mark_hook
50 PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *,
51 struct elf_link_hash_entry *, Elf_Internal_Sym *));
52 static boolean mcore_elf_gc_sweep_hook
53 PARAMS ((bfd *, struct bfd_link_info *, asection *,
54 const Elf_Internal_Rela *));
55 static boolean mcore_elf_check_relocs
56 PARAMS ((bfd *, struct bfd_link_info *, asection *,
57 const Elf_Internal_Rela *));
58
59 static reloc_howto_type * mcore_elf_howto_table [(int) R_MCORE_max];
60
61 static reloc_howto_type mcore_elf_howto_raw[] =
62 {
63 /* This reloc does nothing. */
64 HOWTO (R_MCORE_NONE, /* type */
65 0, /* rightshift */
66 2, /* size (0 = byte, 1 = short, 2 = long) */
67 32, /* bitsize */
68 false, /* pc_relative */
69 0, /* bitpos */
70 complain_overflow_bitfield, /* complain_on_overflow */
71 NULL, /* special_function */
72 "R_MCORE_NONE", /* name */
73 false, /* partial_inplace */
74 0, /* src_mask */
75 0, /* dst_mask */
76 false), /* pcrel_offset */
77
78 /* A standard 32 bit relocation. */
79 HOWTO (R_MCORE_ADDR32, /* 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_bitfield, /* complain_on_overflow */
86 bfd_elf_generic_reloc, /* special_function */
87 "ADDR32", /* name *//* For compatability with coff/pe port. */
88 false, /* partial_inplace */
89 0x0, /* src_mask */
90 0xffffffff, /* dst_mask */
91 false), /* pcrel_offset */
92
93 /* 8 bits + 2 zero bits; jmpi/jsri/lrw instructions.
94 Should not appear in object files. */
95 HOWTO (R_MCORE_PCRELIMM8BY4, /* type */
96 2, /* rightshift */
97 1, /* size (0 = byte, 1 = short, 2 = long) */
98 8, /* bitsize */
99 true, /* pc_relative */
100 0, /* bitpos */
101 complain_overflow_bitfield, /* complain_on_overflow */
102 mcore_elf_unsupported_reloc, /* special_function */
103 "R_MCORE_PCRELIMM8BY4",/* name */
104 false, /* partial_inplace */
105 0, /* src_mask */
106 0, /* dst_mask */
107 true), /* pcrel_offset */
108
109 /* bsr/bt/bf/br instructions; 11 bits + 1 zero bit
110 Span 2k instructions == 4k bytes.
111 Only useful pieces at the relocated address are the opcode (5 bits) */
112 HOWTO (R_MCORE_PCRELIMM11BY2,/* type */
113 1, /* rightshift */
114 1, /* size (0 = byte, 1 = short, 2 = long) */
115 11, /* bitsize */
116 true, /* pc_relative */
117 0, /* bitpos */
118 complain_overflow_signed, /* complain_on_overflow */
119 bfd_elf_generic_reloc, /* special_function */
120 "R_MCORE_PCRELIMM11BY2",/* name */
121 false, /* partial_inplace */
122 0x0, /* src_mask */
123 0x7ff, /* dst_mask */
124 true), /* pcrel_offset */
125
126 /* 4 bits + 1 zero bit; 'loopt' instruction only; unsupported. */
127 HOWTO (R_MCORE_PCRELIMM4BY2, /* type */
128 1, /* rightshift */
129 1, /* size (0 = byte, 1 = short, 2 = long) */
130 4, /* bitsize */
131 true, /* pc_relative */
132 0, /* bitpos */
133 complain_overflow_bitfield, /* complain_on_overflow */
134 mcore_elf_unsupported_reloc,/* special_function */
135 "R_MCORE_PCRELIMM4BY2",/* name */
136 false, /* partial_inplace */
137 0, /* src_mask */
138 0, /* dst_mask */
139 true), /* pcrel_offset */
140
141 /* 32-bit pc-relative. Eventually this will help support PIC code. */
142 HOWTO (R_MCORE_PCREL32, /* type */
143 0, /* rightshift */
144 2, /* size (0 = byte, 1 = short, 2 = long) */
145 32, /* bitsize */
146 true, /* pc_relative */
147 0, /* bitpos */
148 complain_overflow_bitfield, /* complain_on_overflow */
149 bfd_elf_generic_reloc, /* special_function */
150 "R_MCORE_PCREL32", /* name */
151 false, /* partial_inplace */
152 0x0, /* src_mask */
153 0xffffffff, /* dst_mask */
154 true), /* pcrel_offset */
155
156 /* Like PCRELIMM11BY2, this relocation indicates that there is a
157 'jsri' at the specified address. There is a separate relocation
158 entry for the literal pool entry that it references, but we
159 might be able to change the jsri to a bsr if the target turns out
160 to be close enough [even though we won't reclaim the literal pool
161 entry, we'll get some runtime efficiency back]. Note that this
162 is a relocation that we are allowed to safely ignore. */
163 HOWTO (R_MCORE_PCRELJSR_IMM11BY2,/* type */
164 1, /* rightshift */
165 1, /* size (0 = byte, 1 = short, 2 = long) */
166 11, /* bitsize */
167 true, /* pc_relative */
168 0, /* bitpos */
169 complain_overflow_signed, /* complain_on_overflow */
170 bfd_elf_generic_reloc, /* special_function */
171 "R_MCORE_PCRELJSR_IMM11BY2", /* name */
172 false, /* partial_inplace */
173 0x0, /* src_mask */
174 0x7ff, /* dst_mask */
175 true), /* pcrel_offset */
176
177 /* GNU extension to record C++ vtable hierarchy */
178 HOWTO (R_MCORE_GNU_VTINHERIT, /* type */
179 0, /* rightshift */
180 2, /* size (0 = byte, 1 = short, 2 = long) */
181 0, /* bitsize */
182 false, /* pc_relative */
183 0, /* bitpos */
184 complain_overflow_dont, /* complain_on_overflow */
185 NULL, /* special_function */
186 "R_MCORE_GNU_VTINHERIT", /* name */
187 false, /* partial_inplace */
188 0, /* src_mask */
189 0, /* dst_mask */
190 false), /* pcrel_offset */
191
192 /* GNU extension to record C++ vtable member usage */
193 HOWTO (R_MCORE_GNU_VTENTRY, /* type */
194 0, /* rightshift */
195 2, /* size (0 = byte, 1 = short, 2 = long) */
196 0, /* bitsize */
197 false, /* pc_relative */
198 0, /* bitpos */
199 complain_overflow_dont,/* complain_on_overflow */
200 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
201 "R_MCORE_GNU_VTENTRY", /* name */
202 false, /* partial_inplace */
203 0, /* src_mask */
204 0, /* dst_mask */
205 false), /* pcrel_offset */
206
207 HOWTO (R_MCORE_RELATIVE, /* type */
208 0, /* rightshift */
209 2, /* size (0 = byte, 1 = short, 2 = long) */
210 32, /* bitsize */
211 false, /* pc_relative */
212 0, /* bitpos */
213 complain_overflow_signed, /* complain_on_overflow */
214 NULL, /* special_function */
215 "R_MCORE_RELATIVE", /* name */
216 true, /* partial_inplace */
217 0xffffffff, /* src_mask */
218 0xffffffff, /* dst_mask */
219 false) /* pcrel_offset */
220 };
221
222 #ifndef NUM_ELEM
223 #define NUM_ELEM(a) (sizeof (a) / sizeof (a)[0])
224 #endif
225 \f
226 /* Initialize the mcore_elf_howto_table, so that linear accesses can be done. */
227 static void
228 mcore_elf_howto_init ()
229 {
230 unsigned int i;
231
232 for (i = NUM_ELEM (mcore_elf_howto_raw); i--;)
233 {
234 unsigned int type;
235
236 type = mcore_elf_howto_raw[i].type;
237
238 BFD_ASSERT (type < NUM_ELEM (mcore_elf_howto_table));
239
240 mcore_elf_howto_table [type] = & mcore_elf_howto_raw [i];
241 }
242 }
243 \f
244 static reloc_howto_type *
245 mcore_elf_reloc_type_lookup (abfd, code)
246 bfd * abfd ATTRIBUTE_UNUSED;
247 bfd_reloc_code_real_type code;
248 {
249 enum elf_mcore_reloc_type mcore_reloc = R_MCORE_NONE;
250
251 switch (code)
252 {
253 case BFD_RELOC_NONE: mcore_reloc = R_MCORE_NONE; break;
254 case BFD_RELOC_32: mcore_reloc = R_MCORE_ADDR32; break;
255 case BFD_RELOC_MCORE_PCREL_IMM8BY4: mcore_reloc = R_MCORE_PCRELIMM8BY4; break;
256 case BFD_RELOC_MCORE_PCREL_IMM11BY2: mcore_reloc = R_MCORE_PCRELIMM11BY2; break;
257 case BFD_RELOC_MCORE_PCREL_IMM4BY2: mcore_reloc = R_MCORE_PCRELIMM4BY2; break;
258 case BFD_RELOC_32_PCREL: mcore_reloc = R_MCORE_PCREL32; break;
259 case BFD_RELOC_MCORE_PCREL_JSR_IMM11BY2: mcore_reloc = R_MCORE_PCRELJSR_IMM11BY2; break;
260 case BFD_RELOC_VTABLE_INHERIT: mcore_reloc = R_MCORE_GNU_VTINHERIT; break;
261 case BFD_RELOC_VTABLE_ENTRY: mcore_reloc = R_MCORE_GNU_VTENTRY; break;
262 case BFD_RELOC_RVA: mcore_reloc = R_MCORE_RELATIVE; break;
263 default:
264 return (reloc_howto_type *)NULL;
265 }
266
267 if (! mcore_elf_howto_table [R_MCORE_PCRELIMM8BY4]) /* Initialize howto table if needed */
268 mcore_elf_howto_init ();
269
270 return mcore_elf_howto_table [(int) mcore_reloc];
271 };
272
273 /* Set the howto pointer for a RCE ELF reloc. */
274 static void
275 mcore_elf_info_to_howto (abfd, cache_ptr, dst)
276 bfd * abfd ATTRIBUTE_UNUSED;
277 arelent * cache_ptr;
278 Elf32_Internal_Rela * dst;
279 {
280 if (! mcore_elf_howto_table [R_MCORE_PCRELIMM8BY4]) /* Initialize howto table if needed */
281 mcore_elf_howto_init ();
282
283 BFD_ASSERT (ELF32_R_TYPE (dst->r_info) < (unsigned int) R_MCORE_max);
284
285 cache_ptr->howto = mcore_elf_howto_table [ELF32_R_TYPE (dst->r_info)];
286 }
287
288 /* Function to set whether a module needs the -mrelocatable bit set. */
289 static boolean
290 mcore_elf_set_private_flags (abfd, flags)
291 bfd * abfd;
292 flagword flags;
293 {
294 BFD_ASSERT (! elf_flags_init (abfd)
295 || elf_elfheader (abfd)->e_flags == flags);
296
297 elf_elfheader (abfd)->e_flags = flags;
298 elf_flags_init (abfd) = true;
299 return true;
300 }
301
302 /* Merge backend specific data from an object file to the output
303 object file when linking. */
304 static boolean
305 mcore_elf_merge_private_bfd_data (ibfd, obfd)
306 bfd * ibfd;
307 bfd * obfd;
308 {
309 flagword old_flags;
310 flagword new_flags;
311
312 /* Check if we have the same endianess */
313 if (! _bfd_generic_verify_endian_match (ibfd, obfd))
314 return false;
315
316 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
317 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
318 return true;
319
320 new_flags = elf_elfheader (ibfd)->e_flags;
321 old_flags = elf_elfheader (obfd)->e_flags;
322
323 if (! elf_flags_init (obfd)) /* First call, no flags set */
324 {
325 elf_flags_init (obfd) = true;
326 elf_elfheader (obfd)->e_flags = new_flags;
327 }
328 else if (new_flags == old_flags) /* Compatible flags are ok */
329 ;
330 else
331 {
332 /* FIXME */
333 }
334
335 return true;
336 }
337 \f
338 /* Don't pretend we can deal with unsupported relocs. */
339
340 static bfd_reloc_status_type
341 mcore_elf_unsupported_reloc (abfd, reloc_entry, symbol, data, input_section,
342 output_bfd, error_message)
343 bfd * abfd;
344 arelent * reloc_entry;
345 asymbol * symbol ATTRIBUTE_UNUSED;
346 PTR data ATTRIBUTE_UNUSED;
347 asection * input_section ATTRIBUTE_UNUSED;
348 bfd * output_bfd ATTRIBUTE_UNUSED;
349 char ** error_message ATTRIBUTE_UNUSED;
350 {
351 BFD_ASSERT (reloc_entry->howto != (reloc_howto_type *)0);
352
353 _bfd_error_handler (_("%s: Relocation %s (%d) is not currently supported.\n"),
354 bfd_archive_filename (abfd),
355 reloc_entry->howto->name,
356 reloc_entry->howto->type);
357
358 return bfd_reloc_notsupported;
359 }
360 \f
361 /* The RELOCATE_SECTION function is called by the ELF backend linker
362 to handle the relocations for a section.
363
364 The relocs are always passed as Rela structures; if the section
365 actually uses Rel structures, the r_addend field will always be
366 zero.
367
368 This function is responsible for adjust the section contents as
369 necessary, and (if using Rela relocs and generating a
370 relocateable output file) adjusting the reloc addend as
371 necessary.
372
373 This function does not have to worry about setting the reloc
374 address or the reloc symbol index.
375
376 LOCAL_SYMS is a pointer to the swapped in local symbols.
377
378 LOCAL_SECTIONS is an array giving the section in the input file
379 corresponding to the st_shndx field of each local symbol.
380
381 The global hash table entry for the global symbols can be found
382 via elf_sym_hashes (input_bfd).
383
384 When generating relocateable output, this function must handle
385 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
386 going to be the section symbol corresponding to the output
387 section, which means that the addend must be adjusted
388 accordingly. */
389
390 static boolean
391 mcore_elf_relocate_section (output_bfd, info, input_bfd, input_section,
392 contents, relocs, local_syms, local_sections)
393 bfd * output_bfd;
394 struct bfd_link_info * info;
395 bfd * input_bfd;
396 asection * input_section;
397 bfd_byte * contents;
398 Elf_Internal_Rela * relocs;
399 Elf_Internal_Sym * local_syms;
400 asection ** local_sections;
401 {
402 Elf_Internal_Shdr * symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
403 struct elf_link_hash_entry ** sym_hashes = elf_sym_hashes (input_bfd);
404 Elf_Internal_Rela * rel = relocs;
405 Elf_Internal_Rela * relend = relocs + input_section->reloc_count;
406 boolean ret = true;
407
408 #ifdef DEBUG
409 fprintf (stderr,
410 "mcore_elf_relocate_section called for %s section %s, %ld relocations%s\n",
411 bfd_archive_filename (input_bfd),
412 bfd_section_name(input_bfd, input_section),
413 (long) input_section->reloc_count,
414 (info->relocateable) ? " (relocatable)" : "");
415 #endif
416
417 if (info->relocateable)
418 return true;
419
420 if (! mcore_elf_howto_table [R_MCORE_PCRELIMM8BY4]) /* Initialize howto table if needed */
421 mcore_elf_howto_init ();
422
423 for (; rel < relend; rel++)
424 {
425 enum elf_mcore_reloc_type r_type = (enum elf_mcore_reloc_type) ELF32_R_TYPE (rel->r_info);
426 bfd_vma offset = rel->r_offset;
427 bfd_vma addend = rel->r_addend;
428 bfd_reloc_status_type r = bfd_reloc_other;
429 asection * sec = (asection *) 0;
430 reloc_howto_type * howto;
431 bfd_vma relocation;
432 Elf_Internal_Sym * sym = (Elf_Internal_Sym *) 0;
433 unsigned long r_symndx;
434 struct elf_link_hash_entry * h = (struct elf_link_hash_entry *) 0;
435 unsigned short oldinst = 0;
436
437 /* Unknown relocation handling */
438 if ((unsigned) r_type >= (unsigned) R_MCORE_max
439 || ! mcore_elf_howto_table [(int)r_type])
440 {
441 _bfd_error_handler (_("%s: Unknown relocation type %d\n"),
442 bfd_archive_filename (input_bfd),
443 (int) r_type);
444
445 bfd_set_error (bfd_error_bad_value);
446 ret = false;
447 continue;
448 }
449
450 howto = mcore_elf_howto_table [(int) r_type];
451 r_symndx = ELF32_R_SYM (rel->r_info);
452
453 /* Complain about known relocation that are not yet supported. */
454 if (howto->special_function == mcore_elf_unsupported_reloc)
455 {
456 _bfd_error_handler (_("%s: Relocation %s (%d) is not currently supported.\n"),
457 bfd_archive_filename (input_bfd),
458 howto->name,
459 (int)r_type);
460
461 bfd_set_error (bfd_error_bad_value);
462 ret = false;
463 continue;
464 }
465
466 if (r_symndx < symtab_hdr->sh_info)
467 {
468 sym = local_syms + r_symndx;
469 sec = local_sections [r_symndx];
470 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
471 addend = rel->r_addend;
472 }
473 else
474 {
475 h = sym_hashes [r_symndx - symtab_hdr->sh_info];
476 if ( h->root.type == bfd_link_hash_defined
477 || h->root.type == bfd_link_hash_defweak)
478 {
479 sec = h->root.u.def.section;
480 relocation = (h->root.u.def.value
481 + sec->output_section->vma
482 + sec->output_offset);
483 }
484 else if (h->root.type == bfd_link_hash_undefweak)
485 relocation = 0;
486 else if (info->shared
487 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
488 relocation = 0;
489 else
490 {
491 if (! ((*info->callbacks->undefined_symbol)
492 (info, h->root.root.string, input_bfd,
493 input_section, rel->r_offset, true)))
494 return false;
495
496 ret = false;
497 continue;
498 }
499 }
500
501 switch (r_type)
502 {
503 default:
504 break;
505
506 case R_MCORE_PCRELJSR_IMM11BY2:
507 oldinst = bfd_get_16 (input_bfd, contents + offset);
508 #define MCORE_INST_BSR 0xF800
509 bfd_put_16 (input_bfd, (bfd_vma) MCORE_INST_BSR, contents + offset);
510 break;
511 }
512
513 #ifdef DEBUG
514 fprintf (stderr, "\ttype = %s (%d), symbol index = %ld, offset = %ld, addend = %ld\n",
515 howto->name, r_type, r_symndx, (long) offset, (long) addend);
516 #endif
517
518 r = _bfd_final_link_relocate
519 (howto, input_bfd, input_section, contents, offset, relocation, addend);
520
521 if (r != bfd_reloc_ok && r_type == R_MCORE_PCRELJSR_IMM11BY2)
522 {
523 /* Wasn't ok, back it out and give up. */
524 bfd_put_16 (input_bfd, (bfd_vma) oldinst, contents + offset);
525 r = bfd_reloc_ok;
526 }
527
528 if (r != bfd_reloc_ok)
529 {
530 ret = false;
531
532 switch (r)
533 {
534 default:
535 break;
536
537 case bfd_reloc_overflow:
538 {
539 const char * name;
540
541 if (h != NULL)
542 name = h->root.root.string;
543 else
544 {
545 name = bfd_elf_string_from_elf_section
546 (input_bfd, symtab_hdr->sh_link, sym->st_name);
547
548 if (name == NULL)
549 break;
550
551 if (* name == '\0')
552 name = bfd_section_name (input_bfd, sec);
553 }
554
555 (*info->callbacks->reloc_overflow)
556 (info, name, howto->name, (bfd_vma) 0, input_bfd, input_section,
557 offset);
558 }
559 break;
560 }
561 }
562 }
563
564 #ifdef DEBUG
565 fprintf (stderr, "\n");
566 #endif
567
568 return ret;
569 }
570 \f
571 /* Return the section that should be marked against GC for a given
572 relocation. */
573
574 static asection *
575 mcore_elf_gc_mark_hook (sec, info, rel, h, sym)
576 asection * sec;
577 struct bfd_link_info * info ATTRIBUTE_UNUSED;
578 Elf_Internal_Rela * rel;
579 struct elf_link_hash_entry * h;
580 Elf_Internal_Sym * sym;
581 {
582 if (h != NULL)
583 {
584 switch (ELF32_R_TYPE (rel->r_info))
585 {
586 case R_MCORE_GNU_VTINHERIT:
587 case R_MCORE_GNU_VTENTRY:
588 break;
589
590 default:
591 switch (h->root.type)
592 {
593 case bfd_link_hash_defined:
594 case bfd_link_hash_defweak:
595 return h->root.u.def.section;
596
597 case bfd_link_hash_common:
598 return h->root.u.c.p->section;
599
600 default:
601 break;
602 }
603 }
604 }
605 else
606 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
607
608 return NULL;
609 }
610
611 /* Update the got entry reference counts for the section being removed. */
612
613 static boolean
614 mcore_elf_gc_sweep_hook (abfd, info, sec, relocs)
615 bfd * abfd ATTRIBUTE_UNUSED;
616 struct bfd_link_info * info ATTRIBUTE_UNUSED;
617 asection * sec ATTRIBUTE_UNUSED;
618 const Elf_Internal_Rela * relocs ATTRIBUTE_UNUSED;
619 {
620 return true;
621 }
622
623 /* Look through the relocs for a section during the first phase.
624 Since we don't do .gots or .plts, we just need to consider the
625 virtual table relocs for gc. */
626
627 static boolean
628 mcore_elf_check_relocs (abfd, info, sec, relocs)
629 bfd * abfd;
630 struct bfd_link_info * info;
631 asection * sec;
632 const Elf_Internal_Rela * relocs;
633 {
634 Elf_Internal_Shdr * symtab_hdr;
635 struct elf_link_hash_entry ** sym_hashes;
636 struct elf_link_hash_entry ** sym_hashes_end;
637 const Elf_Internal_Rela * rel;
638 const Elf_Internal_Rela * rel_end;
639
640 if (info->relocateable)
641 return true;
642
643 symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
644 sym_hashes = elf_sym_hashes (abfd);
645 sym_hashes_end = sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
646 if (!elf_bad_symtab (abfd))
647 sym_hashes_end -= symtab_hdr->sh_info;
648
649 rel_end = relocs + sec->reloc_count;
650
651 for (rel = relocs; rel < rel_end; rel++)
652 {
653 struct elf_link_hash_entry * h;
654 unsigned long r_symndx;
655
656 r_symndx = ELF32_R_SYM (rel->r_info);
657
658 if (r_symndx < symtab_hdr->sh_info)
659 h = NULL;
660 else
661 h = sym_hashes [r_symndx - symtab_hdr->sh_info];
662
663 switch (ELF32_R_TYPE (rel->r_info))
664 {
665 /* This relocation describes the C++ object vtable hierarchy.
666 Reconstruct it for later use during GC. */
667 case R_MCORE_GNU_VTINHERIT:
668 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
669 return false;
670 break;
671
672 /* This relocation describes which C++ vtable entries are actually
673 used. Record for later use during GC. */
674 case R_MCORE_GNU_VTENTRY:
675 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
676 return false;
677 break;
678 }
679 }
680
681 return true;
682 }
683
684 #define TARGET_BIG_SYM bfd_elf32_mcore_big_vec
685 #define TARGET_BIG_NAME "elf32-mcore-big"
686 #define TARGET_LITTLE_SYM bfd_elf32_mcore_little_vec
687 #define TARGET_LITTLE_NAME "elf32-mcore-little"
688
689 #define ELF_ARCH bfd_arch_mcore
690 #define ELF_MACHINE_CODE EM_MCORE
691 #define ELF_MAXPAGESIZE 0x1000 /* 4k, if we ever have 'em */
692 #define elf_info_to_howto mcore_elf_info_to_howto
693 #define elf_info_to_howto_rel NULL
694
695 #define bfd_elf32_bfd_merge_private_bfd_data mcore_elf_merge_private_bfd_data
696 #define bfd_elf32_bfd_set_private_flags mcore_elf_set_private_flags
697 #define bfd_elf32_bfd_reloc_type_lookup mcore_elf_reloc_type_lookup
698 #define elf_backend_relocate_section mcore_elf_relocate_section
699 #define elf_backend_gc_mark_hook mcore_elf_gc_mark_hook
700 #define elf_backend_gc_sweep_hook mcore_elf_gc_sweep_hook
701 #define elf_backend_check_relocs mcore_elf_check_relocs
702
703 #define elf_backend_can_gc_sections 1
704 #define elf_backend_rela_normal 1
705
706 #include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.05674 seconds and 5 git commands to generate.