1 /* 32-bit ELF support for S+core.
2 Copyright 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
4 Brain.lin (brain.lin@sunplusct.com)
5 Mei Ligang (ligang@sunnorth.com.cn)
6 Pei-Lin Tsai (pltsai@sunplus.com)
8 This file is part of BFD, the Binary File Descriptor library.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
23 MA 02110-1301, USA. */
28 #include "libiberty.h"
30 #include "elf/score.h"
31 #include "elf/common.h"
32 #include "elf/internal.h"
34 #include "elf32-score.h"
37 /* The SCORE ELF linker needs additional information for each symbol in
38 the global hash table. */
39 struct score_elf_link_hash_entry
41 struct elf_link_hash_entry root
;
43 /* Number of R_SCORE_ABS32, R_SCORE_REL32 relocs against this symbol. */
44 unsigned int possibly_dynamic_relocs
;
46 /* If the R_SCORE_ABS32, R_SCORE_REL32 reloc is against a readonly section. */
47 bfd_boolean readonly_reloc
;
49 /* We must not create a stub for a symbol that has relocations related to
50 taking the function's address, i.e. any but R_SCORE_CALL15 ones. */
51 bfd_boolean no_fn_stub
;
53 /* Are we forced local? This will only be set if we have converted
54 the initial global GOT entry to a local GOT entry. */
55 bfd_boolean forced_local
;
58 /* Traverse a score ELF linker hash table. */
59 #define score_elf_link_hash_traverse(table, func, info) \
60 (elf_link_hash_traverse \
62 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
65 /* This structure is used to hold .got entries while estimating got sizes. */
66 struct score_got_entry
68 /* The input bfd in which the symbol is defined. */
70 /* The index of the symbol, as stored in the relocation r_info, if
71 we have a local symbol; -1 otherwise. */
75 /* If abfd == NULL, an address that must be stored in the got. */
77 /* If abfd != NULL && symndx != -1, the addend of the relocation
78 that should be added to the symbol value. */
80 /* If abfd != NULL && symndx == -1, the hash table entry
81 corresponding to a global symbol in the got (or, local, if
83 struct score_elf_link_hash_entry
*h
;
86 /* The offset from the beginning of the .got section to the entry
87 corresponding to this symbol+addend. If it's a global symbol
88 whose offset is yet to be decided, it's going to be -1. */
92 /* This structure is passed to score_elf_sort_hash_table_f when sorting
93 the dynamic symbols. */
94 struct score_elf_hash_sort_data
96 /* The symbol in the global GOT with the lowest dynamic symbol table index. */
97 struct elf_link_hash_entry
*low
;
98 /* The least dynamic symbol table index corresponding to a symbol with a GOT entry. */
100 /* The greatest dynamic symbol table index corresponding to a symbol
101 with a GOT entry that is not referenced (e.g., a dynamic symbol
102 with dynamic relocations pointing to it from non-primary GOTs). */
103 long max_unref_got_dynindx
;
104 /* The greatest dynamic symbol table index not corresponding to a
105 symbol without a GOT entry. */
106 long max_non_got_dynindx
;
109 struct score_got_info
111 /* The global symbol in the GOT with the lowest index in the dynamic
113 struct elf_link_hash_entry
*global_gotsym
;
114 /* The number of global .got entries. */
115 unsigned int global_gotno
;
116 /* The number of local .got entries. */
117 unsigned int local_gotno
;
118 /* The number of local .got entries we have used. */
119 unsigned int assigned_gotno
;
120 /* A hash table holding members of the got. */
121 struct htab
*got_entries
;
122 /* In multi-got links, a pointer to the next got (err, rather, most
123 of the time, it points to the previous got). */
124 struct score_got_info
*next
;
127 /* A structure used to count GOT entries, for GOT entry or ELF symbol table traversal. */
128 struct _score_elf_section_data
130 struct bfd_elf_section_data elf
;
133 struct score_got_info
*got_info
;
139 #define score_elf_section_data(sec) \
140 ((struct _score_elf_section_data *) elf_section_data (sec))
142 /* The size of a symbol-table entry. */
143 #define SCORE_ELF_SYM_SIZE(abfd) \
144 (get_elf_backend_data (abfd)->s->sizeof_sym)
146 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
147 from smaller values. Start with zero, widen, *then* decrement. */
148 #define MINUS_ONE (((bfd_vma)0) - 1)
149 #define MINUS_TWO (((bfd_vma)0) - 2)
154 /* The number of local .got entries we reserve. */
155 #define SCORE_RESERVED_GOTNO (2)
156 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
158 /* The offset of $gp from the beginning of the .got section. */
159 #define ELF_SCORE_GP_OFFSET(abfd) (0x3ff0)
161 /* The maximum size of the GOT for it to be addressable using 15-bit offsets from $gp. */
162 #define SCORE_ELF_GOT_MAX_SIZE(abfd) (ELF_SCORE_GP_OFFSET(abfd) + 0x3fff)
164 #define SCORE_ELF_STUB_SECTION_NAME (".SCORE.stub")
165 #define SCORE_FUNCTION_STUB_SIZE (16)
167 #define STUB_LW 0xc3bcc010 /* lw r29, [r28, -0x3ff0] */
168 #define STUB_MOVE 0x8323bc56 /* mv r25, r3 */
169 #define STUB_LI16 0x87548000 /* ori r26, .dynsym_index */
170 #define STUB_BRL 0x801dbc09 /* brl r29 */
172 #define SCORE_ELF_GOT_SIZE(abfd) \
173 (get_elf_backend_data (abfd)->s->arch_size / 8)
175 #define SCORE_ELF_ADD_DYNAMIC_ENTRY(info, tag, val) \
176 (_bfd_elf_add_dynamic_entry (info, (bfd_vma) tag, (bfd_vma) val))
178 /* The size of an external dynamic table entry. */
179 #define SCORE_ELF_DYN_SIZE(abfd) \
180 (get_elf_backend_data (abfd)->s->sizeof_dyn)
182 /* The size of an external REL relocation. */
183 #define SCORE_ELF_REL_SIZE(abfd) \
184 (get_elf_backend_data (abfd)->s->sizeof_rel)
186 /* The default alignment for sections, as a power of two. */
187 #define SCORE_ELF_LOG_FILE_ALIGN(abfd)\
188 (get_elf_backend_data (abfd)->s->log_file_align)
190 static bfd_byte
*hi16_rel_addr
;
192 /* This will be used when we sort the dynamic relocation records. */
193 static bfd
*reldyn_sorting_bfd
;
195 /* SCORE ELF uses two common sections. One is the usual one, and the
196 other is for small objects. All the small objects are kept
197 together, and then referenced via the gp pointer, which yields
198 faster assembler code. This is what we use for the small common
199 section. This approach is copied from ecoff.c. */
200 static asection score_elf_scom_section
;
201 static asymbol score_elf_scom_symbol
;
202 static asymbol
* score_elf_scom_symbol_ptr
;
204 static bfd_reloc_status_type
205 score_elf_hi16_reloc (bfd
*abfd ATTRIBUTE_UNUSED
,
206 arelent
*reloc_entry
,
207 asymbol
*symbol ATTRIBUTE_UNUSED
,
209 asection
*input_section ATTRIBUTE_UNUSED
,
210 bfd
*output_bfd ATTRIBUTE_UNUSED
,
211 char **error_message ATTRIBUTE_UNUSED
)
213 hi16_rel_addr
= (bfd_byte
*) data
+ reloc_entry
->address
;
217 static bfd_reloc_status_type
218 score_elf_lo16_reloc (bfd
*abfd
,
219 arelent
*reloc_entry
,
220 asymbol
*symbol ATTRIBUTE_UNUSED
,
222 asection
*input_section
,
223 bfd
*output_bfd ATTRIBUTE_UNUSED
,
224 char **error_message ATTRIBUTE_UNUSED
)
226 bfd_vma addend
= 0, offset
= 0;
228 unsigned long hi16_offset
, hi16_value
, uvalue
;
230 hi16_value
= bfd_get_32 (abfd
, hi16_rel_addr
);
231 hi16_offset
= ((((hi16_value
>> 16) & 0x3) << 15) | (hi16_value
& 0x7fff)) >> 1;
232 addend
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
233 offset
= ((((addend
>> 16) & 0x3) << 15) | (addend
& 0x7fff)) >> 1;
234 val
= reloc_entry
->addend
;
235 if (reloc_entry
->address
> input_section
->size
)
236 return bfd_reloc_outofrange
;
237 uvalue
= ((hi16_offset
<< 16) | (offset
& 0xffff)) + val
;
238 hi16_offset
= (uvalue
>> 16) << 1;
239 hi16_value
= (hi16_value
& ~0x37fff) | (hi16_offset
& 0x7fff) | ((hi16_offset
<< 1) & 0x30000);
240 bfd_put_32 (abfd
, hi16_value
, hi16_rel_addr
);
241 offset
= (uvalue
& 0xffff) << 1;
242 addend
= (addend
& ~0x37fff) | (offset
& 0x7fff) | ((offset
<< 1) & 0x30000);
243 bfd_put_32 (abfd
, addend
, (bfd_byte
*) data
+ reloc_entry
->address
);
247 /* Set the GP value for OUTPUT_BFD. Returns FALSE if this is a
248 dangerous relocation. */
251 score_elf_assign_gp (bfd
*output_bfd
, bfd_vma
*pgp
)
257 /* If we've already figured out what GP will be, just return it. */
258 *pgp
= _bfd_get_gp_value (output_bfd
);
262 count
= bfd_get_symcount (output_bfd
);
263 sym
= bfd_get_outsymbols (output_bfd
);
265 /* The linker script will have created a symbol named `_gp' with the
266 appropriate value. */
271 for (i
= 0; i
< count
; i
++, sym
++)
275 name
= bfd_asymbol_name (*sym
);
276 if (*name
== '_' && strcmp (name
, "_gp") == 0)
278 *pgp
= bfd_asymbol_value (*sym
);
279 _bfd_set_gp_value (output_bfd
, *pgp
);
287 /* Only get the error once. */
289 _bfd_set_gp_value (output_bfd
, *pgp
);
296 /* We have to figure out the gp value, so that we can adjust the
297 symbol value correctly. We look up the symbol _gp in the output
298 BFD. If we can't find it, we're stuck. We cache it in the ELF
299 target data. We don't need to adjust the symbol value for an
300 external symbol if we are producing relocatable output. */
302 static bfd_reloc_status_type
303 score_elf_final_gp (bfd
*output_bfd
,
305 bfd_boolean relocatable
,
306 char **error_message
,
309 if (bfd_is_und_section (symbol
->section
)
313 return bfd_reloc_undefined
;
316 *pgp
= _bfd_get_gp_value (output_bfd
);
319 || (symbol
->flags
& BSF_SECTION_SYM
) != 0))
323 /* Make up a value. */
324 *pgp
= symbol
->section
->output_section
->vma
+ 0x4000;
325 _bfd_set_gp_value (output_bfd
, *pgp
);
327 else if (!score_elf_assign_gp (output_bfd
, pgp
))
330 (char *) _("GP relative relocation when _gp not defined");
331 return bfd_reloc_dangerous
;
338 static bfd_reloc_status_type
339 score_elf_gprel15_with_gp (bfd
*abfd
,
341 arelent
*reloc_entry
,
342 asection
*input_section
,
343 bfd_boolean relocateable
,
345 bfd_vma gp ATTRIBUTE_UNUSED
)
350 if (bfd_is_com_section (symbol
->section
))
353 relocation
= symbol
->value
;
355 relocation
+= symbol
->section
->output_section
->vma
;
356 relocation
+= symbol
->section
->output_offset
;
357 if (reloc_entry
->address
> input_section
->size
)
358 return bfd_reloc_outofrange
;
360 insn
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
361 if (((reloc_entry
->addend
& 0xffffc000) != 0)
362 && ((reloc_entry
->addend
& 0xffffc000) != 0xffffc000))
363 return bfd_reloc_overflow
;
365 insn
= (insn
& ~0x7fff) | (reloc_entry
->addend
& 0x7fff);
366 bfd_put_32 (abfd
, insn
, (bfd_byte
*) data
+ reloc_entry
->address
);
368 reloc_entry
->address
+= input_section
->output_offset
;
373 static bfd_reloc_status_type
374 gprel32_with_gp (bfd
*abfd
, asymbol
*symbol
, arelent
*reloc_entry
,
375 asection
*input_section
, bfd_boolean relocatable
,
376 void *data
, bfd_vma gp
)
381 if (bfd_is_com_section (symbol
->section
))
384 relocation
= symbol
->value
;
386 relocation
+= symbol
->section
->output_section
->vma
;
387 relocation
+= symbol
->section
->output_offset
;
389 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
390 return bfd_reloc_outofrange
;
392 /* Set val to the offset into the section or symbol. */
393 val
= reloc_entry
->addend
;
395 if (reloc_entry
->howto
->partial_inplace
)
396 val
+= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
398 /* Adjust val for the final section location and GP value. If we
399 are producing relocatable output, we don't want to do this for
400 an external symbol. */
402 || (symbol
->flags
& BSF_SECTION_SYM
) != 0)
403 val
+= relocation
- gp
;
405 if (reloc_entry
->howto
->partial_inplace
)
406 bfd_put_32 (abfd
, val
, (bfd_byte
*) data
+ reloc_entry
->address
);
408 reloc_entry
->addend
= val
;
411 reloc_entry
->address
+= input_section
->output_offset
;
416 static bfd_reloc_status_type
417 score_elf_gprel15_reloc (bfd
*abfd
,
418 arelent
*reloc_entry
,
421 asection
*input_section
,
423 char **error_message
)
425 bfd_boolean relocateable
;
426 bfd_reloc_status_type ret
;
429 if (output_bfd
!= NULL
430 && (symbol
->flags
& BSF_SECTION_SYM
) == 0 && reloc_entry
->addend
== 0)
432 reloc_entry
->address
+= input_section
->output_offset
;
435 if (output_bfd
!= NULL
)
439 relocateable
= FALSE
;
440 output_bfd
= symbol
->section
->output_section
->owner
;
443 ret
= score_elf_final_gp (output_bfd
, symbol
, relocateable
, error_message
, &gp
);
444 if (ret
!= bfd_reloc_ok
)
447 return score_elf_gprel15_with_gp (abfd
, symbol
, reloc_entry
,
448 input_section
, relocateable
, data
, gp
);
451 /* Do a R_SCORE_GPREL32 relocation. This is a 32 bit value which must
452 become the offset from the gp register. */
454 static bfd_reloc_status_type
455 score_elf_gprel32_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
456 void *data
, asection
*input_section
, bfd
*output_bfd
,
457 char **error_message
)
459 bfd_boolean relocatable
;
460 bfd_reloc_status_type ret
;
463 /* R_SCORE_GPREL32 relocations are defined for local symbols only. */
464 if (output_bfd
!= NULL
465 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
466 && (symbol
->flags
& BSF_LOCAL
) != 0)
468 *error_message
= (char *)
469 _("32bits gp relative relocation occurs for an external symbol");
470 return bfd_reloc_outofrange
;
473 if (output_bfd
!= NULL
)
478 output_bfd
= symbol
->section
->output_section
->owner
;
481 ret
= score_elf_final_gp (output_bfd
, symbol
, relocatable
, error_message
, &gp
);
482 if (ret
!= bfd_reloc_ok
)
486 return gprel32_with_gp (abfd
, symbol
, reloc_entry
, input_section
,
487 relocatable
, data
, gp
);
490 /* A howto special_function for R_SCORE_GOT15 relocations. This is just
491 like any other 16-bit relocation when applied to global symbols, but is
492 treated in the same as R_SCORE_HI16 when applied to local symbols. */
494 static bfd_reloc_status_type
495 score_elf_got15_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
496 void *data
, asection
*input_section
,
497 bfd
*output_bfd
, char **error_message
)
499 if ((symbol
->flags
& (BSF_GLOBAL
| BSF_WEAK
)) != 0
500 || bfd_is_und_section (bfd_get_section (symbol
))
501 || bfd_is_com_section (bfd_get_section (symbol
)))
502 /* The relocation is against a global symbol. */
503 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
504 input_section
, output_bfd
,
507 return score_elf_hi16_reloc (abfd
, reloc_entry
, symbol
, data
,
508 input_section
, output_bfd
, error_message
);
511 static bfd_reloc_status_type
512 score_elf_got_lo16_reloc (bfd
*abfd
,
513 arelent
*reloc_entry
,
514 asymbol
*symbol ATTRIBUTE_UNUSED
,
516 asection
*input_section
,
517 bfd
*output_bfd ATTRIBUTE_UNUSED
,
518 char **error_message ATTRIBUTE_UNUSED
)
520 bfd_vma addend
= 0, offset
= 0;
522 signed long hi16_offset
, hi16_value
, uvalue
;
524 hi16_value
= bfd_get_32 (abfd
, hi16_rel_addr
);
525 hi16_offset
= ((((hi16_value
>> 16) & 0x3) << 15) | (hi16_value
& 0x7fff)) >> 1;
526 addend
= bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
527 offset
= ((((addend
>> 16) & 0x3) << 15) | (addend
& 0x7fff)) >> 1;
528 val
= reloc_entry
->addend
;
529 if (reloc_entry
->address
> input_section
->size
)
530 return bfd_reloc_outofrange
;
531 uvalue
= ((hi16_offset
<< 16) | (offset
& 0xffff)) + val
;
532 if ((uvalue
> -0x8000) && (uvalue
< 0x7fff))
535 hi16_offset
= (uvalue
>> 16) & 0x7fff;
536 hi16_value
= (hi16_value
& ~0x37fff) | (hi16_offset
& 0x7fff) | ((hi16_offset
<< 1) & 0x30000);
537 bfd_put_32 (abfd
, hi16_value
, hi16_rel_addr
);
538 offset
= (uvalue
& 0xffff) << 1;
539 addend
= (addend
& ~0x37fff) | (offset
& 0x7fff) | ((offset
<< 1) & 0x30000);
540 bfd_put_32 (abfd
, addend
, (bfd_byte
*) data
+ reloc_entry
->address
);
544 static reloc_howto_type elf32_score_howto_table
[] =
547 HOWTO (R_SCORE_NONE
, /* type */
549 0, /* size (0 = byte, 1 = short, 2 = long) */
551 FALSE
, /* pc_relative */
553 complain_overflow_dont
,/* complain_on_overflow */
554 bfd_elf_generic_reloc
, /* special_function */
555 "R_SCORE_NONE", /* name */
556 FALSE
, /* partial_inplace */
559 FALSE
), /* pcrel_offset */
562 HOWTO (R_SCORE_HI16
, /* type */
564 2, /* size (0 = byte, 1 = short, 2 = long) */
566 FALSE
, /* pc_relative */
568 complain_overflow_dont
,/* complain_on_overflow */
569 score_elf_hi16_reloc
, /* special_function */
570 "R_SCORE_HI16", /* name */
571 TRUE
, /* partial_inplace */
572 0x37fff, /* src_mask */
573 0x37fff, /* dst_mask */
574 FALSE
), /* pcrel_offset */
577 HOWTO (R_SCORE_LO16
, /* type */
579 2, /* size (0 = byte, 1 = short, 2 = long) */
581 FALSE
, /* pc_relative */
583 complain_overflow_dont
,/* complain_on_overflow */
584 score_elf_lo16_reloc
, /* special_function */
585 "R_SCORE_LO16", /* name */
586 TRUE
, /* partial_inplace */
587 0x37fff, /* src_mask */
588 0x37fff, /* dst_mask */
589 FALSE
), /* pcrel_offset */
592 HOWTO (R_SCORE_BCMP
, /* type */
594 2, /* size (0 = byte, 1 = short, 2 = long) */
596 FALSE
, /* pc_relative */
598 complain_overflow_dont
,/* complain_on_overflow */
599 bfd_elf_generic_reloc
, /* special_function */
600 "R_SCORE_BCMP", /* name */
601 TRUE
, /* partial_inplace */
602 0x0000ffff, /* src_mask */
603 0x0000ffff, /* dst_mask */
604 FALSE
), /* pcrel_offset */
606 HOWTO (R_SCORE_24
, /* type */
608 2, /* size (0 = byte, 1 = short, 2 = long) */
610 FALSE
, /* pc_relative */
612 complain_overflow_dont
,/* complain_on_overflow */
613 bfd_elf_generic_reloc
, /* special_function */
614 "R_SCORE_24", /* name */
615 FALSE
, /* partial_inplace */
616 0x3ff7fff, /* src_mask */
617 0x3ff7fff, /* dst_mask */
618 FALSE
), /* pcrel_offset */
621 HOWTO (R_SCORE_PC19
, /* type */
623 2, /* size (0 = byte, 1 = short, 2 = long) */
625 TRUE
, /* pc_relative */
627 complain_overflow_dont
,/* complain_on_overflow */
628 bfd_elf_generic_reloc
, /* special_function */
629 "R_SCORE_PC19", /* name */
630 FALSE
, /* partial_inplace */
631 0x3ff03fe, /* src_mask */
632 0x3ff03fe, /* dst_mask */
633 FALSE
), /* pcrel_offset */
636 HOWTO (R_SCORE16_11
, /* type */
638 1, /* size (0 = byte, 1 = short, 2 = long) */
640 FALSE
, /* pc_relative */
642 complain_overflow_dont
,/* complain_on_overflow */
643 bfd_elf_generic_reloc
, /* special_function */
644 "R_SCORE16_11", /* name */
645 FALSE
, /* partial_inplace */
646 0x000000ffe, /* src_mask */
647 0x000000ffe, /* dst_mask */
648 FALSE
), /* pcrel_offset */
651 HOWTO (R_SCORE16_PC8
, /* type */
653 1, /* size (0 = byte, 1 = short, 2 = long) */
655 TRUE
, /* pc_relative */
657 complain_overflow_dont
,/* complain_on_overflow */
658 bfd_elf_generic_reloc
, /* special_function */
659 "R_SCORE16_PC8", /* name */
660 FALSE
, /* partial_inplace */
661 0x000000ff, /* src_mask */
662 0x000000ff, /* dst_mask */
663 FALSE
), /* pcrel_offset */
665 /* 32 bit absolute */
666 HOWTO (R_SCORE_ABS32
, /* type 8 */
668 2, /* size (0 = byte, 1 = short, 2 = long) */
670 FALSE
, /* pc_relative */
672 complain_overflow_bitfield
, /* complain_on_overflow */
673 bfd_elf_generic_reloc
, /* special_function */
674 "R_SCORE_ABS32", /* name */
675 FALSE
, /* partial_inplace */
676 0xffffffff, /* src_mask */
677 0xffffffff, /* dst_mask */
678 FALSE
), /* pcrel_offset */
680 /* 16 bit absolute */
681 HOWTO (R_SCORE_ABS16
, /* type 11 */
683 1, /* size (0 = byte, 1 = short, 2 = long) */
685 FALSE
, /* pc_relative */
687 complain_overflow_bitfield
, /* complain_on_overflow */
688 bfd_elf_generic_reloc
, /* special_function */
689 "R_SCORE_ABS16", /* name */
690 FALSE
, /* partial_inplace */
691 0x0000ffff, /* src_mask */
692 0x0000ffff, /* dst_mask */
693 FALSE
), /* pcrel_offset */
696 HOWTO (R_SCORE_DUMMY2
, /* type */
698 2, /* size (0 = byte, 1 = short, 2 = long) */
700 FALSE
, /* pc_relative */
702 complain_overflow_dont
,/* complain_on_overflow */
703 bfd_elf_generic_reloc
, /* special_function */
704 "R_SCORE_DUMMY2", /* name */
705 TRUE
, /* partial_inplace */
706 0x00007fff, /* src_mask */
707 0x00007fff, /* dst_mask */
708 FALSE
), /* pcrel_offset */
711 HOWTO (R_SCORE_GP15
, /* type */
713 2, /* size (0 = byte, 1 = short, 2 = long) */
715 FALSE
, /* pc_relative */
717 complain_overflow_dont
,/* complain_on_overflow */
718 score_elf_gprel15_reloc
,/* special_function */
719 "R_SCORE_GP15", /* name */
720 TRUE
, /* partial_inplace */
721 0x00007fff, /* src_mask */
722 0x00007fff, /* dst_mask */
723 FALSE
), /* pcrel_offset */
725 /* GNU extension to record C++ vtable hierarchy. */
726 HOWTO (R_SCORE_GNU_VTINHERIT
, /* type */
728 2, /* size (0 = byte, 1 = short, 2 = long) */
730 FALSE
, /* pc_relative */
732 complain_overflow_dont
,/* complain_on_overflow */
733 NULL
, /* special_function */
734 "R_SCORE_GNU_VTINHERIT", /* name */
735 FALSE
, /* partial_inplace */
738 FALSE
), /* pcrel_offset */
740 /* GNU extension to record C++ vtable member usage */
741 HOWTO (R_SCORE_GNU_VTENTRY
, /* type */
743 2, /* size (0 = byte, 1 = short, 2 = long) */
745 FALSE
, /* pc_relative */
747 complain_overflow_dont
,/* complain_on_overflow */
748 _bfd_elf_rel_vtable_reloc_fn
, /* special_function */
749 "R_SCORE_GNU_VTENTRY", /* name */
750 FALSE
, /* partial_inplace */
753 FALSE
), /* pcrel_offset */
755 /* Reference to global offset table. */
756 HOWTO (R_SCORE_GOT15
, /* type */
758 2, /* size (0 = byte, 1 = short, 2 = long) */
760 FALSE
, /* pc_relative */
762 complain_overflow_signed
, /* complain_on_overflow */
763 score_elf_got15_reloc
, /* special_function */
764 "R_SCORE_GOT15", /* name */
765 TRUE
, /* partial_inplace */
766 0x00007fff, /* src_mask */
767 0x00007fff, /* dst_mask */
768 FALSE
), /* pcrel_offset */
770 /* Low 16 bits of displacement in global offset table. */
771 HOWTO (R_SCORE_GOT_LO16
, /* type */
773 2, /* size (0 = byte, 1 = short, 2 = long) */
775 FALSE
, /* pc_relative */
777 complain_overflow_dont
,/* complain_on_overflow */
778 score_elf_got_lo16_reloc
, /* special_function */
779 "R_SCORE_GOT_LO16", /* name */
780 TRUE
, /* partial_inplace */
781 0x37ffe, /* src_mask */
782 0x37ffe, /* dst_mask */
783 FALSE
), /* pcrel_offset */
785 /* 15 bit call through global offset table. */
786 HOWTO (R_SCORE_CALL15
, /* type */
788 2, /* size (0 = byte, 1 = short, 2 = long) */
790 FALSE
, /* pc_relative */
792 complain_overflow_signed
, /* complain_on_overflow */
793 bfd_elf_generic_reloc
, /* special_function */
794 "R_SCORE_CALL15", /* name */
795 TRUE
, /* partial_inplace */
796 0x00007fff, /* src_mask */
797 0x00007fff, /* dst_mask */
798 FALSE
), /* pcrel_offset */
800 /* 32 bit GP relative reference. */
801 HOWTO (R_SCORE_GPREL32
, /* type */
803 2, /* size (0 = byte, 1 = short, 2 = long) */
805 FALSE
, /* pc_relative */
807 complain_overflow_dont
,/* complain_on_overflow */
808 score_elf_gprel32_reloc
, /* special_function */
809 "R_SCORE_GPREL32", /* name */
810 TRUE
, /* partial_inplace */
811 0xffffffff, /* src_mask */
812 0xffffffff, /* dst_mask */
813 FALSE
), /* pcrel_offset */
815 /* 32 bit symbol relative relocation. */
816 HOWTO (R_SCORE_REL32
, /* type */
818 2, /* size (0 = byte, 1 = short, 2 = long) */
820 FALSE
, /* pc_relative */
822 complain_overflow_dont
,/* complain_on_overflow */
823 bfd_elf_generic_reloc
, /* special_function */
824 "R_SCORE_REL32", /* name */
825 TRUE
, /* partial_inplace */
826 0xffffffff, /* src_mask */
827 0xffffffff, /* dst_mask */
828 FALSE
), /* pcrel_offset */
830 /* R_SCORE_DUMMY_HI16 */
831 HOWTO (R_SCORE_DUMMY_HI16
, /* type */
833 2, /* size (0 = byte, 1 = short, 2 = long) */
835 FALSE
, /* pc_relative */
837 complain_overflow_dont
,/* complain_on_overflow */
838 score_elf_hi16_reloc
, /* special_function */
839 "R_SCORE_DUMMY_HI16", /* name */
840 TRUE
, /* partial_inplace */
841 0x37fff, /* src_mask */
842 0x37fff, /* dst_mask */
843 FALSE
), /* pcrel_offset */
846 struct score_reloc_map
848 bfd_reloc_code_real_type bfd_reloc_val
;
849 unsigned char elf_reloc_val
;
852 static const struct score_reloc_map elf32_score_reloc_map
[] =
854 {BFD_RELOC_NONE
, R_SCORE_NONE
},
855 {BFD_RELOC_HI16_S
, R_SCORE_HI16
},
856 {BFD_RELOC_LO16
, R_SCORE_LO16
},
857 {BFD_RELOC_SCORE_BCMP
, R_SCORE_BCMP
},
858 {BFD_RELOC_SCORE_JMP
, R_SCORE_24
},
859 {BFD_RELOC_SCORE_BRANCH
, R_SCORE_PC19
},
860 {BFD_RELOC_SCORE16_JMP
, R_SCORE16_11
},
861 {BFD_RELOC_SCORE16_BRANCH
, R_SCORE16_PC8
},
862 {BFD_RELOC_32
, R_SCORE_ABS32
},
863 {BFD_RELOC_16
, R_SCORE_ABS16
},
864 {BFD_RELOC_SCORE_DUMMY2
, R_SCORE_DUMMY2
},
865 {BFD_RELOC_SCORE_GPREL15
, R_SCORE_GP15
},
866 {BFD_RELOC_VTABLE_INHERIT
, R_SCORE_GNU_VTINHERIT
},
867 {BFD_RELOC_VTABLE_ENTRY
, R_SCORE_GNU_VTENTRY
},
868 {BFD_RELOC_SCORE_GOT15
, R_SCORE_GOT15
},
869 {BFD_RELOC_SCORE_GOT_LO16
, R_SCORE_GOT_LO16
},
870 {BFD_RELOC_SCORE_CALL15
, R_SCORE_CALL15
},
871 {BFD_RELOC_GPREL32
, R_SCORE_GPREL32
},
872 {BFD_RELOC_32_PCREL
, R_SCORE_REL32
},
873 {BFD_RELOC_SCORE_DUMMY_HI16
, R_SCORE_DUMMY_HI16
},
876 static INLINE hashval_t
877 score_elf_hash_bfd_vma (bfd_vma addr
)
880 return addr
+ (addr
>> 32);
886 /* got_entries only match if they're identical, except for gotidx, so
887 use all fields to compute the hash, and compare the appropriate
891 score_elf_got_entry_hash (const void *entry_
)
893 const struct score_got_entry
*entry
= (struct score_got_entry
*) entry_
;
896 + (! entry
->abfd
? score_elf_hash_bfd_vma (entry
->d
.address
)
898 + (entry
->symndx
>= 0 ? score_elf_hash_bfd_vma (entry
->d
.addend
)
899 : entry
->d
.h
->root
.root
.root
.hash
));
903 score_elf_got_entry_eq (const void *entry1
, const void *entry2
)
905 const struct score_got_entry
*e1
= (struct score_got_entry
*) entry1
;
906 const struct score_got_entry
*e2
= (struct score_got_entry
*) entry2
;
908 return e1
->abfd
== e2
->abfd
&& e1
->symndx
== e2
->symndx
909 && (! e1
->abfd
? e1
->d
.address
== e2
->d
.address
910 : e1
->symndx
>= 0 ? e1
->d
.addend
== e2
->d
.addend
911 : e1
->d
.h
== e2
->d
.h
);
914 /* If H needs a GOT entry, assign it the highest available dynamic
915 index. Otherwise, assign it the lowest available dynamic
919 score_elf_sort_hash_table_f (struct score_elf_link_hash_entry
*h
, void *data
)
921 struct score_elf_hash_sort_data
*hsd
= data
;
923 /* Symbols without dynamic symbol table entries aren't interesting at all. */
924 if (h
->root
.dynindx
== -1)
927 /* Global symbols that need GOT entries that are not explicitly
928 referenced are marked with got offset 2. Those that are
929 referenced get a 1, and those that don't need GOT entries get
931 if (h
->root
.got
.offset
== 2)
933 if (hsd
->max_unref_got_dynindx
== hsd
->min_got_dynindx
)
934 hsd
->low
= (struct elf_link_hash_entry
*) h
;
935 h
->root
.dynindx
= hsd
->max_unref_got_dynindx
++;
937 else if (h
->root
.got
.offset
!= 1)
938 h
->root
.dynindx
= hsd
->max_non_got_dynindx
++;
941 h
->root
.dynindx
= --hsd
->min_got_dynindx
;
942 hsd
->low
= (struct elf_link_hash_entry
*) h
;
949 score_elf_got_section (bfd
*abfd
, bfd_boolean maybe_excluded
)
951 asection
*sgot
= bfd_get_linker_section (abfd
, ".got");
953 if (sgot
== NULL
|| (! maybe_excluded
&& (sgot
->flags
& SEC_EXCLUDE
) != 0))
958 /* Returns the GOT information associated with the link indicated by
959 INFO. If SGOTP is non-NULL, it is filled in with the GOT section. */
961 static struct score_got_info
*
962 score_elf_got_info (bfd
*abfd
, asection
**sgotp
)
965 struct score_got_info
*g
;
967 sgot
= score_elf_got_section (abfd
, TRUE
);
968 BFD_ASSERT (sgot
!= NULL
);
969 BFD_ASSERT (elf_section_data (sgot
) != NULL
);
970 g
= score_elf_section_data (sgot
)->u
.got_info
;
971 BFD_ASSERT (g
!= NULL
);
978 /* Sort the dynamic symbol table so that symbols that need GOT entries
979 appear towards the end. This reduces the amount of GOT space
980 required. MAX_LOCAL is used to set the number of local symbols
981 known to be in the dynamic symbol table. During
982 s7_bfd_score_elf_size_dynamic_sections, this value is 1. Afterward, the
983 section symbols are added and the count is higher. */
986 score_elf_sort_hash_table (struct bfd_link_info
*info
,
987 unsigned long max_local
)
989 struct score_elf_hash_sort_data hsd
;
990 struct score_got_info
*g
;
993 dynobj
= elf_hash_table (info
)->dynobj
;
995 g
= score_elf_got_info (dynobj
, NULL
);
998 hsd
.max_unref_got_dynindx
=
999 hsd
.min_got_dynindx
= elf_hash_table (info
)->dynsymcount
1000 /* In the multi-got case, assigned_gotno of the master got_info
1001 indicate the number of entries that aren't referenced in the
1002 primary GOT, but that must have entries because there are
1003 dynamic relocations that reference it. Since they aren't
1004 referenced, we move them to the end of the GOT, so that they
1005 don't prevent other entries that are referenced from getting
1006 too large offsets. */
1007 - (g
->next
? g
->assigned_gotno
: 0);
1008 hsd
.max_non_got_dynindx
= max_local
;
1009 score_elf_link_hash_traverse (elf_hash_table (info
),
1010 score_elf_sort_hash_table_f
,
1013 /* There should have been enough room in the symbol table to
1014 accommodate both the GOT and non-GOT symbols. */
1015 BFD_ASSERT (hsd
.max_non_got_dynindx
<= hsd
.min_got_dynindx
);
1016 BFD_ASSERT ((unsigned long) hsd
.max_unref_got_dynindx
1017 <= elf_hash_table (info
)->dynsymcount
);
1019 /* Now we know which dynamic symbol has the lowest dynamic symbol
1020 table index in the GOT. */
1021 g
->global_gotsym
= hsd
.low
;
1026 /* Returns the first relocation of type r_type found, beginning with
1027 RELOCATION. RELEND is one-past-the-end of the relocation table. */
1029 static const Elf_Internal_Rela
*
1030 score_elf_next_relocation (bfd
*abfd ATTRIBUTE_UNUSED
, unsigned int r_type
,
1031 const Elf_Internal_Rela
*relocation
,
1032 const Elf_Internal_Rela
*relend
)
1034 while (relocation
< relend
)
1036 if (ELF32_R_TYPE (relocation
->r_info
) == r_type
)
1042 /* We didn't find it. */
1043 bfd_set_error (bfd_error_bad_value
);
1047 /* This function is called via qsort() to sort the dynamic relocation
1048 entries by increasing r_symndx value. */
1050 score_elf_sort_dynamic_relocs (const void *arg1
, const void *arg2
)
1052 Elf_Internal_Rela int_reloc1
;
1053 Elf_Internal_Rela int_reloc2
;
1055 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd
, arg1
, &int_reloc1
);
1056 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd
, arg2
, &int_reloc2
);
1058 return (ELF32_R_SYM (int_reloc1
.r_info
) - ELF32_R_SYM (int_reloc2
.r_info
));
1061 /* Return whether a relocation is against a local symbol. */
1063 score_elf_local_relocation_p (bfd
*input_bfd
,
1064 const Elf_Internal_Rela
*relocation
,
1065 asection
**local_sections
,
1066 bfd_boolean check_forced
)
1068 unsigned long r_symndx
;
1069 Elf_Internal_Shdr
*symtab_hdr
;
1070 struct score_elf_link_hash_entry
*h
;
1073 r_symndx
= ELF32_R_SYM (relocation
->r_info
);
1074 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1075 extsymoff
= (elf_bad_symtab (input_bfd
)) ? 0 : symtab_hdr
->sh_info
;
1077 if (r_symndx
< extsymoff
)
1079 if (elf_bad_symtab (input_bfd
) && local_sections
[r_symndx
] != NULL
)
1084 /* Look up the hash table to check whether the symbol was forced local. */
1085 h
= (struct score_elf_link_hash_entry
*)
1086 elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
];
1087 /* Find the real hash-table entry for this symbol. */
1088 while (h
->root
.root
.type
== bfd_link_hash_indirect
1089 || h
->root
.root
.type
== bfd_link_hash_warning
)
1090 h
= (struct score_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
1091 if (h
->root
.forced_local
)
1098 /* Returns the dynamic relocation section for DYNOBJ. */
1101 score_elf_rel_dyn_section (bfd
*dynobj
, bfd_boolean create_p
)
1103 static const char dname
[] = ".rel.dyn";
1106 sreloc
= bfd_get_linker_section (dynobj
, dname
);
1107 if (sreloc
== NULL
&& create_p
)
1109 sreloc
= bfd_make_section_anyway_with_flags (dynobj
, dname
,
1114 | SEC_LINKER_CREATED
1117 || ! bfd_set_section_alignment (dynobj
, sreloc
,
1118 SCORE_ELF_LOG_FILE_ALIGN (dynobj
)))
1125 score_elf_allocate_dynamic_relocations (bfd
*abfd
, unsigned int n
)
1129 s
= score_elf_rel_dyn_section (abfd
, FALSE
);
1130 BFD_ASSERT (s
!= NULL
);
1134 /* Make room for a null element. */
1135 s
->size
+= SCORE_ELF_REL_SIZE (abfd
);
1138 s
->size
+= n
* SCORE_ELF_REL_SIZE (abfd
);
1141 /* Create a rel.dyn relocation for the dynamic linker to resolve. REL
1142 is the original relocation, which is now being transformed into a
1143 dynamic relocation. The ADDENDP is adjusted if necessary; the
1144 caller should store the result in place of the original addend. */
1147 score_elf_create_dynamic_relocation (bfd
*output_bfd
,
1148 struct bfd_link_info
*info
,
1149 const Elf_Internal_Rela
*rel
,
1150 struct score_elf_link_hash_entry
*h
,
1152 bfd_vma
*addendp
, asection
*input_section
)
1154 Elf_Internal_Rela outrel
[3];
1159 bfd_boolean defined_p
;
1161 r_type
= ELF32_R_TYPE (rel
->r_info
);
1162 dynobj
= elf_hash_table (info
)->dynobj
;
1163 sreloc
= score_elf_rel_dyn_section (dynobj
, FALSE
);
1164 BFD_ASSERT (sreloc
!= NULL
);
1165 BFD_ASSERT (sreloc
->contents
!= NULL
);
1166 BFD_ASSERT (sreloc
->reloc_count
* SCORE_ELF_REL_SIZE (output_bfd
) < sreloc
->size
);
1168 outrel
[0].r_offset
=
1169 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[0].r_offset
);
1170 outrel
[1].r_offset
=
1171 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[1].r_offset
);
1172 outrel
[2].r_offset
=
1173 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[2].r_offset
);
1175 if (outrel
[0].r_offset
== MINUS_ONE
)
1176 /* The relocation field has been deleted. */
1179 if (outrel
[0].r_offset
== MINUS_TWO
)
1181 /* The relocation field has been converted into a relative value of
1182 some sort. Functions like _bfd_elf_write_section_eh_frame expect
1183 the field to be fully relocated, so add in the symbol's value. */
1188 /* We must now calculate the dynamic symbol table index to use
1189 in the relocation. */
1191 && (! info
->symbolic
|| !h
->root
.def_regular
)
1192 /* h->root.dynindx may be -1 if this symbol was marked to
1194 && h
->root
.dynindx
!= -1)
1196 indx
= h
->root
.dynindx
;
1197 /* ??? glibc's ld.so just adds the final GOT entry to the
1198 relocation field. It therefore treats relocs against
1199 defined symbols in the same way as relocs against
1200 undefined symbols. */
1209 /* If the relocation was previously an absolute relocation and
1210 this symbol will not be referred to by the relocation, we must
1211 adjust it by the value we give it in the dynamic symbol table.
1212 Otherwise leave the job up to the dynamic linker. */
1213 if (defined_p
&& r_type
!= R_SCORE_REL32
)
1216 /* The relocation is always an REL32 relocation because we don't
1217 know where the shared library will wind up at load-time. */
1218 outrel
[0].r_info
= ELF32_R_INFO ((unsigned long) indx
, R_SCORE_REL32
);
1220 /* For strict adherence to the ABI specification, we should
1221 generate a R_SCORE_64 relocation record by itself before the
1222 _REL32/_64 record as well, such that the addend is read in as
1223 a 64-bit value (REL32 is a 32-bit relocation, after all).
1224 However, since none of the existing ELF64 SCORE dynamic
1225 loaders seems to care, we don't waste space with these
1226 artificial relocations. If this turns out to not be true,
1227 score_elf_allocate_dynamic_relocations() should be tweaked so
1228 as to make room for a pair of dynamic relocations per
1229 invocation if ABI_64_P, and here we should generate an
1230 additional relocation record with R_SCORE_64 by itself for a
1231 NULL symbol before this relocation record. */
1232 outrel
[1].r_info
= ELF32_R_INFO (0, R_SCORE_NONE
);
1233 outrel
[2].r_info
= ELF32_R_INFO (0, R_SCORE_NONE
);
1235 /* Adjust the output offset of the relocation to reference the
1236 correct location in the output file. */
1237 outrel
[0].r_offset
+= (input_section
->output_section
->vma
1238 + input_section
->output_offset
);
1239 outrel
[1].r_offset
+= (input_section
->output_section
->vma
1240 + input_section
->output_offset
);
1241 outrel
[2].r_offset
+= (input_section
->output_section
->vma
1242 + input_section
->output_offset
);
1244 /* Put the relocation back out. We have to use the special
1245 relocation outputter in the 64-bit case since the 64-bit
1246 relocation format is non-standard. */
1247 bfd_elf32_swap_reloc_out
1248 (output_bfd
, &outrel
[0],
1249 (sreloc
->contents
+ sreloc
->reloc_count
* sizeof (Elf32_External_Rel
)));
1251 /* We've now added another relocation. */
1252 ++sreloc
->reloc_count
;
1254 /* Make sure the output section is writable. The dynamic linker
1255 will be writing to it. */
1256 elf_section_data (input_section
->output_section
)->this_hdr
.sh_flags
|= SHF_WRITE
;
1262 score_elf_create_got_section (bfd
*abfd
,
1263 struct bfd_link_info
*info
,
1264 bfd_boolean maybe_exclude
)
1268 struct elf_link_hash_entry
*h
;
1269 struct bfd_link_hash_entry
*bh
;
1270 struct score_got_info
*g
;
1273 /* This function may be called more than once. */
1274 s
= score_elf_got_section (abfd
, TRUE
);
1277 if (! maybe_exclude
)
1278 s
->flags
&= ~SEC_EXCLUDE
;
1282 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
1285 flags
|= SEC_EXCLUDE
;
1287 /* We have to use an alignment of 2**4 here because this is hardcoded
1288 in the function stub generation and in the linker script. */
1289 s
= bfd_make_section_anyway_with_flags (abfd
, ".got", flags
);
1291 || ! bfd_set_section_alignment (abfd
, s
, 4))
1294 /* Define the symbol _GLOBAL_OFFSET_TABLE_. We don't do this in the
1295 linker script because we don't want to define the symbol if we
1296 are not creating a global offset table. */
1298 if (! (_bfd_generic_link_add_one_symbol
1299 (info
, abfd
, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL
, s
,
1300 0, NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
1303 h
= (struct elf_link_hash_entry
*) bh
;
1306 h
->type
= STT_OBJECT
;
1308 if (info
->shared
&& ! bfd_elf_link_record_dynamic_symbol (info
, h
))
1311 amt
= sizeof (struct score_got_info
);
1312 g
= bfd_alloc (abfd
, amt
);
1316 g
->global_gotsym
= NULL
;
1317 g
->global_gotno
= 0;
1319 g
->local_gotno
= SCORE_RESERVED_GOTNO
;
1320 g
->assigned_gotno
= SCORE_RESERVED_GOTNO
;
1323 g
->got_entries
= htab_try_create (1, score_elf_got_entry_hash
,
1324 score_elf_got_entry_eq
, NULL
);
1325 if (g
->got_entries
== NULL
)
1327 score_elf_section_data (s
)->u
.got_info
= g
;
1328 score_elf_section_data (s
)->elf
.this_hdr
.sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_SCORE_GPREL
;
1333 /* Calculate the %high function. */
1336 score_elf_high (bfd_vma value
)
1338 return ((value
+ (bfd_vma
) 0x8000) >> 16) & 0xffff;
1341 /* Create a local GOT entry for VALUE. Return the index of the entry,
1342 or -1 if it could not be created. */
1344 static struct score_got_entry
*
1345 score_elf_create_local_got_entry (bfd
*abfd
,
1346 bfd
*ibfd ATTRIBUTE_UNUSED
,
1347 struct score_got_info
*gg
,
1348 asection
*sgot
, bfd_vma value
,
1349 unsigned long r_symndx ATTRIBUTE_UNUSED
,
1350 struct score_elf_link_hash_entry
*h ATTRIBUTE_UNUSED
,
1351 int r_type ATTRIBUTE_UNUSED
)
1353 struct score_got_entry entry
, **loc
;
1354 struct score_got_info
*g
;
1358 entry
.d
.address
= value
;
1361 loc
= (struct score_got_entry
**) htab_find_slot (g
->got_entries
, &entry
, INSERT
);
1365 entry
.gotidx
= SCORE_ELF_GOT_SIZE (abfd
) * g
->assigned_gotno
++;
1367 *loc
= bfd_alloc (abfd
, sizeof entry
);
1372 memcpy (*loc
, &entry
, sizeof entry
);
1374 if (g
->assigned_gotno
>= g
->local_gotno
)
1376 (*loc
)->gotidx
= -1;
1377 /* We didn't allocate enough space in the GOT. */
1378 (*_bfd_error_handler
)
1379 (_("not enough GOT space for local GOT entries"));
1380 bfd_set_error (bfd_error_bad_value
);
1384 bfd_put_32 (abfd
, value
, (sgot
->contents
+ entry
.gotidx
));
1389 /* Find a GOT entry whose higher-order 16 bits are the same as those
1390 for value. Return the index into the GOT for this entry. */
1393 score_elf_got16_entry (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
1394 bfd_vma value
, bfd_boolean external
)
1397 struct score_got_info
*g
;
1398 struct score_got_entry
*entry
;
1402 /* Although the ABI says that it is "the high-order 16 bits" that we
1403 want, it is really the %high value. The complete value is
1404 calculated with a `addiu' of a LO16 relocation, just as with a
1406 value
= score_elf_high (value
) << 16;
1409 g
= score_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
1411 entry
= score_elf_create_local_got_entry (abfd
, ibfd
, g
, sgot
, value
, 0, NULL
,
1414 return entry
->gotidx
;
1420 s7_bfd_score_elf_hide_symbol (struct bfd_link_info
*info
,
1421 struct elf_link_hash_entry
*entry
,
1422 bfd_boolean force_local
)
1426 struct score_got_info
*g
;
1427 struct score_elf_link_hash_entry
*h
;
1429 h
= (struct score_elf_link_hash_entry
*) entry
;
1430 if (h
->forced_local
)
1432 h
->forced_local
= TRUE
;
1434 dynobj
= elf_hash_table (info
)->dynobj
;
1435 if (dynobj
!= NULL
&& force_local
)
1437 got
= score_elf_got_section (dynobj
, FALSE
);
1440 g
= score_elf_section_data (got
)->u
.got_info
;
1444 struct score_got_entry e
;
1445 struct score_got_info
*gg
= g
;
1447 /* Since we're turning what used to be a global symbol into a
1448 local one, bump up the number of local entries of each GOT
1449 that had an entry for it. This will automatically decrease
1450 the number of global entries, since global_gotno is actually
1451 the upper limit of global entries. */
1456 for (g
= g
->next
; g
!= gg
; g
= g
->next
)
1457 if (htab_find (g
->got_entries
, &e
))
1459 BFD_ASSERT (g
->global_gotno
> 0);
1464 /* If this was a global symbol forced into the primary GOT, we
1465 no longer need an entry for it. We can't release the entry
1466 at this point, but we must at least stop counting it as one
1467 of the symbols that required a forced got entry. */
1468 if (h
->root
.got
.offset
== 2)
1470 BFD_ASSERT (gg
->assigned_gotno
> 0);
1471 gg
->assigned_gotno
--;
1474 else if (g
->global_gotno
== 0 && g
->global_gotsym
== NULL
)
1475 /* If we haven't got through GOT allocation yet, just bump up the
1476 number of local entries, as this symbol won't be counted as
1479 else if (h
->root
.got
.offset
== 1)
1481 /* If we're past non-multi-GOT allocation and this symbol had
1482 been marked for a global got entry, give it a local entry
1484 BFD_ASSERT (g
->global_gotno
> 0);
1490 _bfd_elf_link_hash_hide_symbol (info
, &h
->root
, force_local
);
1493 /* If H is a symbol that needs a global GOT entry, but has a dynamic
1494 symbol table index lower than any we've seen to date, record it for
1498 score_elf_record_global_got_symbol (struct elf_link_hash_entry
*h
,
1500 struct bfd_link_info
*info
,
1501 struct score_got_info
*g
)
1503 struct score_got_entry entry
, **loc
;
1505 /* A global symbol in the GOT must also be in the dynamic symbol table. */
1506 if (h
->dynindx
== -1)
1508 switch (ELF_ST_VISIBILITY (h
->other
))
1512 s7_bfd_score_elf_hide_symbol (info
, h
, TRUE
);
1515 if (!bfd_elf_link_record_dynamic_symbol (info
, h
))
1521 entry
.d
.h
= (struct score_elf_link_hash_entry
*) h
;
1523 loc
= (struct score_got_entry
**) htab_find_slot (g
->got_entries
, &entry
, INSERT
);
1525 /* If we've already marked this entry as needing GOT space, we don't
1526 need to do it again. */
1530 *loc
= bfd_alloc (abfd
, sizeof entry
);
1536 memcpy (*loc
, &entry
, sizeof (entry
));
1538 if (h
->got
.offset
!= MINUS_ONE
)
1541 /* By setting this to a value other than -1, we are indicating that
1542 there needs to be a GOT entry for H. Avoid using zero, as the
1543 generic ELF copy_indirect_symbol tests for <= 0. */
1549 /* Reserve space in G for a GOT entry containing the value of symbol
1550 SYMNDX in input bfd ABDF, plus ADDEND. */
1553 score_elf_record_local_got_symbol (bfd
*abfd
,
1556 struct score_got_info
*g
)
1558 struct score_got_entry entry
, **loc
;
1561 entry
.symndx
= symndx
;
1562 entry
.d
.addend
= addend
;
1563 loc
= (struct score_got_entry
**) htab_find_slot (g
->got_entries
, &entry
, INSERT
);
1568 entry
.gotidx
= g
->local_gotno
++;
1570 *loc
= bfd_alloc (abfd
, sizeof(entry
));
1574 memcpy (*loc
, &entry
, sizeof (entry
));
1579 /* Returns the GOT offset at which the indicated address can be found.
1580 If there is not yet a GOT entry for this value, create one.
1581 Returns -1 if no satisfactory GOT offset can be found. */
1584 score_elf_local_got_index (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
1585 bfd_vma value
, unsigned long r_symndx
,
1586 struct score_elf_link_hash_entry
*h
, int r_type
)
1589 struct score_got_info
*g
;
1590 struct score_got_entry
*entry
;
1592 g
= score_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
1594 entry
= score_elf_create_local_got_entry (abfd
, ibfd
, g
, sgot
, value
,
1595 r_symndx
, h
, r_type
);
1600 return entry
->gotidx
;
1603 /* Returns the GOT index for the global symbol indicated by H. */
1606 score_elf_global_got_index (bfd
*abfd
, struct elf_link_hash_entry
*h
)
1610 struct score_got_info
*g
;
1611 long global_got_dynindx
= 0;
1613 g
= score_elf_got_info (abfd
, &sgot
);
1614 if (g
->global_gotsym
!= NULL
)
1615 global_got_dynindx
= g
->global_gotsym
->dynindx
;
1617 /* Once we determine the global GOT entry with the lowest dynamic
1618 symbol table index, we must put all dynamic symbols with greater
1619 indices into the GOT. That makes it easy to calculate the GOT
1621 BFD_ASSERT (h
->dynindx
>= global_got_dynindx
);
1622 got_index
= ((h
->dynindx
- global_got_dynindx
+ g
->local_gotno
) * SCORE_ELF_GOT_SIZE (abfd
));
1623 BFD_ASSERT (got_index
< sgot
->size
);
1628 /* Returns the offset for the entry at the INDEXth position in the GOT. */
1631 score_elf_got_offset_from_index (bfd
*dynobj
,
1633 bfd
*input_bfd ATTRIBUTE_UNUSED
,
1639 score_elf_got_info (dynobj
, &sgot
);
1640 gp
= _bfd_get_gp_value (output_bfd
);
1642 return sgot
->output_section
->vma
+ sgot
->output_offset
+ got_index
- gp
;
1645 /* Follow indirect and warning hash entries so that each got entry
1646 points to the final symbol definition. P must point to a pointer
1647 to the hash table we're traversing. Since this traversal may
1648 modify the hash table, we set this pointer to NULL to indicate
1649 we've made a potentially-destructive change to the hash table, so
1650 the traversal must be restarted. */
1653 score_elf_resolve_final_got_entry (void **entryp
, void *p
)
1655 struct score_got_entry
*entry
= (struct score_got_entry
*) *entryp
;
1656 htab_t got_entries
= *(htab_t
*) p
;
1658 if (entry
->abfd
!= NULL
&& entry
->symndx
== -1)
1660 struct score_elf_link_hash_entry
*h
= entry
->d
.h
;
1662 while (h
->root
.root
.type
== bfd_link_hash_indirect
1663 || h
->root
.root
.type
== bfd_link_hash_warning
)
1664 h
= (struct score_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
1666 if (entry
->d
.h
== h
)
1671 /* If we can't find this entry with the new bfd hash, re-insert
1672 it, and get the traversal restarted. */
1673 if (! htab_find (got_entries
, entry
))
1675 htab_clear_slot (got_entries
, entryp
);
1676 entryp
= htab_find_slot (got_entries
, entry
, INSERT
);
1679 /* Abort the traversal, since the whole table may have
1680 moved, and leave it up to the parent to restart the
1682 *(htab_t
*) p
= NULL
;
1685 /* We might want to decrement the global_gotno count, but it's
1686 either too early or too late for that at this point. */
1692 /* Turn indirect got entries in a got_entries table into their final locations. */
1695 score_elf_resolve_final_got_entries (struct score_got_info
*g
)
1701 got_entries
= g
->got_entries
;
1703 htab_traverse (got_entries
,
1704 score_elf_resolve_final_got_entry
,
1707 while (got_entries
== NULL
);
1710 /* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS. for -r */
1713 score_elf_add_to_rel (bfd
*abfd
,
1715 reloc_howto_type
*howto
,
1716 bfd_signed_vma increment
)
1718 bfd_signed_vma addend
;
1720 unsigned long offset
;
1721 unsigned long r_type
= howto
->type
;
1722 unsigned long hi16_addend
, hi16_offset
, hi16_value
, uvalue
;
1724 contents
= bfd_get_32 (abfd
, address
);
1725 /* Get the (signed) value from the instruction. */
1726 addend
= contents
& howto
->src_mask
;
1727 if (addend
& ((howto
->src_mask
+ 1) >> 1))
1729 bfd_signed_vma mask
;
1732 mask
&= ~howto
->src_mask
;
1735 /* Add in the increment, (which is a byte value). */
1740 (((contents
& howto
->src_mask
) & 0x3ff0000) >> 6) | ((contents
& howto
->src_mask
) & 0x3ff);
1741 offset
+= increment
;
1743 (contents
& ~howto
->
1744 src_mask
) | (((offset
<< 6) & howto
->src_mask
) & 0x3ff0000) | (offset
& 0x3ff);
1745 bfd_put_32 (abfd
, contents
, address
);
1750 hi16_addend
= bfd_get_32 (abfd
, address
- 4);
1751 hi16_offset
= ((((hi16_addend
>> 16) & 0x3) << 15) | (hi16_addend
& 0x7fff)) >> 1;
1752 offset
= ((((contents
>> 16) & 0x3) << 15) | (contents
& 0x7fff)) >> 1;
1753 offset
= (hi16_offset
<< 16) | (offset
& 0xffff);
1754 uvalue
= increment
+ offset
;
1755 hi16_offset
= (uvalue
>> 16) << 1;
1756 hi16_value
= (hi16_addend
& (~(howto
->dst_mask
)))
1757 | (hi16_offset
& 0x7fff) | ((hi16_offset
<< 1) & 0x30000);
1758 bfd_put_32 (abfd
, hi16_value
, address
- 4);
1759 offset
= (uvalue
& 0xffff) << 1;
1760 contents
= (contents
& (~(howto
->dst_mask
))) | (offset
& 0x7fff) | ((offset
<< 1) & 0x30000);
1761 bfd_put_32 (abfd
, contents
, address
);
1765 (((contents
& howto
->src_mask
) >> 1) & 0x1ff8000) | ((contents
& howto
->src_mask
) & 0x7fff);
1766 offset
+= increment
;
1768 (contents
& ~howto
->
1769 src_mask
) | (((offset
<< 1) & howto
->src_mask
) & 0x3ff0000) | (offset
& 0x7fff);
1770 bfd_put_32 (abfd
, contents
, address
);
1774 contents
= bfd_get_16 (abfd
, address
);
1775 offset
= contents
& howto
->src_mask
;
1776 offset
+= increment
;
1777 contents
= (contents
& ~howto
->src_mask
) | (offset
& howto
->src_mask
);
1778 bfd_put_16 (abfd
, contents
, address
);
1783 contents
= bfd_get_16 (abfd
, address
);
1784 offset
= (contents
& howto
->src_mask
) + ((increment
>> 1) & 0xff);
1785 contents
= (contents
& (~howto
->src_mask
)) | (offset
& howto
->src_mask
);
1786 bfd_put_16 (abfd
, contents
, address
);
1790 case R_SCORE_GOT_LO16
:
1794 addend
+= increment
;
1795 contents
= (contents
& ~howto
->dst_mask
) | (addend
& howto
->dst_mask
);
1796 bfd_put_32 (abfd
, contents
, address
);
1801 /* Perform a relocation as part of a final link. */
1803 static bfd_reloc_status_type
1804 score_elf_final_link_relocate (reloc_howto_type
*howto
,
1807 asection
*input_section
,
1809 Elf_Internal_Rela
*rel
,
1810 Elf_Internal_Rela
*relocs
,
1812 struct bfd_link_info
*info
,
1813 const char *sym_name ATTRIBUTE_UNUSED
,
1814 int sym_flags ATTRIBUTE_UNUSED
,
1815 struct score_elf_link_hash_entry
*h
,
1816 Elf_Internal_Sym
*local_syms
,
1817 asection
**local_sections
,
1818 bfd_boolean gp_disp_p
)
1820 unsigned long r_type
;
1821 unsigned long r_symndx
;
1822 bfd_byte
*hit_data
= contents
+ rel
->r_offset
;
1824 /* The final GP value to be used for the relocatable, executable, or
1825 shared object file being produced. */
1826 bfd_vma gp
= MINUS_ONE
;
1827 /* The place (section offset or address) of the storage unit being relocated. */
1829 /* The value of GP used to create the relocatable object. */
1830 bfd_vma gp0
= MINUS_ONE
;
1831 /* The offset into the global offset table at which the address of the relocation entry
1832 symbol, adjusted by the addend, resides during execution. */
1833 bfd_vma g
= MINUS_ONE
;
1834 /* TRUE if the symbol referred to by this relocation is a local symbol. */
1835 bfd_boolean local_p
;
1836 /* The eventual value we will relocate. */
1837 bfd_vma value
= symbol
;
1838 unsigned long hi16_addend
, hi16_offset
, hi16_value
, uvalue
, offset
, abs_value
= 0;
1840 Elf_Internal_Sym
*sym
= 0;
1841 asection
*sec
= NULL
;
1842 bfd_boolean merge_p
= 0;
1845 if (elf_gp (output_bfd
) == 0)
1847 struct bfd_link_hash_entry
*bh
;
1850 bh
= bfd_link_hash_lookup (info
->hash
, "_gp", 0, 0, 1);
1851 if (bh
!= NULL
&& bh
->type
== bfd_link_hash_defined
)
1852 elf_gp (output_bfd
) = (bh
->u
.def
.value
1853 + bh
->u
.def
.section
->output_section
->vma
1854 + bh
->u
.def
.section
->output_offset
);
1855 else if (info
->relocatable
)
1859 /* Find the GP-relative section with the lowest offset. */
1860 for (o
= output_bfd
->sections
; o
!= NULL
; o
= o
->next
)
1863 /* And calculate GP relative to that. */
1864 elf_gp (output_bfd
) = lo
+ ELF_SCORE_GP_OFFSET (input_bfd
);
1868 /* If the relocate_section function needs to do a reloc
1869 involving the GP value, it should make a reloc_dangerous
1870 callback to warn that GP is not defined. */
1874 /* Parse the relocation. */
1875 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1876 r_type
= ELF32_R_TYPE (rel
->r_info
);
1877 rel_addr
= (input_section
->output_section
->vma
+ input_section
->output_offset
+ rel
->r_offset
);
1879 /* For hidden symbol. */
1880 local_p
= score_elf_local_relocation_p (input_bfd
, rel
, local_sections
, FALSE
);
1883 sym
= local_syms
+ r_symndx
;
1884 sec
= local_sections
[r_symndx
];
1886 symbol
= sec
->output_section
->vma
+ sec
->output_offset
;
1887 if (ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
1888 || (sec
->flags
& SEC_MERGE
))
1889 symbol
+= sym
->st_value
;
1890 if ((sec
->flags
& SEC_MERGE
)
1891 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
1895 if (r_type
== R_SCORE_GOT15
)
1897 const Elf_Internal_Rela
*relend
;
1898 const Elf_Internal_Rela
*lo16_rel
;
1899 const struct elf_backend_data
*bed
;
1900 bfd_vma lo_value
= 0;
1902 bed
= get_elf_backend_data (output_bfd
);
1903 relend
= relocs
+ input_section
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
1904 lo16_rel
= score_elf_next_relocation (input_bfd
, R_SCORE_GOT_LO16
, rel
, relend
);
1905 if ((local_p
) && (lo16_rel
!= NULL
))
1908 tmp
= bfd_get_32 (input_bfd
, contents
+ lo16_rel
->r_offset
);
1909 lo_value
= (((tmp
>> 16) & 0x3) << 14) | ((tmp
& 0x7fff) >> 1);
1912 asection
*msec
= sec
;
1913 lo_value
= _bfd_elf_rel_local_sym (output_bfd
, sym
, &msec
, lo_value
);
1915 lo_value
+= msec
->output_section
->vma
+ msec
->output_offset
;
1922 addend
= (bfd_get_32 (input_bfd
, hit_data
) >> howto
->bitpos
) & howto
->src_mask
;
1925 /* Figure out the value of the symbol. */
1926 if (local_p
&& !merge_p
)
1928 if (r_type
== R_SCORE_GOT15
)
1930 const Elf_Internal_Rela
*relend
;
1931 const Elf_Internal_Rela
*lo16_rel
;
1932 const struct elf_backend_data
*bed
;
1933 bfd_vma lo_value
= 0;
1935 value
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
1936 addend
= value
& 0x7fff;
1937 if ((addend
& 0x4000) == 0x4000)
1938 addend
|= 0xffffc000;
1940 bed
= get_elf_backend_data (output_bfd
);
1941 relend
= relocs
+ input_section
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
1942 lo16_rel
= score_elf_next_relocation (input_bfd
, R_SCORE_GOT_LO16
, rel
, relend
);
1943 if ((local_p
) && (lo16_rel
!= NULL
))
1946 tmp
= bfd_get_32 (input_bfd
, contents
+ lo16_rel
->r_offset
);
1947 lo_value
= (((tmp
>> 16) & 0x3) << 14) | ((tmp
& 0x7fff) >> 1);
1955 local_p
= score_elf_local_relocation_p (input_bfd
, rel
, local_sections
, TRUE
);
1957 /* If we haven't already determined the GOT offset, or the GP value,
1958 and we're going to need it, get it now. */
1961 case R_SCORE_CALL15
:
1965 g
= score_elf_global_got_index (elf_hash_table (info
)->dynobj
,
1966 (struct elf_link_hash_entry
*) h
);
1967 if ((! elf_hash_table(info
)->dynamic_sections_created
1969 && (info
->symbolic
|| h
->root
.dynindx
== -1)
1970 && h
->root
.def_regular
)))
1972 /* This is a static link or a -Bsymbolic link. The
1973 symbol is defined locally, or was forced to be local.
1974 We must initialize this entry in the GOT. */
1975 bfd
*tmpbfd
= elf_hash_table (info
)->dynobj
;
1976 asection
*sgot
= score_elf_got_section (tmpbfd
, FALSE
);
1977 bfd_put_32 (tmpbfd
, value
, sgot
->contents
+ g
);
1980 else if (r_type
== R_SCORE_GOT15
|| r_type
== R_SCORE_CALL15
)
1982 /* There's no need to create a local GOT entry here; the
1983 calculation for a local GOT15 entry does not involve G. */
1988 g
= score_elf_local_got_index (output_bfd
, input_bfd
, info
,
1989 symbol
+ addend
, r_symndx
, h
, r_type
);
1991 return bfd_reloc_outofrange
;
1994 /* Convert GOT indices to actual offsets. */
1995 g
= score_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
1996 output_bfd
, input_bfd
, g
);
2001 case R_SCORE_GPREL32
:
2002 gp0
= _bfd_get_gp_value (input_bfd
);
2003 gp
= _bfd_get_gp_value (output_bfd
);
2007 gp
= _bfd_get_gp_value (output_bfd
);
2016 return bfd_reloc_ok
;
2021 || (elf_hash_table (info
)->dynamic_sections_created
2023 && h
->root
.def_dynamic
2024 && !h
->root
.def_regular
))
2025 && r_symndx
!= STN_UNDEF
2026 && (input_section
->flags
& SEC_ALLOC
) != 0)
2028 /* If we're creating a shared library, or this relocation is against a symbol
2029 in a shared library, then we can't know where the symbol will end up.
2030 So, we create a relocation record in the output, and leave the job up
2031 to the dynamic linker. */
2033 if (!score_elf_create_dynamic_relocation (output_bfd
, info
, rel
, h
,
2036 return bfd_reloc_undefined
;
2038 else if (r_symndx
== STN_UNDEF
)
2039 /* r_symndx will be STN_UNDEF (zero) only for relocs against symbols
2040 from removed linkonce sections, or sections discarded by
2045 if (r_type
!= R_SCORE_REL32
)
2046 value
= symbol
+ addend
;
2050 value
&= howto
->dst_mask
;
2051 bfd_put_32 (input_bfd
, value
, hit_data
);
2052 return bfd_reloc_ok
;
2056 if ((long) value
> 0x7fff || (long) value
< -0x8000)
2057 return bfd_reloc_overflow
;
2058 bfd_put_16 (input_bfd
, value
, hit_data
);
2059 return bfd_reloc_ok
;
2062 addend
= bfd_get_32 (input_bfd
, hit_data
);
2063 offset
= (((addend
& howto
->src_mask
) >> 1) & 0x1ff8000) | ((addend
& howto
->src_mask
) & 0x7fff);
2064 if ((offset
& 0x1000000) != 0)
2065 offset
|= 0xfe000000;
2067 abs_value
= abs (value
- rel_addr
);
2068 if ((abs_value
& 0xfe000000) != 0)
2069 return bfd_reloc_overflow
;
2070 addend
= (addend
& ~howto
->src_mask
)
2071 | (((value
<< 1) & howto
->src_mask
) & 0x3ff0000) | (value
& 0x7fff);
2072 bfd_put_32 (input_bfd
, addend
, hit_data
);
2073 return bfd_reloc_ok
;
2076 addend
= bfd_get_32 (input_bfd
, hit_data
);
2077 offset
= (((addend
& howto
->src_mask
) & 0x3ff0000) >> 6) | ((addend
& howto
->src_mask
) & 0x3ff);
2078 if ((offset
& 0x80000) != 0)
2079 offset
|= 0xfff00000;
2080 abs_value
= value
= value
- rel_addr
+ offset
;
2081 /* exceed 20 bit : overflow. */
2082 if ((abs_value
& 0x80000000) == 0x80000000)
2083 abs_value
= 0xffffffff - value
+ 1;
2084 if ((abs_value
& 0xfff80000) != 0)
2085 return bfd_reloc_overflow
;
2086 addend
= (addend
& ~howto
->src_mask
)
2087 | (((value
<< 6) & howto
->src_mask
) & 0x3ff0000) | (value
& 0x3ff);
2088 bfd_put_32 (input_bfd
, addend
, hit_data
);
2089 return bfd_reloc_ok
;
2092 addend
= bfd_get_16 (input_bfd
, hit_data
);
2093 offset
= addend
& howto
->src_mask
;
2094 if ((offset
& 0x800) != 0) /* Offset is negative. */
2095 offset
|= 0xfffff000;
2097 abs_value
= abs (value
- rel_addr
);
2098 if ((abs_value
& 0xfffff000) != 0)
2099 return bfd_reloc_overflow
;
2100 addend
= (addend
& ~howto
->src_mask
) | (value
& howto
->src_mask
);
2101 bfd_put_16 (input_bfd
, addend
, hit_data
);
2102 return bfd_reloc_ok
;
2105 addend
= bfd_get_16 (input_bfd
, hit_data
);
2106 offset
= (addend
& howto
->src_mask
) << 1;
2107 if ((offset
& 0x100) != 0) /* Offset is negative. */
2108 offset
|= 0xfffffe00;
2109 abs_value
= value
= value
- rel_addr
+ offset
;
2110 /* Sign bit + exceed 9 bit. */
2111 if (((value
& 0xffffff00) != 0) && ((value
& 0xffffff00) != 0xffffff00))
2112 return bfd_reloc_overflow
;
2114 addend
= (addend
& ~howto
->src_mask
) | (value
& howto
->src_mask
);
2115 bfd_put_16 (input_bfd
, addend
, hit_data
);
2116 return bfd_reloc_ok
;
2119 return bfd_reloc_ok
;
2122 hi16_addend
= bfd_get_32 (input_bfd
, hit_data
- 4);
2123 hi16_offset
= ((((hi16_addend
>> 16) & 0x3) << 15) | (hi16_addend
& 0x7fff)) >> 1;
2124 addend
= bfd_get_32 (input_bfd
, hit_data
);
2125 offset
= ((((addend
>> 16) & 0x3) << 15) | (addend
& 0x7fff)) >> 1;
2126 offset
= (hi16_offset
<< 16) | (offset
& 0xffff);
2129 uvalue
= value
+ offset
;
2131 uvalue
= offset
+ gp
- rel_addr
+ 4;
2133 hi16_offset
= (uvalue
>> 16) << 1;
2134 hi16_value
= (hi16_addend
& (~(howto
->dst_mask
)))
2135 | (hi16_offset
& 0x7fff) | ((hi16_offset
<< 1) & 0x30000);
2136 bfd_put_32 (input_bfd
, hi16_value
, hit_data
- 4);
2137 offset
= (uvalue
& 0xffff) << 1;
2138 value
= (addend
& (~(howto
->dst_mask
))) | (offset
& 0x7fff) | ((offset
<< 1) & 0x30000);
2139 bfd_put_32 (input_bfd
, value
, hit_data
);
2140 return bfd_reloc_ok
;
2143 addend
= bfd_get_32 (input_bfd
, hit_data
);
2144 offset
= addend
& 0x7fff;
2145 if ((offset
& 0x4000) == 0x4000)
2146 offset
|= 0xffffc000;
2147 value
= value
+ offset
- gp
;
2148 if (((value
& 0xffffc000) != 0) && ((value
& 0xffffc000) != 0xffffc000))
2149 return bfd_reloc_overflow
;
2150 value
= (addend
& ~howto
->src_mask
) | (value
& howto
->src_mask
);
2151 bfd_put_32 (input_bfd
, value
, hit_data
);
2152 return bfd_reloc_ok
;
2155 case R_SCORE_CALL15
:
2160 /* The special case is when the symbol is forced to be local. We need the
2161 full address in the GOT since no R_SCORE_GOT_LO16 relocation follows. */
2162 forced
= ! score_elf_local_relocation_p (input_bfd
, rel
,
2163 local_sections
, FALSE
);
2164 value
= score_elf_got16_entry (output_bfd
, input_bfd
, info
,
2165 symbol
+ addend
, forced
);
2166 if (value
== MINUS_ONE
)
2167 return bfd_reloc_outofrange
;
2168 value
= score_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
2169 output_bfd
, input_bfd
, value
);
2176 if ((long) value
> 0x3fff || (long) value
< -0x4000)
2177 return bfd_reloc_overflow
;
2179 addend
= bfd_get_32 (input_bfd
, hit_data
);
2180 value
= (addend
& ~howto
->dst_mask
) | (value
& howto
->dst_mask
);
2181 bfd_put_32 (input_bfd
, value
, hit_data
);
2182 return bfd_reloc_ok
;
2184 case R_SCORE_GPREL32
:
2185 value
= (addend
+ symbol
+ gp0
- gp
);
2186 value
&= howto
->dst_mask
;
2187 bfd_put_32 (input_bfd
, value
, hit_data
);
2188 return bfd_reloc_ok
;
2190 case R_SCORE_GOT_LO16
:
2191 addend
= bfd_get_32 (input_bfd
, hit_data
);
2192 value
= (((addend
>> 16) & 0x3) << 14) | ((addend
& 0x7fff) >> 1);
2194 value
= (addend
& (~(howto
->dst_mask
))) | ((value
& 0x3fff) << 1)
2195 | (((value
>> 14) & 0x3) << 16);
2197 bfd_put_32 (input_bfd
, value
, hit_data
);
2198 return bfd_reloc_ok
;
2200 case R_SCORE_DUMMY_HI16
:
2201 return bfd_reloc_ok
;
2203 case R_SCORE_GNU_VTINHERIT
:
2204 case R_SCORE_GNU_VTENTRY
:
2205 /* We don't do anything with these at present. */
2206 return bfd_reloc_continue
;
2209 return bfd_reloc_notsupported
;
2213 /* Score backend functions. */
2216 s7_bfd_score_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
2218 Elf_Internal_Rela
*elf_reloc
)
2220 unsigned int r_type
;
2222 r_type
= ELF32_R_TYPE (elf_reloc
->r_info
);
2223 if (r_type
>= ARRAY_SIZE (elf32_score_howto_table
))
2224 bfd_reloc
->howto
= NULL
;
2226 bfd_reloc
->howto
= &elf32_score_howto_table
[r_type
];
2229 /* Relocate an score ELF section. */
2232 s7_bfd_score_elf_relocate_section (bfd
*output_bfd
,
2233 struct bfd_link_info
*info
,
2235 asection
*input_section
,
2237 Elf_Internal_Rela
*relocs
,
2238 Elf_Internal_Sym
*local_syms
,
2239 asection
**local_sections
)
2241 Elf_Internal_Shdr
*symtab_hdr
;
2242 Elf_Internal_Rela
*rel
;
2243 Elf_Internal_Rela
*relend
;
2245 unsigned long offset
;
2246 unsigned long hi16_addend
, hi16_offset
, hi16_value
, uvalue
;
2248 bfd_boolean gp_disp_p
= FALSE
;
2251 if (elf_hash_table (info
)->dynamic_sections_created
)
2253 bfd_size_type dynsecsymcount
= 0;
2257 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
2259 for (p
= output_bfd
->sections
; p
; p
= p
->next
)
2260 if ((p
->flags
& SEC_EXCLUDE
) == 0
2261 && (p
->flags
& SEC_ALLOC
) != 0
2262 && !(*bed
->elf_backend_omit_section_dynsym
) (output_bfd
, info
, p
))
2266 if (!score_elf_sort_hash_table (info
, dynsecsymcount
+ 1))
2270 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2271 extsymoff
= (elf_bad_symtab (input_bfd
)) ? 0 : symtab_hdr
->sh_info
;
2273 relend
= relocs
+ input_section
->reloc_count
;
2274 for (; rel
< relend
; rel
++)
2277 reloc_howto_type
*howto
;
2278 unsigned long r_symndx
;
2279 Elf_Internal_Sym
*sym
;
2281 struct score_elf_link_hash_entry
*h
;
2282 bfd_vma relocation
= 0;
2283 bfd_reloc_status_type r
;
2286 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2287 r_type
= ELF32_R_TYPE (rel
->r_info
);
2289 s7_bfd_score_info_to_howto (input_bfd
, &bfd_reloc
, (Elf_Internal_Rela
*) rel
);
2290 howto
= bfd_reloc
.howto
;
2296 if (r_symndx
< extsymoff
)
2298 sym
= local_syms
+ r_symndx
;
2299 sec
= local_sections
[r_symndx
];
2300 relocation
= sec
->output_section
->vma
+ sec
->output_offset
;
2301 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
, sec
);
2303 if (!info
->relocatable
)
2305 if (ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
2306 || (sec
->flags
& SEC_MERGE
))
2308 relocation
+= sym
->st_value
;
2311 if ((sec
->flags
& SEC_MERGE
)
2312 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
2315 bfd_vma addend
, value
;
2322 hi16_addend
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
- 4);
2323 hi16_offset
= ((((hi16_addend
>> 16) & 0x3) << 15) | (hi16_addend
& 0x7fff)) >> 1;
2324 value
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
2325 offset
= ((((value
>> 16) & 0x3) << 15) | (value
& 0x7fff)) >> 1;
2326 addend
= (hi16_offset
<< 16) | (offset
& 0xffff);
2328 addend
= _bfd_elf_rel_local_sym (output_bfd
, sym
, &msec
, addend
);
2329 addend
-= relocation
;
2330 addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
2332 hi16_offset
= (uvalue
>> 16) << 1;
2333 hi16_value
= (hi16_addend
& (~(howto
->dst_mask
)))
2334 | (hi16_offset
& 0x7fff) | ((hi16_offset
<< 1) & 0x30000);
2335 bfd_put_32 (input_bfd
, hi16_value
, contents
+ rel
->r_offset
- 4);
2336 offset
= (uvalue
& 0xffff) << 1;
2337 value
= (value
& (~(howto
->dst_mask
)))
2338 | (offset
& 0x7fff) | ((offset
<< 1) & 0x30000);
2339 bfd_put_32 (input_bfd
, value
, contents
+ rel
->r_offset
);
2341 case R_SCORE_GOT_LO16
:
2342 value
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
2343 addend
= (((value
>> 16) & 0x3) << 14) | ((value
& 0x7fff) >> 1);
2345 addend
= _bfd_elf_rel_local_sym (output_bfd
, sym
, &msec
, addend
) - relocation
;
2346 addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
2347 value
= (value
& (~(howto
->dst_mask
))) | ((addend
& 0x3fff) << 1)
2348 | (((addend
>> 14) & 0x3) << 16);
2350 bfd_put_32 (input_bfd
, value
, contents
+ rel
->r_offset
);
2353 value
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
2354 /* Get the (signed) value from the instruction. */
2355 addend
= value
& howto
->src_mask
;
2356 if (addend
& ((howto
->src_mask
+ 1) >> 1))
2358 bfd_signed_vma mask
;
2361 mask
&= ~howto
->src_mask
;
2365 addend
= _bfd_elf_rel_local_sym (output_bfd
, sym
, &msec
, addend
) - relocation
;
2366 addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
2367 value
= (value
& ~howto
->dst_mask
) | (addend
& howto
->dst_mask
);
2368 bfd_put_32 (input_bfd
, value
, contents
+ rel
->r_offset
);
2376 /* For global symbols we look up the symbol in the hash-table. */
2377 h
= ((struct score_elf_link_hash_entry
*)
2378 elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
]);
2379 /* Find the real hash-table entry for this symbol. */
2380 while (h
->root
.root
.type
== bfd_link_hash_indirect
2381 || h
->root
.root
.type
== bfd_link_hash_warning
)
2382 h
= (struct score_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
2384 /* Record the name of this symbol, for our caller. */
2385 name
= h
->root
.root
.root
.string
;
2387 /* See if this is the special GP_DISP_LABEL symbol. Note that such a
2388 symbol must always be a global symbol. */
2389 if (strcmp (name
, GP_DISP_LABEL
) == 0)
2391 /* Relocations against GP_DISP_LABEL are permitted only with
2392 R_SCORE_HI16 and R_SCORE_LO16 relocations. */
2393 if (r_type
!= R_SCORE_HI16
&& r_type
!= R_SCORE_LO16
)
2394 return bfd_reloc_notsupported
;
2399 /* If this symbol is defined, calculate its address. Note that
2400 GP_DISP_LABEL is a magic symbol, always implicitly defined by the
2401 linker, so it's inappropriate to check to see whether or not
2403 else if ((h
->root
.root
.type
== bfd_link_hash_defined
2404 || h
->root
.root
.type
== bfd_link_hash_defweak
)
2405 && h
->root
.root
.u
.def
.section
)
2407 sec
= h
->root
.root
.u
.def
.section
;
2408 if (sec
->output_section
)
2409 relocation
= (h
->root
.root
.u
.def
.value
2410 + sec
->output_section
->vma
2411 + sec
->output_offset
);
2414 relocation
= h
->root
.root
.u
.def
.value
;
2417 else if (h
->root
.root
.type
== bfd_link_hash_undefweak
)
2418 /* We allow relocations against undefined weak symbols, giving
2419 it the value zero, so that you can undefined weak functions
2420 and check to see if they exist by looking at their addresses. */
2422 else if (info
->unresolved_syms_in_objects
== RM_IGNORE
2423 && ELF_ST_VISIBILITY (h
->root
.other
) == STV_DEFAULT
)
2425 else if (strcmp (name
, "_DYNAMIC_LINK") == 0)
2427 /* If this is a dynamic link, we should have created a _DYNAMIC_LINK symbol
2428 in s7_bfd_score_elf_create_dynamic_sections. Otherwise, we should define
2429 the symbol with a value of 0. */
2430 BFD_ASSERT (! info
->shared
);
2431 BFD_ASSERT (bfd_get_section_by_name (output_bfd
, ".dynamic") == NULL
);
2434 else if (!info
->relocatable
)
2436 if (! ((*info
->callbacks
->undefined_symbol
)
2437 (info
, h
->root
.root
.root
.string
, input_bfd
,
2438 input_section
, rel
->r_offset
,
2439 (info
->unresolved_syms_in_objects
== RM_GENERATE_ERROR
)
2440 || ELF_ST_VISIBILITY (h
->root
.other
))))
2441 return bfd_reloc_undefined
;
2446 if (sec
!= NULL
&& discarded_section (sec
))
2447 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
2448 rel
, 1, relend
, howto
, 0, contents
);
2450 if (info
->relocatable
)
2452 /* This is a relocatable link. We don't have to change
2453 anything, unless the reloc is against a section symbol,
2454 in which case we have to adjust according to where the
2455 section symbol winds up in the output section. */
2456 if (r_symndx
< symtab_hdr
->sh_info
)
2458 sym
= local_syms
+ r_symndx
;
2460 if (r_type
== R_SCORE_GOT15
)
2462 const Elf_Internal_Rela
*lo16_rel
;
2463 const struct elf_backend_data
*bed
;
2464 bfd_vma lo_addend
= 0, lo_value
= 0;
2465 bfd_vma addend
, value
;
2467 value
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
2468 addend
= value
& 0x7fff;
2469 if ((addend
& 0x4000) == 0x4000)
2470 addend
|= 0xffffc000;
2472 bed
= get_elf_backend_data (output_bfd
);
2473 relend
= relocs
+ input_section
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
2474 lo16_rel
= score_elf_next_relocation (input_bfd
, R_SCORE_GOT_LO16
, rel
, relend
);
2475 if (lo16_rel
!= NULL
)
2477 lo_value
= bfd_get_32 (input_bfd
, contents
+ lo16_rel
->r_offset
);
2478 lo_addend
= (((lo_value
>> 16) & 0x3) << 14) | ((lo_value
& 0x7fff) >> 1);
2482 addend
+= lo_addend
;
2484 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
2485 addend
+= local_sections
[r_symndx
]->output_offset
;
2487 lo_addend
= addend
& 0xffff;
2488 lo_value
= (lo_value
& (~(howto
->dst_mask
))) | ((lo_addend
& 0x3fff) << 1)
2489 | (((lo_addend
>> 14) & 0x3) << 16);
2490 bfd_put_32 (input_bfd
, lo_value
, contents
+ lo16_rel
->r_offset
);
2492 addend
= addend
>> 16;
2493 value
= (value
& ~howto
->src_mask
) | (addend
& howto
->src_mask
);
2494 bfd_put_32 (input_bfd
, value
, contents
+ rel
->r_offset
);
2496 else if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
2498 sec
= local_sections
[r_symndx
];
2499 score_elf_add_to_rel (input_bfd
, contents
+ rel
->r_offset
,
2500 howto
, (bfd_signed_vma
) (sec
->output_offset
+ sym
->st_value
));
2506 /* This is a final link. */
2507 r
= score_elf_final_link_relocate (howto
, input_bfd
, output_bfd
,
2508 input_section
, contents
, rel
, relocs
,
2509 relocation
, info
, name
,
2510 (h
? ELF_ST_TYPE ((unsigned int) h
->root
.root
.type
) :
2511 ELF_ST_TYPE ((unsigned int) sym
->st_info
)), h
, local_syms
,
2512 local_sections
, gp_disp_p
);
2514 if (r
!= bfd_reloc_ok
)
2516 const char *msg
= (const char *)0;
2520 case bfd_reloc_overflow
:
2521 /* If the overflowing reloc was to an undefined symbol,
2522 we have already printed one error message and there
2523 is no point complaining again. */
2524 if (((!h
) || (h
->root
.root
.type
!= bfd_link_hash_undefined
))
2525 && (!((*info
->callbacks
->reloc_overflow
)
2526 (info
, NULL
, name
, howto
->name
, (bfd_vma
) 0,
2527 input_bfd
, input_section
, rel
->r_offset
))))
2530 case bfd_reloc_undefined
:
2531 if (!((*info
->callbacks
->undefined_symbol
)
2532 (info
, name
, input_bfd
, input_section
, rel
->r_offset
, TRUE
)))
2536 case bfd_reloc_outofrange
:
2537 msg
= _("internal error: out of range error");
2540 case bfd_reloc_notsupported
:
2541 msg
= _("internal error: unsupported relocation error");
2544 case bfd_reloc_dangerous
:
2545 msg
= _("internal error: dangerous error");
2549 msg
= _("internal error: unknown error");
2553 if (!((*info
->callbacks
->warning
)
2554 (info
, msg
, name
, input_bfd
, input_section
, rel
->r_offset
)))
2564 /* Look through the relocs for a section during the first phase, and
2565 allocate space in the global offset table. */
2568 s7_bfd_score_elf_check_relocs (bfd
*abfd
,
2569 struct bfd_link_info
*info
,
2571 const Elf_Internal_Rela
*relocs
)
2575 Elf_Internal_Shdr
*symtab_hdr
;
2576 struct elf_link_hash_entry
**sym_hashes
;
2577 struct score_got_info
*g
;
2579 const Elf_Internal_Rela
*rel
;
2580 const Elf_Internal_Rela
*rel_end
;
2583 const struct elf_backend_data
*bed
;
2585 if (info
->relocatable
)
2588 dynobj
= elf_hash_table (info
)->dynobj
;
2589 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2590 sym_hashes
= elf_sym_hashes (abfd
);
2591 extsymoff
= (elf_bad_symtab (abfd
)) ? 0 : symtab_hdr
->sh_info
;
2593 name
= bfd_get_section_name (abfd
, sec
);
2602 sgot
= score_elf_got_section (dynobj
, FALSE
);
2607 BFD_ASSERT (score_elf_section_data (sgot
) != NULL
);
2608 g
= score_elf_section_data (sgot
)->u
.got_info
;
2609 BFD_ASSERT (g
!= NULL
);
2614 bed
= get_elf_backend_data (abfd
);
2615 rel_end
= relocs
+ sec
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
2616 for (rel
= relocs
; rel
< rel_end
; ++rel
)
2618 unsigned long r_symndx
;
2619 unsigned int r_type
;
2620 struct elf_link_hash_entry
*h
;
2622 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2623 r_type
= ELF32_R_TYPE (rel
->r_info
);
2625 if (r_symndx
< extsymoff
)
2629 else if (r_symndx
>= extsymoff
+ NUM_SHDR_ENTRIES (symtab_hdr
))
2631 (*_bfd_error_handler
) (_("%s: Malformed reloc detected for section %s"), abfd
, name
);
2632 bfd_set_error (bfd_error_bad_value
);
2637 h
= sym_hashes
[r_symndx
- extsymoff
];
2639 /* This may be an indirect symbol created because of a version. */
2642 while (h
->root
.type
== bfd_link_hash_indirect
)
2643 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
2645 /* PR15323, ref flags aren't set for references in the
2647 h
->root
.non_ir_ref
= 1;
2651 /* Some relocs require a global offset table. */
2652 if (dynobj
== NULL
|| sgot
== NULL
)
2657 case R_SCORE_CALL15
:
2659 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
2660 if (!score_elf_create_got_section (dynobj
, info
, FALSE
))
2662 g
= score_elf_got_info (dynobj
, &sgot
);
2666 if (dynobj
== NULL
&& (info
->shared
|| h
!= NULL
) && (sec
->flags
& SEC_ALLOC
) != 0)
2667 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
2674 if (!h
&& (r_type
== R_SCORE_GOT_LO16
))
2676 if (! score_elf_record_local_got_symbol (abfd
, r_symndx
, rel
->r_addend
, g
))
2682 case R_SCORE_CALL15
:
2685 (*_bfd_error_handler
)
2686 (_("%B: CALL15 reloc at 0x%lx not against global symbol"),
2687 abfd
, (unsigned long) rel
->r_offset
);
2688 bfd_set_error (bfd_error_bad_value
);
2693 /* This symbol requires a global offset table entry. */
2694 if (! score_elf_record_global_got_symbol (h
, abfd
, info
, g
))
2697 /* We need a stub, not a plt entry for the undefined function. But we record
2698 it as if it needs plt. See _bfd_elf_adjust_dynamic_symbol. */
2704 if (h
&& ! score_elf_record_global_got_symbol (h
, abfd
, info
, g
))
2709 if ((info
->shared
|| h
!= NULL
) && (sec
->flags
& SEC_ALLOC
) != 0)
2713 sreloc
= score_elf_rel_dyn_section (dynobj
, TRUE
);
2717 #define SCORE_READONLY_SECTION (SEC_ALLOC | SEC_LOAD | SEC_READONLY)
2720 /* When creating a shared object, we must copy these reloc types into
2721 the output file as R_SCORE_REL32 relocs. We make room for this reloc
2722 in the .rel.dyn reloc section. */
2723 score_elf_allocate_dynamic_relocations (dynobj
, 1);
2724 if ((sec
->flags
& SCORE_READONLY_SECTION
)
2725 == SCORE_READONLY_SECTION
)
2726 /* We tell the dynamic linker that there are
2727 relocations against the text segment. */
2728 info
->flags
|= DF_TEXTREL
;
2732 struct score_elf_link_hash_entry
*hscore
;
2734 /* We only need to copy this reloc if the symbol is
2735 defined in a dynamic object. */
2736 hscore
= (struct score_elf_link_hash_entry
*) h
;
2737 ++hscore
->possibly_dynamic_relocs
;
2738 if ((sec
->flags
& SCORE_READONLY_SECTION
)
2739 == SCORE_READONLY_SECTION
)
2740 /* We need it to tell the dynamic linker if there
2741 are relocations against the text segment. */
2742 hscore
->readonly_reloc
= TRUE
;
2745 /* Even though we don't directly need a GOT entry for this symbol,
2746 a symbol must have a dynamic symbol table index greater that
2747 DT_SCORE_GOTSYM if there are dynamic relocations against it. */
2751 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
2752 if (! score_elf_create_got_section (dynobj
, info
, TRUE
))
2754 g
= score_elf_got_info (dynobj
, &sgot
);
2755 if (! score_elf_record_global_got_symbol (h
, abfd
, info
, g
))
2761 /* This relocation describes the C++ object vtable hierarchy.
2762 Reconstruct it for later use during GC. */
2763 case R_SCORE_GNU_VTINHERIT
:
2764 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
2768 /* This relocation describes which C++ vtable entries are actually
2769 used. Record for later use during GC. */
2770 case R_SCORE_GNU_VTENTRY
:
2771 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
2778 /* We must not create a stub for a symbol that has relocations
2779 related to taking the function's address. */
2785 struct score_elf_link_hash_entry
*sh
;
2787 sh
= (struct score_elf_link_hash_entry
*) h
;
2788 sh
->no_fn_stub
= TRUE
;
2791 case R_SCORE_CALL15
:
2800 s7_bfd_score_elf_add_symbol_hook (bfd
*abfd
,
2801 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2802 Elf_Internal_Sym
*sym
,
2803 const char **namep ATTRIBUTE_UNUSED
,
2804 flagword
*flagsp ATTRIBUTE_UNUSED
,
2808 switch (sym
->st_shndx
)
2811 if (sym
->st_size
> elf_gp_size (abfd
))
2814 case SHN_SCORE_SCOMMON
:
2815 *secp
= bfd_make_section_old_way (abfd
, ".scommon");
2816 (*secp
)->flags
|= SEC_IS_COMMON
;
2817 *valp
= sym
->st_size
;
2825 s7_bfd_score_elf_symbol_processing (bfd
*abfd
, asymbol
*asym
)
2827 elf_symbol_type
*elfsym
;
2829 elfsym
= (elf_symbol_type
*) asym
;
2830 switch (elfsym
->internal_elf_sym
.st_shndx
)
2833 if (asym
->value
> elf_gp_size (abfd
))
2836 case SHN_SCORE_SCOMMON
:
2837 if (score_elf_scom_section
.name
== NULL
)
2839 /* Initialize the small common section. */
2840 score_elf_scom_section
.name
= ".scommon";
2841 score_elf_scom_section
.flags
= SEC_IS_COMMON
;
2842 score_elf_scom_section
.output_section
= &score_elf_scom_section
;
2843 score_elf_scom_section
.symbol
= &score_elf_scom_symbol
;
2844 score_elf_scom_section
.symbol_ptr_ptr
= &score_elf_scom_symbol_ptr
;
2845 score_elf_scom_symbol
.name
= ".scommon";
2846 score_elf_scom_symbol
.flags
= BSF_SECTION_SYM
;
2847 score_elf_scom_symbol
.section
= &score_elf_scom_section
;
2848 score_elf_scom_symbol_ptr
= &score_elf_scom_symbol
;
2850 asym
->section
= &score_elf_scom_section
;
2851 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
2857 s7_bfd_score_elf_link_output_symbol_hook (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2858 const char *name ATTRIBUTE_UNUSED
,
2859 Elf_Internal_Sym
*sym
,
2860 asection
*input_sec
,
2861 struct elf_link_hash_entry
*h ATTRIBUTE_UNUSED
)
2863 /* If we see a common symbol, which implies a relocatable link, then
2864 if a symbol was small common in an input file, mark it as small
2865 common in the output file. */
2866 if (sym
->st_shndx
== SHN_COMMON
&& strcmp (input_sec
->name
, ".scommon") == 0)
2867 sym
->st_shndx
= SHN_SCORE_SCOMMON
;
2873 s7_bfd_score_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
2877 if (strcmp (bfd_get_section_name (abfd
, sec
), ".scommon") == 0)
2879 *retval
= SHN_SCORE_SCOMMON
;
2886 /* Adjust a symbol defined by a dynamic object and referenced by a
2887 regular object. The current definition is in some section of the
2888 dynamic object, but we're not including those sections. We have to
2889 change the definition to something the rest of the link can understand. */
2892 s7_bfd_score_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
2893 struct elf_link_hash_entry
*h
)
2896 struct score_elf_link_hash_entry
*hscore
;
2899 dynobj
= elf_hash_table (info
)->dynobj
;
2901 /* Make sure we know what is going on here. */
2902 BFD_ASSERT (dynobj
!= NULL
2904 || h
->u
.weakdef
!= NULL
2905 || (h
->def_dynamic
&& h
->ref_regular
&& !h
->def_regular
)));
2907 /* If this symbol is defined in a dynamic object, we need to copy
2908 any R_SCORE_ABS32 or R_SCORE_REL32 relocs against it into the output
2910 hscore
= (struct score_elf_link_hash_entry
*) h
;
2911 if (!info
->relocatable
2912 && hscore
->possibly_dynamic_relocs
!= 0
2913 && (h
->root
.type
== bfd_link_hash_defweak
|| !h
->def_regular
))
2915 score_elf_allocate_dynamic_relocations (dynobj
, hscore
->possibly_dynamic_relocs
);
2916 if (hscore
->readonly_reloc
)
2917 /* We tell the dynamic linker that there are relocations
2918 against the text segment. */
2919 info
->flags
|= DF_TEXTREL
;
2922 /* For a function, create a stub, if allowed. */
2923 if (!hscore
->no_fn_stub
&& h
->needs_plt
)
2925 if (!elf_hash_table (info
)->dynamic_sections_created
)
2928 /* If this symbol is not defined in a regular file, then set
2929 the symbol to the stub location. This is required to make
2930 function pointers compare as equal between the normal
2931 executable and the shared library. */
2932 if (!h
->def_regular
)
2934 /* We need .stub section. */
2935 s
= bfd_get_linker_section (dynobj
, SCORE_ELF_STUB_SECTION_NAME
);
2936 BFD_ASSERT (s
!= NULL
);
2938 h
->root
.u
.def
.section
= s
;
2939 h
->root
.u
.def
.value
= s
->size
;
2941 /* XXX Write this stub address somewhere. */
2942 h
->plt
.offset
= s
->size
;
2944 /* Make room for this stub code. */
2945 s
->size
+= SCORE_FUNCTION_STUB_SIZE
;
2947 /* The last half word of the stub will be filled with the index
2948 of this symbol in .dynsym section. */
2952 else if ((h
->type
== STT_FUNC
) && !h
->needs_plt
)
2954 /* This will set the entry for this symbol in the GOT to 0, and
2955 the dynamic linker will take care of this. */
2956 h
->root
.u
.def
.value
= 0;
2960 /* If this is a weak symbol, and there is a real definition, the
2961 processor independent code will have arranged for us to see the
2962 real definition first, and we can just use the same value. */
2963 if (h
->u
.weakdef
!= NULL
)
2965 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
2966 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
2967 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
2968 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
2972 /* This is a reference to a symbol defined by a dynamic object which
2973 is not a function. */
2977 /* This function is called after all the input files have been read,
2978 and the input sections have been assigned to output sections. */
2981 s7_bfd_score_elf_always_size_sections (bfd
*output_bfd
,
2982 struct bfd_link_info
*info
)
2986 struct score_got_info
*g
;
2988 bfd_size_type loadable_size
= 0;
2989 bfd_size_type local_gotno
;
2992 dynobj
= elf_hash_table (info
)->dynobj
;
2994 /* Relocatable links don't have it. */
2997 g
= score_elf_got_info (dynobj
, &s
);
3001 /* Calculate the total loadable size of the output. That will give us the
3002 maximum number of GOT_PAGE entries required. */
3003 for (sub
= info
->input_bfds
; sub
; sub
= sub
->link_next
)
3005 asection
*subsection
;
3007 for (subsection
= sub
->sections
;
3009 subsection
= subsection
->next
)
3011 if ((subsection
->flags
& SEC_ALLOC
) == 0)
3013 loadable_size
+= ((subsection
->size
+ 0xf)
3014 &~ (bfd_size_type
) 0xf);
3018 /* There has to be a global GOT entry for every symbol with
3019 a dynamic symbol table index of DT_SCORE_GOTSYM or
3020 higher. Therefore, it make sense to put those symbols
3021 that need GOT entries at the end of the symbol table. We
3023 if (! score_elf_sort_hash_table (info
, 1))
3026 if (g
->global_gotsym
!= NULL
)
3027 i
= elf_hash_table (info
)->dynsymcount
- g
->global_gotsym
->dynindx
;
3029 /* If there are no global symbols, or none requiring
3030 relocations, then GLOBAL_GOTSYM will be NULL. */
3033 /* In the worst case, we'll get one stub per dynamic symbol. */
3034 loadable_size
+= SCORE_FUNCTION_STUB_SIZE
* i
;
3036 /* Assume there are two loadable segments consisting of
3037 contiguous sections. Is 5 enough? */
3038 local_gotno
= (loadable_size
>> 16) + 5;
3040 g
->local_gotno
+= local_gotno
;
3041 s
->size
+= g
->local_gotno
* SCORE_ELF_GOT_SIZE (output_bfd
);
3043 g
->global_gotno
= i
;
3044 s
->size
+= i
* SCORE_ELF_GOT_SIZE (output_bfd
);
3046 score_elf_resolve_final_got_entries (g
);
3048 if (s
->size
> SCORE_ELF_GOT_MAX_SIZE (output_bfd
))
3050 /* Fixme. Error message or Warning message should be issued here. */
3056 /* Set the sizes of the dynamic sections. */
3059 s7_bfd_score_elf_size_dynamic_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
3063 bfd_boolean reltext
;
3065 dynobj
= elf_hash_table (info
)->dynobj
;
3066 BFD_ASSERT (dynobj
!= NULL
);
3068 if (elf_hash_table (info
)->dynamic_sections_created
)
3070 /* Set the contents of the .interp section to the interpreter. */
3073 s
= bfd_get_linker_section (dynobj
, ".interp");
3074 BFD_ASSERT (s
!= NULL
);
3075 s
->size
= strlen (ELF_DYNAMIC_INTERPRETER
) + 1;
3076 s
->contents
= (bfd_byte
*) ELF_DYNAMIC_INTERPRETER
;
3080 /* The check_relocs and adjust_dynamic_symbol entry points have
3081 determined the sizes of the various dynamic sections. Allocate
3084 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3088 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3091 /* It's OK to base decisions on the section name, because none
3092 of the dynobj section names depend upon the input files. */
3093 name
= bfd_get_section_name (dynobj
, s
);
3095 if (CONST_STRNEQ (name
, ".rel"))
3099 /* We only strip the section if the output section name
3100 has the same name. Otherwise, there might be several
3101 input sections for this output section. FIXME: This
3102 code is probably not needed these days anyhow, since
3103 the linker now does not create empty output sections. */
3104 if (s
->output_section
!= NULL
3106 bfd_get_section_name (s
->output_section
->owner
,
3107 s
->output_section
)) == 0)
3108 s
->flags
|= SEC_EXCLUDE
;
3112 const char *outname
;
3115 /* If this relocation section applies to a read only
3116 section, then we probably need a DT_TEXTREL entry.
3117 If the relocation section is .rel.dyn, we always
3118 assert a DT_TEXTREL entry rather than testing whether
3119 there exists a relocation to a read only section or
3121 outname
= bfd_get_section_name (output_bfd
, s
->output_section
);
3122 target
= bfd_get_section_by_name (output_bfd
, outname
+ 4);
3124 && (target
->flags
& SEC_READONLY
) != 0
3125 && (target
->flags
& SEC_ALLOC
) != 0) || strcmp (outname
, ".rel.dyn") == 0)
3128 /* We use the reloc_count field as a counter if we need
3129 to copy relocs into the output file. */
3130 if (strcmp (name
, ".rel.dyn") != 0)
3134 else if (CONST_STRNEQ (name
, ".got"))
3136 /* s7_bfd_score_elf_always_size_sections() has already done
3137 most of the work, but some symbols may have been mapped
3138 to versions that we must now resolve in the got_entries
3141 else if (strcmp (name
, SCORE_ELF_STUB_SECTION_NAME
) == 0)
3143 /* IRIX rld assumes that the function stub isn't at the end
3144 of .text section. So put a dummy. XXX */
3145 s
->size
+= SCORE_FUNCTION_STUB_SIZE
;
3147 else if (! CONST_STRNEQ (name
, ".init"))
3149 /* It's not one of our sections, so don't allocate space. */
3153 /* Allocate memory for the section contents. */
3154 s
->contents
= bfd_zalloc (dynobj
, s
->size
);
3155 if (s
->contents
== NULL
&& s
->size
!= 0)
3157 bfd_set_error (bfd_error_no_memory
);
3162 if (elf_hash_table (info
)->dynamic_sections_created
)
3164 /* Add some entries to the .dynamic section. We fill in the
3165 values later, in s7_bfd_score_elf_finish_dynamic_sections, but we
3166 must add the entries now so that we get the correct size for
3167 the .dynamic section. The DT_DEBUG entry is filled in by the
3168 dynamic linker and used by the debugger. */
3170 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info
, DT_DEBUG
, 0))
3174 info
->flags
|= DF_TEXTREL
;
3176 if ((info
->flags
& DF_TEXTREL
) != 0)
3178 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info
, DT_TEXTREL
, 0))
3182 if (! SCORE_ELF_ADD_DYNAMIC_ENTRY (info
, DT_PLTGOT
, 0))
3185 if (score_elf_rel_dyn_section (dynobj
, FALSE
))
3187 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info
, DT_REL
, 0))
3190 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELSZ
, 0))
3193 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELENT
, 0))
3197 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info
, DT_SCORE_BASE_ADDRESS
, 0))
3200 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info
, DT_SCORE_LOCAL_GOTNO
, 0))
3203 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info
, DT_SCORE_SYMTABNO
, 0))
3206 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info
, DT_SCORE_UNREFEXTNO
, 0))
3209 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info
, DT_SCORE_GOTSYM
, 0))
3212 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info
, DT_SCORE_HIPAGENO
, 0))
3220 s7_bfd_score_elf_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3222 struct elf_link_hash_entry
*h
;
3223 struct bfd_link_hash_entry
*bh
;
3227 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
3228 | SEC_LINKER_CREATED
| SEC_READONLY
);
3230 /* ABI requests the .dynamic section to be read only. */
3231 s
= bfd_get_linker_section (abfd
, ".dynamic");
3234 if (!bfd_set_section_flags (abfd
, s
, flags
))
3238 /* We need to create .got section. */
3239 if (!score_elf_create_got_section (abfd
, info
, FALSE
))
3242 if (!score_elf_rel_dyn_section (elf_hash_table (info
)->dynobj
, TRUE
))
3245 /* Create .stub section. */
3246 if (bfd_get_linker_section (abfd
, SCORE_ELF_STUB_SECTION_NAME
) == NULL
)
3248 s
= bfd_make_section_anyway_with_flags (abfd
, SCORE_ELF_STUB_SECTION_NAME
,
3251 || !bfd_set_section_alignment (abfd
, s
, 2))
3260 name
= "_DYNAMIC_LINK";
3262 if (!(_bfd_generic_link_add_one_symbol
3263 (info
, abfd
, name
, BSF_GLOBAL
, bfd_abs_section_ptr
,
3264 (bfd_vma
) 0, NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
3267 h
= (struct elf_link_hash_entry
*) bh
;
3270 h
->type
= STT_SECTION
;
3272 if (!bfd_elf_link_record_dynamic_symbol (info
, h
))
3280 /* Finish up dynamic symbol handling. We set the contents of various
3281 dynamic sections here. */
3284 s7_bfd_score_elf_finish_dynamic_symbol (bfd
*output_bfd
,
3285 struct bfd_link_info
*info
,
3286 struct elf_link_hash_entry
*h
,
3287 Elf_Internal_Sym
*sym
)
3291 struct score_got_info
*g
;
3294 dynobj
= elf_hash_table (info
)->dynobj
;
3296 if (h
->plt
.offset
!= MINUS_ONE
)
3299 bfd_byte stub
[SCORE_FUNCTION_STUB_SIZE
];
3301 /* This symbol has a stub. Set it up. */
3302 BFD_ASSERT (h
->dynindx
!= -1);
3304 s
= bfd_get_linker_section (dynobj
, SCORE_ELF_STUB_SECTION_NAME
);
3305 BFD_ASSERT (s
!= NULL
);
3307 /* FIXME: Can h->dynindex be more than 64K? */
3308 if (h
->dynindx
& 0xffff0000)
3311 /* Fill the stub. */
3312 bfd_put_32 (output_bfd
, STUB_LW
, stub
);
3313 bfd_put_32 (output_bfd
, STUB_MOVE
, stub
+ 4);
3314 bfd_put_32 (output_bfd
, STUB_LI16
| (h
->dynindx
<< 1), stub
+ 8);
3315 bfd_put_32 (output_bfd
, STUB_BRL
, stub
+ 12);
3317 BFD_ASSERT (h
->plt
.offset
<= s
->size
);
3318 memcpy (s
->contents
+ h
->plt
.offset
, stub
, SCORE_FUNCTION_STUB_SIZE
);
3320 /* Mark the symbol as undefined. plt.offset != -1 occurs
3321 only for the referenced symbol. */
3322 sym
->st_shndx
= SHN_UNDEF
;
3324 /* The run-time linker uses the st_value field of the symbol
3325 to reset the global offset table entry for this external
3326 to its stub address when unlinking a shared object. */
3327 sym
->st_value
= (s
->output_section
->vma
+ s
->output_offset
+ h
->plt
.offset
);
3330 BFD_ASSERT (h
->dynindx
!= -1 || h
->forced_local
);
3332 sgot
= score_elf_got_section (dynobj
, FALSE
);
3333 BFD_ASSERT (sgot
!= NULL
);
3334 BFD_ASSERT (score_elf_section_data (sgot
) != NULL
);
3335 g
= score_elf_section_data (sgot
)->u
.got_info
;
3336 BFD_ASSERT (g
!= NULL
);
3338 /* Run through the global symbol table, creating GOT entries for all
3339 the symbols that need them. */
3340 if (g
->global_gotsym
!= NULL
&& h
->dynindx
>= g
->global_gotsym
->dynindx
)
3345 value
= sym
->st_value
;
3346 offset
= score_elf_global_got_index (dynobj
, h
);
3347 bfd_put_32 (output_bfd
, value
, sgot
->contents
+ offset
);
3350 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3351 name
= h
->root
.root
.string
;
3352 if (h
== elf_hash_table (info
)->hdynamic
3353 || h
== elf_hash_table (info
)->hgot
)
3354 sym
->st_shndx
= SHN_ABS
;
3355 else if (strcmp (name
, "_DYNAMIC_LINK") == 0)
3357 sym
->st_shndx
= SHN_ABS
;
3358 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
3361 else if (strcmp (name
, GP_DISP_LABEL
) == 0)
3363 sym
->st_shndx
= SHN_ABS
;
3364 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
3365 sym
->st_value
= elf_gp (output_bfd
);
3371 /* Finish up the dynamic sections. */
3374 s7_bfd_score_elf_finish_dynamic_sections (bfd
*output_bfd
,
3375 struct bfd_link_info
*info
)
3381 struct score_got_info
*g
;
3383 dynobj
= elf_hash_table (info
)->dynobj
;
3385 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
3387 sgot
= score_elf_got_section (dynobj
, FALSE
);
3392 BFD_ASSERT (score_elf_section_data (sgot
) != NULL
);
3393 g
= score_elf_section_data (sgot
)->u
.got_info
;
3394 BFD_ASSERT (g
!= NULL
);
3397 if (elf_hash_table (info
)->dynamic_sections_created
)
3401 BFD_ASSERT (sdyn
!= NULL
);
3402 BFD_ASSERT (g
!= NULL
);
3404 for (b
= sdyn
->contents
;
3405 b
< sdyn
->contents
+ sdyn
->size
;
3406 b
+= SCORE_ELF_DYN_SIZE (dynobj
))
3408 Elf_Internal_Dyn dyn
;
3411 bfd_boolean swap_out_p
;
3413 /* Read in the current dynamic entry. */
3414 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_in
) (dynobj
, b
, &dyn
);
3416 /* Assume that we're going to modify it and write it out. */
3422 s
= score_elf_rel_dyn_section (dynobj
, FALSE
);
3423 BFD_ASSERT (s
!= NULL
);
3424 dyn
.d_un
.d_val
= SCORE_ELF_REL_SIZE (dynobj
);
3428 /* Rewrite DT_STRSZ. */
3429 dyn
.d_un
.d_val
= _bfd_elf_strtab_size (elf_hash_table (info
)->dynstr
);
3434 s
= bfd_get_section_by_name (output_bfd
, name
);
3435 BFD_ASSERT (s
!= NULL
);
3436 dyn
.d_un
.d_ptr
= s
->vma
;
3439 case DT_SCORE_BASE_ADDRESS
:
3440 s
= output_bfd
->sections
;
3441 BFD_ASSERT (s
!= NULL
);
3442 dyn
.d_un
.d_ptr
= s
->vma
& ~(bfd_vma
) 0xffff;
3445 case DT_SCORE_LOCAL_GOTNO
:
3446 dyn
.d_un
.d_val
= g
->local_gotno
;
3449 case DT_SCORE_UNREFEXTNO
:
3450 /* The index into the dynamic symbol table which is the
3451 entry of the first external symbol that is not
3452 referenced within the same object. */
3453 dyn
.d_un
.d_val
= bfd_count_sections (output_bfd
) + 1;
3456 case DT_SCORE_GOTSYM
:
3457 if (g
->global_gotsym
)
3459 dyn
.d_un
.d_val
= g
->global_gotsym
->dynindx
;
3462 /* In case if we don't have global got symbols we default
3463 to setting DT_SCORE_GOTSYM to the same value as
3464 DT_SCORE_SYMTABNO, so we just fall through. */
3466 case DT_SCORE_SYMTABNO
:
3468 elemsize
= SCORE_ELF_SYM_SIZE (output_bfd
);
3469 s
= bfd_get_section_by_name (output_bfd
, name
);
3470 BFD_ASSERT (s
!= NULL
);
3472 dyn
.d_un
.d_val
= s
->size
/ elemsize
;
3475 case DT_SCORE_HIPAGENO
:
3476 dyn
.d_un
.d_val
= g
->local_gotno
- SCORE_RESERVED_GOTNO
;
3485 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_out
) (dynobj
, &dyn
, b
);
3489 /* The first entry of the global offset table will be filled at
3490 runtime. The second entry will be used by some runtime loaders.
3491 This isn't the case of IRIX rld. */
3492 if (sgot
!= NULL
&& sgot
->size
> 0)
3494 bfd_put_32 (output_bfd
, 0, sgot
->contents
);
3495 bfd_put_32 (output_bfd
, 0x80000000, sgot
->contents
+ SCORE_ELF_GOT_SIZE (output_bfd
));
3499 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
3500 = SCORE_ELF_GOT_SIZE (output_bfd
);
3503 /* We need to sort the entries of the dynamic relocation section. */
3504 s
= score_elf_rel_dyn_section (dynobj
, FALSE
);
3506 if (s
!= NULL
&& s
->size
> (bfd_vma
)2 * SCORE_ELF_REL_SIZE (output_bfd
))
3508 reldyn_sorting_bfd
= output_bfd
;
3509 qsort ((Elf32_External_Rel
*) s
->contents
+ 1, s
->reloc_count
- 1,
3510 sizeof (Elf32_External_Rel
), score_elf_sort_dynamic_relocs
);
3516 /* This function set up the ELF section header for a BFD section in preparation for writing
3517 it out. This is where the flags and type fields are set for unusual sections. */
3520 s7_bfd_score_elf_fake_sections (bfd
*abfd ATTRIBUTE_UNUSED
,
3521 Elf_Internal_Shdr
*hdr
,
3526 name
= bfd_get_section_name (abfd
, sec
);
3528 if (strcmp (name
, ".got") == 0
3529 || strcmp (name
, ".srdata") == 0
3530 || strcmp (name
, ".sdata") == 0
3531 || strcmp (name
, ".sbss") == 0)
3532 hdr
->sh_flags
|= SHF_SCORE_GPREL
;
3537 /* This function do additional processing on the ELF section header before writing
3538 it out. This is used to set the flags and type fields for some sections. */
3540 /* assign_file_positions_except_relocs() check section flag and if it is allocatable,
3541 warning message will be issued. backend_fake_section is called before
3542 assign_file_positions_except_relocs(); backend_section_processing after it. so, we
3543 modify section flag there, but not backend_fake_section. */
3546 s7_bfd_score_elf_section_processing (bfd
*abfd ATTRIBUTE_UNUSED
, Elf_Internal_Shdr
*hdr
)
3548 if (hdr
->bfd_section
!= NULL
)
3550 const char *name
= bfd_get_section_name (abfd
, hdr
->bfd_section
);
3552 if (strcmp (name
, ".sdata") == 0)
3554 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_SCORE_GPREL
;
3555 hdr
->sh_type
= SHT_PROGBITS
;
3557 else if (strcmp (name
, ".sbss") == 0)
3559 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_SCORE_GPREL
;
3560 hdr
->sh_type
= SHT_NOBITS
;
3562 else if (strcmp (name
, ".srdata") == 0)
3564 hdr
->sh_flags
|= SHF_ALLOC
| SHF_SCORE_GPREL
;
3565 hdr
->sh_type
= SHT_PROGBITS
;
3573 s7_bfd_score_elf_write_section (bfd
*output_bfd
, asection
*sec
, bfd_byte
*contents
)
3575 bfd_byte
*to
, *from
, *end
;
3578 if (strcmp (sec
->name
, ".pdr") != 0)
3581 if (score_elf_section_data (sec
)->u
.tdata
== NULL
)
3585 end
= contents
+ sec
->size
;
3586 for (from
= contents
, i
= 0; from
< end
; from
+= PDR_SIZE
, i
++)
3588 if ((score_elf_section_data (sec
)->u
.tdata
)[i
] == 1)
3592 memcpy (to
, from
, PDR_SIZE
);
3596 bfd_set_section_contents (output_bfd
, sec
->output_section
, contents
,
3597 (file_ptr
) sec
->output_offset
, sec
->size
);
3602 /* Copy data from a SCORE ELF indirect symbol to its direct symbol, hiding the old
3603 indirect symbol. Process additional relocation information. */
3606 s7_bfd_score_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
3607 struct elf_link_hash_entry
*dir
,
3608 struct elf_link_hash_entry
*ind
)
3610 struct score_elf_link_hash_entry
*dirscore
, *indscore
;
3612 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
3614 if (ind
->root
.type
!= bfd_link_hash_indirect
)
3617 dirscore
= (struct score_elf_link_hash_entry
*) dir
;
3618 indscore
= (struct score_elf_link_hash_entry
*) ind
;
3619 dirscore
->possibly_dynamic_relocs
+= indscore
->possibly_dynamic_relocs
;
3621 if (indscore
->readonly_reloc
)
3622 dirscore
->readonly_reloc
= TRUE
;
3624 if (indscore
->no_fn_stub
)
3625 dirscore
->no_fn_stub
= TRUE
;
3628 /* Remove information about discarded functions from other sections which mention them. */
3631 s7_bfd_score_elf_discard_info (bfd
*abfd
,
3632 struct elf_reloc_cookie
*cookie
,
3633 struct bfd_link_info
*info
)
3636 bfd_boolean ret
= FALSE
;
3637 unsigned char *tdata
;
3640 o
= bfd_get_section_by_name (abfd
, ".pdr");
3641 if ((!o
) || (o
->size
== 0) || (o
->size
% PDR_SIZE
!= 0)
3642 || (o
->output_section
!= NULL
&& bfd_is_abs_section (o
->output_section
)))
3645 tdata
= bfd_zmalloc (o
->size
/ PDR_SIZE
);
3649 cookie
->rels
= _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
, info
->keep_memory
);
3656 cookie
->rel
= cookie
->rels
;
3657 cookie
->relend
= cookie
->rels
+ o
->reloc_count
;
3659 for (i
= 0, skip
= 0; i
< o
->size
; i
++)
3661 if (bfd_elf_reloc_symbol_deleted_p (i
* PDR_SIZE
, cookie
))
3670 score_elf_section_data (o
)->u
.tdata
= tdata
;
3671 o
->size
-= skip
* PDR_SIZE
;
3677 if (!info
->keep_memory
)
3678 free (cookie
->rels
);
3683 /* Signal that discard_info() has removed the discarded relocations for this section. */
3686 s7_bfd_score_elf_ignore_discarded_relocs (asection
*sec
)
3688 if (strcmp (sec
->name
, ".pdr") == 0)
3693 /* Return the section that should be marked against GC for a given
3697 s7_bfd_score_elf_gc_mark_hook (asection
*sec
,
3698 struct bfd_link_info
*info
,
3699 Elf_Internal_Rela
*rel
,
3700 struct elf_link_hash_entry
*h
,
3701 Elf_Internal_Sym
*sym
)
3704 switch (ELF32_R_TYPE (rel
->r_info
))
3706 case R_SCORE_GNU_VTINHERIT
:
3707 case R_SCORE_GNU_VTENTRY
:
3711 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
3714 /* Support for core dump NOTE sections. */
3717 s7_bfd_score_elf_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
3720 unsigned int raw_size
;
3722 switch (note
->descsz
)
3726 case 272: /* Linux/Score elf_prstatus */
3729 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
3732 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
3737 /* sizeof(elf_gregset_t) */
3743 /* Make a ".reg/999" section. */
3744 return _bfd_elfcore_make_pseudosection (abfd
, ".reg", raw_size
,
3745 note
->descpos
+ offset
);
3749 s7_bfd_score_elf_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
3751 switch (note
->descsz
)
3756 case 128: /* Linux/Score elf_prpsinfo. */
3758 elf_tdata (abfd
)->core
->program
3759 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 32, 16);
3762 elf_tdata (abfd
)->core
->command
3763 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 48, 80);
3767 /* Note that for some reason, a spurious space is tacked
3768 onto the end of the args in some (at least one anyway)
3769 implementations, so strip it off if it exists. */
3772 char *command
= elf_tdata (abfd
)->core
->command
;
3773 int n
= strlen (command
);
3775 if (0 < n
&& command
[n
- 1] == ' ')
3776 command
[n
- 1] = '\0';
3783 /* Score BFD functions. */
3786 s7_elf32_score_reloc_type_lookup (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_reloc_code_real_type code
)
3790 for (i
= 0; i
< ARRAY_SIZE (elf32_score_reloc_map
); i
++)
3791 if (elf32_score_reloc_map
[i
].bfd_reloc_val
== code
)
3792 return &elf32_score_howto_table
[elf32_score_reloc_map
[i
].elf_reloc_val
];
3798 s7_elf32_score_print_private_bfd_data (bfd
*abfd
, void * ptr
)
3800 FILE *file
= (FILE *) ptr
;
3802 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
3804 /* Print normal ELF private data. */
3805 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
3807 /* xgettext:c-format */
3808 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
3809 if (elf_elfheader (abfd
)->e_flags
& EF_SCORE_PIC
)
3811 fprintf (file
, _(" [pic]"));
3813 if (elf_elfheader (abfd
)->e_flags
& EF_SCORE_FIXDEP
)
3815 fprintf (file
, _(" [fix dep]"));
3823 s7_elf32_score_merge_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
3828 if (!_bfd_generic_verify_endian_match (ibfd
, obfd
))
3831 in_flags
= elf_elfheader (ibfd
)->e_flags
;
3832 out_flags
= elf_elfheader (obfd
)->e_flags
;
3834 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
3835 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
3838 in_flags
= elf_elfheader (ibfd
)->e_flags
;
3839 out_flags
= elf_elfheader (obfd
)->e_flags
;
3841 if (! elf_flags_init (obfd
))
3843 elf_flags_init (obfd
) = TRUE
;
3844 elf_elfheader (obfd
)->e_flags
= in_flags
;
3846 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
3847 && bfd_get_arch_info (obfd
)->the_default
)
3849 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
), bfd_get_mach (ibfd
));
3855 if (((in_flags
& EF_SCORE_PIC
) != 0) != ((out_flags
& EF_SCORE_PIC
) != 0))
3857 (*_bfd_error_handler
) (_("%B: warning: linking PIC files with non-PIC files"), ibfd
);
3860 /* Maybe dependency fix compatibility should be checked here. */
3865 s7_elf32_score_new_section_hook (bfd
*abfd
, asection
*sec
)
3867 struct _score_elf_section_data
*sdata
;
3868 bfd_size_type amt
= sizeof (*sdata
);
3870 sdata
= bfd_zalloc (abfd
, amt
);
3873 sec
->used_by_bfd
= sdata
;
3875 return _bfd_elf_new_section_hook (abfd
, sec
);
3878 #define elf_backend_omit_section_dynsym \
3879 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)