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