?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2000-03-08 H.J. Lu (hjl@gnu.org)
[binutils.git] / bfd / elf32-mcore.c
blob5963a9eff6ea8d0465e537547384c0ecfc12cdda
1 /* Motorola MCore specific support for 32-bit ELF
2 Copyright 1994, 1995, 1999 Free Software Foundation, Inc.
3
4 This file is part of BFD, the Binary File Descriptor library.
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, 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
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_copy_private_bfd_data
43 PARAMS ((bfd *, bfd *));
44 static boolean mcore_elf_merge_private_bfd_data
45 PARAMS ((bfd *, bfd *));
46 static bfd_reloc_status_type mcore_elf_unsupported_reloc
47 PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
48 static 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
52 static reloc_howto_type * mcore_elf_howto_table [(int) R_MCORE_max];
53
54 static 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 32, /* bitsize */
61 false, /* pc_relative */
62 0, /* bitpos */
63 complain_overflow_bitfield, /* complain_on_overflow */
64 NULL, /* special_function */
65 "R_MCORE_NONE", /* name */
66 false, /* partial_inplace */
67 0, /* src_mask */
68 0, /* dst_mask */
69 false), /* 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 HOWTO (R_MCORE_RELATIVE, /* type */
201 0, /* rightshift */
202 2, /* size (0 = byte, 1 = short, 2 = long) */
203 32, /* bitsize */
204 false, /* pc_relative */
205 0, /* bitpos */
206 complain_overflow_signed, /* complain_on_overflow */
207 NULL, /* special_function */
208 "R_MCORE_RELATIVE", /* name */
209 true, /* partial_inplace */
210 0xffffffff, /* src_mask */
211 0xffffffff, /* dst_mask */
212 false) /* pcrel_offset */
213 };
214
215 #ifndef NUM_ELEM
216 #define NUM_ELEM(a) (sizeof (a) / sizeof (a)[0])
217 #endif
218 \f
219 /* Initialize the mcore_elf_howto_table, so that linear accesses can be done. */
220 static void
221 mcore_elf_howto_init ()
222 {
223 unsigned int i;
224
225 for (i = NUM_ELEM (mcore_elf_howto_raw); i--;)
226 {
227 unsigned int type;
228
229 type = mcore_elf_howto_raw[i].type;
230
231 BFD_ASSERT (type < NUM_ELEM (mcore_elf_howto_table));
232
233 mcore_elf_howto_table [type] = & mcore_elf_howto_raw [i];
234 }
235 }
236
237 \f
238 static reloc_howto_type *
239 mcore_elf_reloc_type_lookup (abfd, code)
240 bfd * abfd ATTRIBUTE_UNUSED;
241 bfd_reloc_code_real_type code;
242 {
243 enum elf_mcore_reloc_type mcore_reloc = R_MCORE_NONE;
244
245 switch (code)
246 {
247 case BFD_RELOC_NONE: mcore_reloc = R_MCORE_NONE; break;
248 case BFD_RELOC_32: mcore_reloc = R_MCORE_ADDR32; break;
249 case BFD_RELOC_MCORE_PCREL_IMM8BY4: mcore_reloc = R_MCORE_PCRELIMM8BY4; break;
250 case BFD_RELOC_MCORE_PCREL_IMM11BY2: mcore_reloc = R_MCORE_PCRELIMM11BY2; break;
251 case BFD_RELOC_MCORE_PCREL_IMM4BY2: mcore_reloc = R_MCORE_PCRELIMM4BY2; break;
252 case BFD_RELOC_32_PCREL: mcore_reloc = R_MCORE_PCREL32; break;
253 case BFD_RELOC_MCORE_PCREL_JSR_IMM11BY2: mcore_reloc = R_MCORE_PCRELJSR_IMM11BY2; break;
254 case BFD_RELOC_VTABLE_INHERIT: mcore_reloc = R_MCORE_GNU_VTINHERIT; break;
255 case BFD_RELOC_VTABLE_ENTRY: mcore_reloc = R_MCORE_GNU_VTENTRY; break;
256 case BFD_RELOC_RVA: mcore_reloc = R_MCORE_RELATIVE; break;
257 default:
258 return (reloc_howto_type *)NULL;
259 }
260
261 if (! mcore_elf_howto_table [R_MCORE_PCRELIMM8BY4]) /* Initialize howto table if needed */
262 mcore_elf_howto_init ();
263
264 return mcore_elf_howto_table [(int) mcore_reloc];
265 };
266
267 /* Set the howto pointer for a RCE ELF reloc. */
268 static void
269 mcore_elf_info_to_howto (abfd, cache_ptr, dst)
270 bfd * abfd ATTRIBUTE_UNUSED;
271 arelent * cache_ptr;
272 Elf32_Internal_Rela * dst;
273 {
274 if (! mcore_elf_howto_table [R_MCORE_PCRELIMM8BY4]) /* Initialize howto table if needed */
275 mcore_elf_howto_init ();
276
277 BFD_ASSERT (ELF32_R_TYPE (dst->r_info) < (unsigned int) R_MCORE_max);
278
279 cache_ptr->howto = mcore_elf_howto_table [ELF32_R_TYPE (dst->r_info)];
280 }
281
282 /* Function to set whether a module needs the -mrelocatable bit set. */
283 static boolean
284 mcore_elf_set_private_flags (abfd, flags)
285 bfd * abfd;
286 flagword flags;
287 {
288 BFD_ASSERT (! elf_flags_init (abfd)
289 || elf_elfheader (abfd)->e_flags == flags);
290
291 elf_elfheader (abfd)->e_flags = flags;
292 elf_flags_init (abfd) = true;
293 return true;
294 }
295
296 /* Copy backend specific data from one object module to another. */
297 static boolean
298 mcore_elf_copy_private_bfd_data (ibfd, obfd)
299 bfd * ibfd;
300 bfd * obfd;
301 {
302 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
303 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
304 return true;
305
306 BFD_ASSERT (! elf_flags_init (obfd)
307 || elf_elfheader (obfd)->e_flags == elf_elfheader (ibfd)->e_flags);
308
309 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
310 elf_flags_init (obfd) = true;
311 return true;
312 }
313
314 /* Merge backend specific data from an object file to the output
315 object file when linking. */
316 static boolean
317 mcore_elf_merge_private_bfd_data (ibfd, obfd)
318 bfd * ibfd;
319 bfd * obfd;
320 {
321 flagword old_flags;
322 flagword new_flags;
323
324 /* Check if we have the same endianess */
325 if ( ibfd->xvec->byteorder != obfd->xvec->byteorder
326 && obfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
327 {
328 (*_bfd_error_handler)
329 (_("%s: compiled for a %s endian system and target is %s endian.\n"),
330 bfd_get_filename (ibfd),
331 bfd_big_endian (ibfd) ? "big" : "little",
332 bfd_big_endian (obfd) ? "big" : "little");
333
334 bfd_set_error (bfd_error_wrong_format);
335 return false;
336 }
337
338 if ( bfd_get_flavour (ibfd) != bfd_target_elf_flavour
339 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
340 return true;
341
342 new_flags = elf_elfheader (ibfd)->e_flags;
343 old_flags = elf_elfheader (obfd)->e_flags;
344
345 if (! elf_flags_init (obfd)) /* First call, no flags set */
346 {
347 elf_flags_init (obfd) = true;
348 elf_elfheader (obfd)->e_flags = new_flags;
349 }
350 else if (new_flags == old_flags) /* Compatible flags are ok */
351 ;
352 else
353 {
354 /* FIXME */
355 }
356
357 return true;
358 }
359
360 \f
361 /* Don't pretend we can deal with unsupported relocs. */
362
363 /*ARGSUSED*/
364 static bfd_reloc_status_type
365 mcore_elf_unsupported_reloc (abfd, reloc_entry, symbol, data, input_section,
366 output_bfd, error_message)
367 bfd * abfd;
368 arelent * reloc_entry;
369 asymbol * symbol ATTRIBUTE_UNUSED;
370 PTR data ATTRIBUTE_UNUSED;
371 asection * input_section ATTRIBUTE_UNUSED;
372 bfd * output_bfd ATTRIBUTE_UNUSED;
373 char ** error_message ATTRIBUTE_UNUSED;
374 {
375 BFD_ASSERT (reloc_entry->howto != (reloc_howto_type *)0);
376
377 _bfd_error_handler (_("%s: Relocation %s (%d) is not currently supported.\n"),
378 bfd_get_filename (abfd),
379 reloc_entry->howto->name,
380 reloc_entry->howto->type);
381
382 return bfd_reloc_notsupported;
383 }
384
385 \f
386 /* The RELOCATE_SECTION function is called by the ELF backend linker
387 to handle the relocations for a section.
388
389 The relocs are always passed as Rela structures; if the section
390 actually uses Rel structures, the r_addend field will always be
391 zero.
392
393 This function is responsible for adjust the section contents as
394 necessary, and (if using Rela relocs and generating a
395 relocateable output file) adjusting the reloc addend as
396 necessary.
397
398 This function does not have to worry about setting the reloc
399 address or the reloc symbol index.
400
401 LOCAL_SYMS is a pointer to the swapped in local symbols.
402
403 LOCAL_SECTIONS is an array giving the section in the input file
404 corresponding to the st_shndx field of each local symbol.
405
406 The global hash table entry for the global symbols can be found
407 via elf_sym_hashes (input_bfd).
408
409 When generating relocateable output, this function must handle
410 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
411 going to be the section symbol corresponding to the output
412 section, which means that the addend must be adjusted
413 accordingly. */
414
415 static boolean
416 mcore_elf_relocate_section (output_bfd, info, input_bfd, input_section,
417 contents, relocs, local_syms, local_sections)
418 bfd * output_bfd ATTRIBUTE_UNUSED;
419 struct bfd_link_info * info;
420 bfd * input_bfd;
421 asection * input_section;
422 bfd_byte * contents;
423 Elf_Internal_Rela * relocs;
424 Elf_Internal_Sym * local_syms;
425 asection ** local_sections;
426 {
427 Elf_Internal_Shdr * symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
428 struct elf_link_hash_entry ** sym_hashes = elf_sym_hashes (input_bfd);
429 Elf_Internal_Rela * rel = relocs;
430 Elf_Internal_Rela * relend = relocs + input_section->reloc_count;
431 boolean ret = true;
432
433 #ifdef DEBUG
434 fprintf (stderr,
435 "mcore_elf_relocate_section called for %s section %s, %ld relocations%s\n",
436 bfd_get_filename (input_bfd),
437 bfd_section_name(input_bfd, input_section),
438 (long) input_section->reloc_count,
439 (info->relocateable) ? " (relocatable)" : "");
440 #endif
441
442 if (! mcore_elf_howto_table [R_MCORE_PCRELIMM8BY4]) /* Initialize howto table if needed */
443 mcore_elf_howto_init ();
444
445 for (; rel < relend; rel++)
446 {
447 enum elf_mcore_reloc_type r_type = (enum elf_mcore_reloc_type) ELF32_R_TYPE (rel->r_info);
448 bfd_vma offset = rel->r_offset;
449 bfd_vma addend = rel->r_addend;
450 bfd_reloc_status_type r = bfd_reloc_other;
451 asection * sec = (asection *) 0;
452 reloc_howto_type * howto;
453 bfd_vma relocation;
454 Elf_Internal_Sym * sym = (Elf_Internal_Sym *) 0;
455 unsigned long r_symndx;
456 struct elf_link_hash_entry * h = (struct elf_link_hash_entry *) 0;
457 unsigned short oldinst = 0;
458
459 /* Unknown relocation handling */
460 if ((unsigned) r_type >= (unsigned) R_MCORE_max
461 || ! mcore_elf_howto_table [(int)r_type])
462 {
463 _bfd_error_handler (_("%s: Unknown relocation type %d\n"),
464 bfd_get_filename (input_bfd),
465 (int) r_type);
466
467 bfd_set_error (bfd_error_bad_value);
468 ret = false;
469 continue;
470 }
471
472 howto = mcore_elf_howto_table [(int) r_type];
473 r_symndx = ELF32_R_SYM (rel->r_info);
474
475 if (info->relocateable)
476 {
477 /* This is a relocateable link. We don't have to change
478 anything, unless the reloc is against a section symbol,
479 in which case we have to adjust according to where the
480 section symbol winds up in the output section. */
481 if (r_symndx < symtab_hdr->sh_info)
482 {
483 sym = local_syms + r_symndx;
484
485 if ((unsigned)ELF_ST_TYPE (sym->st_info) == STT_SECTION)
486 {
487 sec = local_sections[r_symndx];
488 addend = rel->r_addend += sec->output_offset + sym->st_value;
489 }
490 }
491
492 #ifdef DEBUG
493 fprintf (stderr, "\ttype = %s (%d), symbol index = %ld, offset = %ld, addend = %ld\n",
494 howto->name, (int) r_type, r_symndx, (long) offset, (long) addend);
495 #endif
496 continue;
497 }
498
499 /* This is a final link. */
500
501 /* Complain about known relocation that are not yet supported */
502 if (howto->special_function == mcore_elf_unsupported_reloc)
503 {
504 _bfd_error_handler (_("%s: Relocation %s (%d) is not currently supported.\n"),
505 bfd_get_filename (input_bfd),
506 howto->name,
507 (int)r_type);
508
509 bfd_set_error (bfd_error_bad_value);
510 ret = false;
511 continue;
512 }
513
514 if (r_symndx < symtab_hdr->sh_info)
515 {
516 sym = local_syms + r_symndx;
517 sec = local_sections [r_symndx];
518 relocation = (sec->output_section->vma
519 + sec->output_offset
520 + sym->st_value);
521 }
522 else
523 {
524 h = sym_hashes [r_symndx - symtab_hdr->sh_info];
525 if ( h->root.type == bfd_link_hash_defined
526 || h->root.type == bfd_link_hash_defweak)
527 {
528 sec = h->root.u.def.section;
529 relocation = (h->root.u.def.value
530 + sec->output_section->vma
531 + sec->output_offset);
532 }
533 else if (h->root.type == bfd_link_hash_undefweak)
534 relocation = 0;
535 else if (info->shared)
536 relocation = 0;
537 else
538 {
539 if (! ((*info->callbacks->undefined_symbol)
540 (info, h->root.root.string, input_bfd,
541 input_section, rel->r_offset, true)))
542 return false;
543
544 ret = false;
545 continue;
546 }
547 }
548
549 switch (r_type)
550 {
551 default:
552 break;
553
554 case R_MCORE_PCRELJSR_IMM11BY2:
555 oldinst = bfd_get_16 (input_bfd, contents + offset);
556 #define MCORE_INST_BSR 0xF800
557 bfd_put_16 (input_bfd, MCORE_INST_BSR, contents + offset);
558 break;
559 }
560
561
562 #ifdef DEBUG
563 fprintf (stderr, "\ttype = %s (%d), symbol index = %ld, offset = %ld, addend = %ld\n",
564 howto->name, r_type, r_symndx, (long) offset, (long) addend);
565 #endif
566
567 r = _bfd_final_link_relocate
568 (howto, input_bfd, input_section, contents, offset, relocation, addend);
569
570 if (r != bfd_reloc_ok && r_type == R_MCORE_PCRELJSR_IMM11BY2)
571 {
572 /* Wasn't ok, back it out and give up. */
573 bfd_put_16 (input_bfd, oldinst, contents + offset);
574 r = bfd_reloc_ok;
575 }
576
577 if (r != bfd_reloc_ok)
578 {
579 ret = false;
580
581 switch (r)
582 {
583 default:
584 break;
585
586 case bfd_reloc_overflow:
587 {
588 const char * name;
589
590 if (h != NULL)
591 name = h->root.root.string;
592 else
593 {
594 name = bfd_elf_string_from_elf_section
595 (input_bfd, symtab_hdr->sh_link, sym->st_name);
596
597 if (name == NULL)
598 break;
599
600 if (* name == '\0')
601 name = bfd_section_name (input_bfd, sec);
602 }
603
604 (*info->callbacks->reloc_overflow)
605 (info, name, howto->name, (bfd_vma) 0, input_bfd, input_section,
606 offset);
607 }
608 break;
609 }
610 }
611 }
612
613 #ifdef DEBUG
614 fprintf (stderr, "\n");
615 #endif
616
617 return ret;
618 }
619 \f
620 /* Return the section that should be marked against GC for a given
621 relocation. */
622
623 static asection *
624 mcore_elf_gc_mark_hook (abfd, info, rel, h, sym)
625 bfd * abfd;
626 struct bfd_link_info * info ATTRIBUTE_UNUSED;
627 Elf_Internal_Rela * rel;
628 struct elf_link_hash_entry * h;
629 Elf_Internal_Sym * sym;
630 {
631 if (h != NULL)
632 {
633 switch (ELF32_R_TYPE (rel->r_info))
634 {
635 case R_MCORE_GNU_VTINHERIT:
636 case R_MCORE_GNU_VTENTRY:
637 break;
638
639 default:
640 switch (h->root.type)
641 {
642 case bfd_link_hash_defined:
643 case bfd_link_hash_defweak:
644 return h->root.u.def.section;
645
646 case bfd_link_hash_common:
647 return h->root.u.c.p->section;
648
649 default:
650 break;
651 }
652 }
653 }
654 else
655 {
656 if (!(elf_bad_symtab (abfd)
657 && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
658 && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
659 && sym->st_shndx != SHN_COMMON))
660 {
661 return bfd_section_from_elf_index (abfd, sym->st_shndx);
662 }
663 }
664
665 return NULL;
666 }
667
668 /* Update the got entry reference counts for the section being removed. */
669
670 static boolean
671 mcore_elf_gc_sweep_hook (abfd, info, sec, relocs)
672 bfd * abfd ATTRIBUTE_UNUSED;
673 struct bfd_link_info * info ATTRIBUTE_UNUSED;
674 asection * sec ATTRIBUTE_UNUSED;
675 const Elf_Internal_Rela * relocs ATTRIBUTE_UNUSED;
676 {
677 return true;
678 }
679
680 /* Look through the relocs for a section during the first phase.
681 Since we don't do .gots or .plts, we just need to consider the
682 virtual table relocs for gc. */
683
684 static boolean
685 mcore_elf_check_relocs (abfd, info, sec, relocs)
686 bfd * abfd;
687 struct bfd_link_info * info;
688 asection * sec;
689 const Elf_Internal_Rela * relocs;
690 {
691 Elf_Internal_Shdr * symtab_hdr;
692 struct elf_link_hash_entry ** sym_hashes;
693 struct elf_link_hash_entry ** sym_hashes_end;
694 const Elf_Internal_Rela * rel;
695 const Elf_Internal_Rela * rel_end;
696
697 if (info->relocateable)
698 return true;
699
700 symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
701 sym_hashes = elf_sym_hashes (abfd);
702 sym_hashes_end = sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
703 if (!elf_bad_symtab (abfd))
704 sym_hashes_end -= symtab_hdr->sh_info;
705
706 rel_end = relocs + sec->reloc_count;
707
708 for (rel = relocs; rel < rel_end; rel++)
709 {
710 struct elf_link_hash_entry * h;
711 unsigned long r_symndx;
712
713 r_symndx = ELF32_R_SYM (rel->r_info);
714
715 if (r_symndx < symtab_hdr->sh_info)
716 h = NULL;
717 else
718 h = sym_hashes [r_symndx - symtab_hdr->sh_info];
719
720 switch (ELF32_R_TYPE (rel->r_info))
721 {
722 /* This relocation describes the C++ object vtable hierarchy.
723 Reconstruct it for later use during GC. */
724 case R_MCORE_GNU_VTINHERIT:
725 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
726 return false;
727 break;
728
729 /* This relocation describes which C++ vtable entries are actually
730 used. Record for later use during GC. */
731 case R_MCORE_GNU_VTENTRY:
732 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
733 return false;
734 break;
735 }
736 }
737
738 return true;
739 }
740
741 #define TARGET_BIG_SYM bfd_elf32_mcore_big_vec
742 #define TARGET_BIG_NAME "elf32-mcore-big"
743 #define TARGET_LITTLE_SYM bfd_elf32_mcore_little_vec
744 #define TARGET_LITTLE_NAME "elf32-mcore-little"
745
746 #define ELF_ARCH bfd_arch_mcore
747 #define ELF_MACHINE_CODE EM_MCORE
748 #define ELF_MAXPAGESIZE 0x1000 /* 4k, if we ever have 'em */
749 #define elf_info_to_howto mcore_elf_info_to_howto
750 #define elf_info_to_howto_rel NULL
751
752
753 #define bfd_elf32_bfd_copy_private_bfd_data mcore_elf_copy_private_bfd_data
754 #define bfd_elf32_bfd_merge_private_bfd_data mcore_elf_merge_private_bfd_data
755 #define bfd_elf32_bfd_set_private_flags mcore_elf_set_private_flags
756 #define bfd_elf32_bfd_reloc_type_lookup mcore_elf_reloc_type_lookup
757 #define elf_backend_relocate_section mcore_elf_relocate_section
758 #define elf_backend_gc_mark_hook mcore_elf_gc_mark_hook
759 #define elf_backend_gc_sweep_hook mcore_elf_gc_sweep_hook
760 #define elf_backend_check_relocs mcore_elf_check_relocs
761
762 #define elf_backend_can_gc_sections 1
763
764 #include "elf32-target.h"
git-cvsimport of binutils cvsroot