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