1 /* 32-bit ELF support for S+core.
2 Copyright 2006, 2007, 2008, 2009, 2010, 2011, 2012
3 Free Software Foundation, Inc.
5 Brain.lin (brain.lin@sunplusct.com)
6 Mei Ligang (ligang@sunnorth.com.cn)
7 Pei-Lin Tsai (pltsai@sunplus.com)
9 This file is part of BFD, the Binary File Descriptor library.
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program; if not, write to the Free Software
23 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
24 MA 02110-1301, USA. */
29 #include "libiberty.h"
31 #include "elf/score.h"
32 #include "elf/common.h"
33 #include "elf/internal.h"
35 #include "elf32-score.h"
41 /* The SCORE ELF linker needs additional information for each symbol in
42 the global hash table. */
43 struct score_elf_link_hash_entry
45 struct elf_link_hash_entry root
;
47 /* Number of R_SCORE_ABS32, R_SCORE_REL32 relocs against this symbol. */
48 unsigned int possibly_dynamic_relocs
;
50 /* If the R_SCORE_ABS32, R_SCORE_REL32 reloc is against a readonly section. */
51 bfd_boolean readonly_reloc
;
53 /* We must not create a stub for a symbol that has relocations related to
54 taking the function's address, i.e. any but R_SCORE_CALL15 ones. */
55 bfd_boolean no_fn_stub
;
57 /* Are we forced local? This will only be set if we have converted
58 the initial global GOT entry to a local GOT entry. */
59 bfd_boolean forced_local
;
62 /* Traverse a score ELF linker hash table. */
63 #define score_elf_link_hash_traverse(table, func, info) \
64 (elf_link_hash_traverse \
66 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
69 /* This structure is used to hold .got entries while estimating got sizes. */
70 struct score_got_entry
72 /* The input bfd in which the symbol is defined. */
74 /* The index of the symbol, as stored in the relocation r_info, if
75 we have a local symbol; -1 otherwise. */
79 /* If abfd == NULL, an address that must be stored in the got. */
81 /* If abfd != NULL && symndx != -1, the addend of the relocation
82 that should be added to the symbol value. */
84 /* If abfd != NULL && symndx == -1, the hash table entry
85 corresponding to a global symbol in the got (or, local, if
87 struct score_elf_link_hash_entry
*h
;
90 /* The offset from the beginning of the .got section to the entry
91 corresponding to this symbol+addend. If it's a global symbol
92 whose offset is yet to be decided, it's going to be -1. */
96 /* This structure is passed to score_elf_sort_hash_table_f when sorting
97 the dynamic symbols. */
99 struct score_elf_hash_sort_data
101 /* The symbol in the global GOT with the lowest dynamic symbol table index. */
102 struct elf_link_hash_entry
*low
;
103 /* The least dynamic symbol table index corresponding to a symbol with a GOT entry. */
104 long min_got_dynindx
;
105 /* The greatest dynamic symbol table index corresponding to a symbol
106 with a GOT entry that is not referenced (e.g., a dynamic symbol
107 with dynamic relocations pointing to it from non-primary GOTs). */
108 long max_unref_got_dynindx
;
109 /* The greatest dynamic symbol table index not corresponding to a
110 symbol without a GOT entry. */
111 long max_non_got_dynindx
;
114 struct score_got_info
116 /* The global symbol in the GOT with the lowest index in the dynamic
118 struct elf_link_hash_entry
*global_gotsym
;
119 /* The number of global .got entries. */
120 unsigned int global_gotno
;
121 /* The number of local .got entries. */
122 unsigned int local_gotno
;
123 /* The number of local .got entries we have used. */
124 unsigned int assigned_gotno
;
125 /* A hash table holding members of the got. */
126 struct htab
*got_entries
;
127 /* In multi-got links, a pointer to the next got (err, rather, most
128 of the time, it points to the previous got). */
129 struct score_got_info
*next
;
132 /* A structure used to count GOT entries, for GOT entry or ELF symbol table traversal. */
133 struct _score_elf_section_data
135 struct bfd_elf_section_data elf
;
138 struct score_got_info
*got_info
;
144 #define score_elf_section_data(sec) \
145 ((struct _score_elf_section_data *) elf_section_data (sec))
147 /* The size of a symbol-table entry. */
148 #define SCORE_ELF_SYM_SIZE(abfd) \
149 (get_elf_backend_data (abfd)->s->sizeof_sym)
151 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
152 from smaller values. Start with zero, widen, *then* decrement. */
153 #define MINUS_ONE (((bfd_vma)0) - 1)
154 #define MINUS_TWO (((bfd_vma)0) - 2)
159 /* The number of local .got entries we reserve. */
160 #define SCORE_RESERVED_GOTNO (2)
161 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
163 /* The offset of $gp from the beginning of the .got section. */
164 #define ELF_SCORE_GP_OFFSET(abfd) (0x3ff0)
165 /* The maximum size of the GOT for it to be addressable using 15-bit offsets from $gp. */
166 #define SCORE_ELF_GOT_MAX_SIZE(abfd) (ELF_SCORE_GP_OFFSET(abfd) + 0x3fff)
168 #define SCORE_ELF_STUB_SECTION_NAME (".SCORE.stub")
169 #define SCORE_FUNCTION_STUB_SIZE (16)
171 #define STUB_LW 0xc3bcc010 /* lw r29, [r28, -0x3ff0] */
172 #define STUB_MOVE 0x8363bc56 /* mv r27, r3 */
173 #define STUB_LI16 0x87548000 /* ori r26, .dynsym_index */
174 #define STUB_BRL 0x801dbc09 /* brl r29 */
176 #define SCORE_ELF_GOT_SIZE(abfd) \
177 (get_elf_backend_data (abfd)->s->arch_size / 8)
179 #define SCORE_ELF_ADD_DYNAMIC_ENTRY(info, tag, val) \
180 (_bfd_elf_add_dynamic_entry (info, (bfd_vma) tag, (bfd_vma) val))
182 /* The size of an external dynamic table entry. */
183 #define SCORE_ELF_DYN_SIZE(abfd) \
184 (get_elf_backend_data (abfd)->s->sizeof_dyn)
186 /* The size of an external REL relocation. */
187 #define SCORE_ELF_REL_SIZE(abfd) \
188 (get_elf_backend_data (abfd)->s->sizeof_rel)
190 /* The default alignment for sections, as a power of two. */
191 #define SCORE_ELF_LOG_FILE_ALIGN(abfd)\
192 (get_elf_backend_data (abfd)->s->log_file_align)
194 static bfd_byte
*hi16_rel_addr
;
196 /* This will be used when we sort the dynamic relocation records. */
197 static bfd
*reldyn_sorting_bfd
;
199 /* SCORE ELF uses two common sections. One is the usual one, and the
200 other is for small objects. All the small objects are kept
201 together, and then referenced via the gp pointer, which yields
202 faster assembler code. This is what we use for the small common
203 section. This approach is copied from ecoff.c. */
204 static asection score_elf_scom_section
;
205 static asymbol score_elf_scom_symbol
;
206 static asymbol
*score_elf_scom_symbol_ptr
;
209 score_bfd_get_16 (bfd
*abfd
, const void *data
)
211 return bfd_get_16 (abfd
, data
);
215 score3_bfd_getl32 (const void *p
)
217 const bfd_byte
*addr
= p
;
220 v
= (unsigned long) addr
[2];
221 v
|= (unsigned long) addr
[3] << 8;
222 v
|= (unsigned long) addr
[0] << 16;
223 v
|= (unsigned long) addr
[1] << 24;
228 score3_bfd_getl48 (const void *p
)
230 const bfd_byte
*addr
= p
;
231 unsigned long long v
;
233 v
= (unsigned long long) addr
[4];
234 v
|= (unsigned long long) addr
[5] << 8;
235 v
|= (unsigned long long) addr
[2] << 16;
236 v
|= (unsigned long long) addr
[3] << 24;
237 v
|= (unsigned long long) addr
[0] << 32;
238 v
|= (unsigned long long) addr
[1] << 40;
243 score_bfd_get_32 (bfd
*abfd
, const void *data
)
245 if (/* score3 && */ abfd
->xvec
->byteorder
== BFD_ENDIAN_LITTLE
)
246 return score3_bfd_getl32 (data
);
248 return bfd_get_32 (abfd
, data
);
252 score_bfd_get_48 (bfd
*abfd
, const void *p
)
254 if (/* score3 && */ abfd
->xvec
->byteorder
== BFD_ENDIAN_LITTLE
)
255 return score3_bfd_getl48 (p
);
257 return bfd_get_bits (p
, 48, 1);
261 score_bfd_put_16 (bfd
*abfd
, bfd_vma addr
, void *data
)
263 return bfd_put_16 (abfd
, addr
, data
);
267 score3_bfd_putl32 (bfd_vma data
, void *p
)
270 addr
[0] = (data
>> 16) & 0xff;
271 addr
[1] = (data
>> 24) & 0xff;
272 addr
[2] = data
& 0xff;
273 addr
[3] = (data
>> 8) & 0xff;
277 score3_bfd_putl48 (bfd_vma data
, void *p
)
280 addr
[0] = (data
>> 32) & 0xff;
281 addr
[1] = (data
>> 40) & 0xff;
282 addr
[2] = (data
>> 16) & 0xff;
283 addr
[3] = (data
>> 24) & 0xff;
284 addr
[4] = data
& 0xff;
285 addr
[5] = (data
>> 8) & 0xff;
289 score_bfd_put_32 (bfd
*abfd
, bfd_vma addr
, void *data
)
291 if (/* score3 && */ abfd
->xvec
->byteorder
== BFD_ENDIAN_LITTLE
)
292 return score3_bfd_putl32 (addr
, data
);
294 return bfd_put_32 (abfd
, addr
, data
);
298 score_bfd_put_48 (bfd
*abfd
, bfd_vma val
, void *p
)
300 if (/* score3 && */ abfd
->xvec
->byteorder
== BFD_ENDIAN_LITTLE
)
301 return score3_bfd_putl48 (val
, p
);
303 return bfd_put_bits (val
, p
, 48, 1);
306 static bfd_reloc_status_type
307 score_elf_hi16_reloc (bfd
*abfd ATTRIBUTE_UNUSED
,
308 arelent
*reloc_entry
,
309 asymbol
*symbol ATTRIBUTE_UNUSED
,
311 asection
*input_section ATTRIBUTE_UNUSED
,
312 bfd
*output_bfd ATTRIBUTE_UNUSED
,
313 char **error_message ATTRIBUTE_UNUSED
)
315 hi16_rel_addr
= (bfd_byte
*) data
+ reloc_entry
->address
;
319 static bfd_reloc_status_type
320 score_elf_lo16_reloc (bfd
*abfd
,
321 arelent
*reloc_entry
,
322 asymbol
*symbol ATTRIBUTE_UNUSED
,
324 asection
*input_section
,
325 bfd
*output_bfd ATTRIBUTE_UNUSED
,
326 char **error_message ATTRIBUTE_UNUSED
)
328 bfd_vma addend
= 0, offset
= 0;
330 unsigned long hi16_offset
, hi16_value
, uvalue
;
332 hi16_value
= score_bfd_get_32 (abfd
, hi16_rel_addr
);
333 hi16_offset
= ((((hi16_value
>> 16) & 0x3) << 15) | (hi16_value
& 0x7fff)) >> 1;
334 addend
= score_bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
335 offset
= ((((addend
>> 16) & 0x3) << 15) | (addend
& 0x7fff)) >> 1;
336 val
= reloc_entry
->addend
;
337 if (reloc_entry
->address
> input_section
->size
)
338 return bfd_reloc_outofrange
;
339 uvalue
= ((hi16_offset
<< 16) | (offset
& 0xffff)) + val
;
340 hi16_offset
= (uvalue
>> 16) << 1;
341 hi16_value
= (hi16_value
& ~0x37fff) | (hi16_offset
& 0x7fff) | ((hi16_offset
<< 1) & 0x30000);
342 score_bfd_put_32 (abfd
, hi16_value
, hi16_rel_addr
);
343 offset
= (uvalue
& 0xffff) << 1;
344 addend
= (addend
& ~0x37fff) | (offset
& 0x7fff) | ((offset
<< 1) & 0x30000);
345 score_bfd_put_32 (abfd
, addend
, (bfd_byte
*) data
+ reloc_entry
->address
);
349 /* Set the GP value for OUTPUT_BFD. Returns FALSE if this is a
350 dangerous relocation. */
353 score_elf_assign_gp (bfd
*output_bfd
, bfd_vma
*pgp
)
359 /* If we've already figured out what GP will be, just return it. */
360 *pgp
= _bfd_get_gp_value (output_bfd
);
364 count
= bfd_get_symcount (output_bfd
);
365 sym
= bfd_get_outsymbols (output_bfd
);
367 /* The linker script will have created a symbol named `_gp' with the
368 appropriate value. */
373 for (i
= 0; i
< count
; i
++, sym
++)
377 name
= bfd_asymbol_name (*sym
);
378 if (*name
== '_' && strcmp (name
, "_gp") == 0)
380 *pgp
= bfd_asymbol_value (*sym
);
381 _bfd_set_gp_value (output_bfd
, *pgp
);
389 /* Only get the error once. */
391 _bfd_set_gp_value (output_bfd
, *pgp
);
398 /* We have to figure out the gp value, so that we can adjust the
399 symbol value correctly. We look up the symbol _gp in the output
400 BFD. If we can't find it, we're stuck. We cache it in the ELF
401 target data. We don't need to adjust the symbol value for an
402 external symbol if we are producing relocatable output. */
403 static bfd_reloc_status_type
404 score_elf_final_gp (bfd
*output_bfd
,
406 bfd_boolean relocatable
,
407 char **error_message
,
410 if (bfd_is_und_section (symbol
->section
)
414 return bfd_reloc_undefined
;
417 *pgp
= _bfd_get_gp_value (output_bfd
);
420 || (symbol
->flags
& BSF_SECTION_SYM
) != 0))
424 /* Make up a value. */
425 *pgp
= symbol
->section
->output_section
->vma
+ 0x4000;
426 _bfd_set_gp_value (output_bfd
, *pgp
);
428 else if (!score_elf_assign_gp (output_bfd
, pgp
))
431 (char *) _("GP relative relocation when _gp not defined");
432 return bfd_reloc_dangerous
;
439 static bfd_reloc_status_type
440 score_elf_gprel15_with_gp (bfd
*abfd
,
442 arelent
*reloc_entry
,
443 asection
*input_section
,
444 bfd_boolean relocateable
,
446 bfd_vma gp ATTRIBUTE_UNUSED
)
451 if (bfd_is_com_section (symbol
->section
))
454 relocation
= symbol
->value
;
456 relocation
+= symbol
->section
->output_section
->vma
;
457 relocation
+= symbol
->section
->output_offset
;
458 if (reloc_entry
->address
> input_section
->size
)
459 return bfd_reloc_outofrange
;
461 insn
= score_bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
462 if (((reloc_entry
->addend
& 0xffffc000) != 0)
463 && ((reloc_entry
->addend
& 0xffffc000) != 0xffffc000))
464 return bfd_reloc_overflow
;
466 insn
= (insn
& ~0x7fff) | (reloc_entry
->addend
& 0x7fff);
467 score_bfd_put_32 (abfd
, insn
, (bfd_byte
*) data
+ reloc_entry
->address
);
469 reloc_entry
->address
+= input_section
->output_offset
;
474 static bfd_reloc_status_type
475 gprel32_with_gp (bfd
*abfd
, asymbol
*symbol
, arelent
*reloc_entry
,
476 asection
*input_section
, bfd_boolean relocatable
,
477 void *data
, bfd_vma gp
)
482 if (bfd_is_com_section (symbol
->section
))
485 relocation
= symbol
->value
;
487 relocation
+= symbol
->section
->output_section
->vma
;
488 relocation
+= symbol
->section
->output_offset
;
490 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
491 return bfd_reloc_outofrange
;
493 /* Set val to the offset into the section or symbol. */
494 val
= reloc_entry
->addend
;
496 if (reloc_entry
->howto
->partial_inplace
)
497 val
+= score_bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
499 /* Adjust val for the final section location and GP value. If we
500 are producing relocatable output, we don't want to do this for
501 an external symbol. */
503 || (symbol
->flags
& BSF_SECTION_SYM
) != 0)
504 val
+= relocation
- gp
;
506 if (reloc_entry
->howto
->partial_inplace
)
507 score_bfd_put_32 (abfd
, val
, (bfd_byte
*) data
+ reloc_entry
->address
);
509 reloc_entry
->addend
= val
;
512 reloc_entry
->address
+= input_section
->output_offset
;
517 static bfd_reloc_status_type
518 score_elf_gprel15_reloc (bfd
*abfd
,
519 arelent
*reloc_entry
,
522 asection
*input_section
,
524 char **error_message
)
526 bfd_boolean relocateable
;
527 bfd_reloc_status_type ret
;
530 if (output_bfd
!= NULL
531 && (symbol
->flags
& BSF_SECTION_SYM
) == 0 && reloc_entry
->addend
== 0)
533 reloc_entry
->address
+= input_section
->output_offset
;
536 if (output_bfd
!= NULL
)
540 relocateable
= FALSE
;
541 output_bfd
= symbol
->section
->output_section
->owner
;
544 ret
= score_elf_final_gp (output_bfd
, symbol
, relocateable
, error_message
, &gp
);
545 if (ret
!= bfd_reloc_ok
)
548 return score_elf_gprel15_with_gp (abfd
, symbol
, reloc_entry
,
549 input_section
, relocateable
, data
, gp
);
552 /* Do a R_SCORE_GPREL32 relocation. This is a 32 bit value which must
553 become the offset from the gp register. */
555 static bfd_reloc_status_type
556 score_elf_gprel32_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
557 void *data
, asection
*input_section
, bfd
*output_bfd
,
558 char **error_message
)
560 bfd_boolean relocatable
;
561 bfd_reloc_status_type ret
;
564 /* R_SCORE_GPREL32 relocations are defined for local symbols only. */
565 if (output_bfd
!= NULL
566 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
567 && (symbol
->flags
& BSF_LOCAL
) != 0)
569 *error_message
= (char *)
570 _("32bits gp relative relocation occurs for an external symbol");
571 return bfd_reloc_outofrange
;
574 if (output_bfd
!= NULL
)
579 output_bfd
= symbol
->section
->output_section
->owner
;
582 ret
= score_elf_final_gp (output_bfd
, symbol
, relocatable
, error_message
, &gp
);
583 if (ret
!= bfd_reloc_ok
)
587 return gprel32_with_gp (abfd
, symbol
, reloc_entry
, input_section
,
588 relocatable
, data
, gp
);
591 /* A howto special_function for R_SCORE_GOT15 relocations. This is just
592 like any other 16-bit relocation when applied to global symbols, but is
593 treated in the same as R_SCORE_HI16 when applied to local symbols. */
594 static bfd_reloc_status_type
595 score_elf_got15_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
596 void *data
, asection
*input_section
,
597 bfd
*output_bfd
, char **error_message
)
599 if ((symbol
->flags
& (BSF_GLOBAL
| BSF_WEAK
)) != 0
600 || bfd_is_und_section (bfd_get_section (symbol
))
601 || bfd_is_com_section (bfd_get_section (symbol
)))
602 /* The relocation is against a global symbol. */
603 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
604 input_section
, output_bfd
,
607 return score_elf_hi16_reloc (abfd
, reloc_entry
, symbol
, data
,
608 input_section
, output_bfd
, error_message
);
611 static bfd_reloc_status_type
612 score_elf_got_lo16_reloc (bfd
*abfd
,
613 arelent
*reloc_entry
,
614 asymbol
*symbol ATTRIBUTE_UNUSED
,
616 asection
*input_section
,
617 bfd
*output_bfd ATTRIBUTE_UNUSED
,
618 char **error_message ATTRIBUTE_UNUSED
)
620 bfd_vma addend
= 0, offset
= 0;
622 signed long hi16_offset
, hi16_value
, uvalue
;
624 hi16_value
= score_bfd_get_32 (abfd
, hi16_rel_addr
);
625 hi16_offset
= ((((hi16_value
>> 16) & 0x3) << 15) | (hi16_value
& 0x7fff)) >> 1;
626 addend
= score_bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
627 offset
= ((((addend
>> 16) & 0x3) << 15) | (addend
& 0x7fff)) >> 1;
628 val
= reloc_entry
->addend
;
629 if (reloc_entry
->address
> input_section
->size
)
630 return bfd_reloc_outofrange
;
631 uvalue
= ((hi16_offset
<< 16) | (offset
& 0xffff)) + val
;
632 if ((uvalue
> -0x8000) && (uvalue
< 0x7fff))
635 hi16_offset
= (uvalue
>> 16) & 0x7fff;
636 hi16_value
= (hi16_value
& ~0x37fff) | (hi16_offset
& 0x7fff) | ((hi16_offset
<< 1) & 0x30000);
637 score_bfd_put_32 (abfd
, hi16_value
, hi16_rel_addr
);
638 offset
= (uvalue
& 0xffff) << 1;
639 addend
= (addend
& ~0x37fff) | (offset
& 0x7fff) | ((offset
<< 1) & 0x30000);
640 score_bfd_put_32 (abfd
, addend
, (bfd_byte
*) data
+ reloc_entry
->address
);
644 static reloc_howto_type elf32_score_howto_table
[] =
647 HOWTO (R_SCORE_NONE
, /* type */
649 0, /* size (0 = byte, 1 = short, 2 = long) */
651 FALSE
, /* pc_relative */
653 complain_overflow_dont
,/* complain_on_overflow */
654 bfd_elf_generic_reloc
, /* special_function */
655 "R_SCORE_NONE", /* name */
656 FALSE
, /* partial_inplace */
659 FALSE
), /* pcrel_offset */
662 HOWTO (R_SCORE_HI16
, /* type */
664 2, /* size (0 = byte, 1 = short, 2 = long) */
666 FALSE
, /* pc_relative */
668 complain_overflow_dont
,/* complain_on_overflow */
669 score_elf_hi16_reloc
, /* special_function */
670 "R_SCORE_HI16", /* name */
671 TRUE
, /* partial_inplace */
672 0x37fff, /* src_mask */
673 0x37fff, /* dst_mask */
674 FALSE
), /* pcrel_offset */
677 HOWTO (R_SCORE_LO16
, /* type */
679 2, /* size (0 = byte, 1 = short, 2 = long) */
681 FALSE
, /* pc_relative */
683 complain_overflow_dont
,/* complain_on_overflow */
684 score_elf_lo16_reloc
, /* special_function */
685 "R_SCORE_LO16", /* name */
686 TRUE
, /* partial_inplace */
687 0x37fff, /* src_mask */
688 0x37fff, /* dst_mask */
689 FALSE
), /* pcrel_offset */
692 HOWTO (R_SCORE_BCMP
, /* type */
694 2, /* size (0 = byte, 1 = short, 2 = long) */
696 TRUE
, /* pc_relative */
698 complain_overflow_dont
,/* complain_on_overflow */
699 bfd_elf_generic_reloc
, /* special_function */
700 "R_SCORE_BCMP", /* name */
701 FALSE
, /* partial_inplace */
702 0x03e00381, /* src_mask */
703 0x03e00381, /* dst_mask */
704 FALSE
), /* pcrel_offset */
707 HOWTO (R_SCORE_24
, /* type */
709 2, /* size (0 = byte, 1 = short, 2 = long) */
711 FALSE
, /* pc_relative */
713 complain_overflow_dont
,/* complain_on_overflow */
714 bfd_elf_generic_reloc
, /* special_function */
715 "R_SCORE_24", /* name */
716 FALSE
, /* partial_inplace */
717 0x3ff7fff, /* src_mask */
718 0x3ff7fff, /* dst_mask */
719 FALSE
), /* pcrel_offset */
722 HOWTO (R_SCORE_PC19
, /* type */
724 2, /* size (0 = byte, 1 = short, 2 = long) */
726 TRUE
, /* pc_relative */
728 complain_overflow_dont
,/* complain_on_overflow */
729 bfd_elf_generic_reloc
, /* special_function */
730 "R_SCORE_PC19", /* name */
731 FALSE
, /* partial_inplace */
732 0x3ff03fe, /* src_mask */
733 0x3ff03fe, /* dst_mask */
734 FALSE
), /* pcrel_offset */
737 HOWTO (R_SCORE16_11
, /* type */
739 1, /* size (0 = byte, 1 = short, 2 = long) */
741 FALSE
, /* pc_relative */
743 complain_overflow_dont
,/* complain_on_overflow */
744 bfd_elf_generic_reloc
, /* special_function */
745 "R_SCORE16_11", /* name */
746 FALSE
, /* partial_inplace */
747 0x000000ffe, /* src_mask */
748 0x000000ffe, /* dst_mask */
749 FALSE
), /* pcrel_offset */
752 HOWTO (R_SCORE16_PC8
, /* type */
754 1, /* size (0 = byte, 1 = short, 2 = long) */
756 TRUE
, /* pc_relative */
758 complain_overflow_dont
,/* complain_on_overflow */
759 bfd_elf_generic_reloc
, /* special_function */
760 "R_SCORE16_PC8", /* name */
761 FALSE
, /* partial_inplace */
762 0x000001ff, /* src_mask */
763 0x000001ff, /* dst_mask */
764 FALSE
), /* pcrel_offset */
766 /* 32 bit absolute */
767 HOWTO (R_SCORE_ABS32
, /* type 8 */
769 2, /* size (0 = byte, 1 = short, 2 = long) */
771 FALSE
, /* pc_relative */
773 complain_overflow_bitfield
, /* complain_on_overflow */
774 bfd_elf_generic_reloc
, /* special_function */
775 "R_SCORE_ABS32", /* name */
776 FALSE
, /* partial_inplace */
777 0xffffffff, /* src_mask */
778 0xffffffff, /* dst_mask */
779 FALSE
), /* pcrel_offset */
781 /* 16 bit absolute */
782 HOWTO (R_SCORE_ABS16
, /* type 11 */
784 1, /* size (0 = byte, 1 = short, 2 = long) */
786 FALSE
, /* pc_relative */
788 complain_overflow_bitfield
, /* complain_on_overflow */
789 bfd_elf_generic_reloc
, /* special_function */
790 "R_SCORE_ABS16", /* name */
791 FALSE
, /* partial_inplace */
792 0x0000ffff, /* src_mask */
793 0x0000ffff, /* dst_mask */
794 FALSE
), /* pcrel_offset */
797 HOWTO (R_SCORE_DUMMY2
, /* type */
799 2, /* size (0 = byte, 1 = short, 2 = long) */
801 FALSE
, /* pc_relative */
803 complain_overflow_dont
,/* complain_on_overflow */
804 bfd_elf_generic_reloc
, /* special_function */
805 "R_SCORE_DUMMY2", /* name */
806 TRUE
, /* partial_inplace */
807 0x00007fff, /* src_mask */
808 0x00007fff, /* dst_mask */
809 FALSE
), /* pcrel_offset */
812 HOWTO (R_SCORE_GP15
, /* type */
814 2, /* size (0 = byte, 1 = short, 2 = long) */
816 FALSE
, /* pc_relative */
818 complain_overflow_dont
,/* complain_on_overflow */
819 score_elf_gprel15_reloc
,/* special_function */
820 "R_SCORE_GP15", /* name */
821 TRUE
, /* partial_inplace */
822 0x00007fff, /* src_mask */
823 0x00007fff, /* dst_mask */
824 FALSE
), /* pcrel_offset */
826 /* GNU extension to record C++ vtable hierarchy. */
827 HOWTO (R_SCORE_GNU_VTINHERIT
, /* type */
829 2, /* size (0 = byte, 1 = short, 2 = long) */
831 FALSE
, /* pc_relative */
833 complain_overflow_dont
,/* complain_on_overflow */
834 NULL
, /* special_function */
835 "R_SCORE_GNU_VTINHERIT", /* name */
836 FALSE
, /* partial_inplace */
839 FALSE
), /* pcrel_offset */
841 /* GNU extension to record C++ vtable member usage */
842 HOWTO (R_SCORE_GNU_VTENTRY
, /* type */
844 2, /* size (0 = byte, 1 = short, 2 = long) */
846 FALSE
, /* pc_relative */
848 complain_overflow_dont
,/* complain_on_overflow */
849 _bfd_elf_rel_vtable_reloc_fn
, /* special_function */
850 "R_SCORE_GNU_VTENTRY", /* name */
851 FALSE
, /* partial_inplace */
854 FALSE
), /* pcrel_offset */
856 /* Reference to global offset table. */
857 HOWTO (R_SCORE_GOT15
, /* type */
859 2, /* size (0 = byte, 1 = short, 2 = long) */
861 FALSE
, /* pc_relative */
863 complain_overflow_signed
, /* complain_on_overflow */
864 score_elf_got15_reloc
, /* special_function */
865 "R_SCORE_GOT15", /* name */
866 TRUE
, /* partial_inplace */
867 0x00007fff, /* src_mask */
868 0x00007fff, /* dst_mask */
869 FALSE
), /* pcrel_offset */
871 /* Low 16 bits of displacement in global offset table. */
872 HOWTO (R_SCORE_GOT_LO16
, /* type */
874 2, /* size (0 = byte, 1 = short, 2 = long) */
876 FALSE
, /* pc_relative */
878 complain_overflow_dont
,/* complain_on_overflow */
879 score_elf_got_lo16_reloc
, /* special_function */
880 "R_SCORE_GOT_LO16", /* name */
881 TRUE
, /* partial_inplace */
882 0x37ffe, /* src_mask */
883 0x37ffe, /* dst_mask */
884 FALSE
), /* pcrel_offset */
886 /* 15 bit call through global offset table. */
887 HOWTO (R_SCORE_CALL15
, /* type */
889 2, /* size (0 = byte, 1 = short, 2 = long) */
891 FALSE
, /* pc_relative */
893 complain_overflow_signed
, /* complain_on_overflow */
894 bfd_elf_generic_reloc
, /* special_function */
895 "R_SCORE_CALL15", /* name */
896 TRUE
, /* partial_inplace */
897 0x0000ffff, /* src_mask */
898 0x0000ffff, /* dst_mask */
899 FALSE
), /* pcrel_offset */
901 /* 32 bit GP relative reference. */
902 HOWTO (R_SCORE_GPREL32
, /* type */
904 2, /* size (0 = byte, 1 = short, 2 = long) */
906 FALSE
, /* pc_relative */
908 complain_overflow_dont
,/* complain_on_overflow */
909 score_elf_gprel32_reloc
, /* special_function */
910 "R_SCORE_GPREL32", /* name */
911 TRUE
, /* partial_inplace */
912 0xffffffff, /* src_mask */
913 0xffffffff, /* dst_mask */
914 FALSE
), /* pcrel_offset */
916 /* 32 bit symbol relative relocation. */
917 HOWTO (R_SCORE_REL32
, /* type */
919 2, /* size (0 = byte, 1 = short, 2 = long) */
921 FALSE
, /* pc_relative */
923 complain_overflow_dont
,/* complain_on_overflow */
924 bfd_elf_generic_reloc
, /* special_function */
925 "R_SCORE_REL32", /* name */
926 TRUE
, /* partial_inplace */
927 0xffffffff, /* src_mask */
928 0xffffffff, /* dst_mask */
929 FALSE
), /* pcrel_offset */
931 /* R_SCORE_DUMMY_HI16 */
932 HOWTO (R_SCORE_DUMMY_HI16
, /* type */
934 2, /* size (0 = byte, 1 = short, 2 = long) */
936 FALSE
, /* pc_relative */
938 complain_overflow_dont
,/* complain_on_overflow */
939 score_elf_hi16_reloc
, /* special_function */
940 "R_SCORE_DUMMY_HI16", /* name */
941 TRUE
, /* partial_inplace */
942 0x37fff, /* src_mask */
943 0x37fff, /* dst_mask */
944 FALSE
), /* pcrel_offset */
947 HOWTO (R_SCORE_IMM30
, /* type */
949 2, /* size (0 = byte, 1 = short, 2 = long) */
951 FALSE
, /* pc_relative */
953 complain_overflow_dont
,/* complain_on_overflow */
954 bfd_elf_generic_reloc
, /* special_function */
955 "R_SCORE_IMM30", /* name */
956 FALSE
, /* partial_inplace */
957 0x7f7fff7f80LL
, /* src_mask */
958 0x7f7fff7f80LL
, /* dst_mask */
959 FALSE
), /* pcrel_offset */
962 HOWTO (R_SCORE_IMM32
, /* type */
964 2, /* size (0 = byte, 1 = short, 2 = long) */
966 FALSE
, /* pc_relative */
968 complain_overflow_dont
,/* complain_on_overflow */
969 bfd_elf_generic_reloc
, /* special_function */
970 "R_SCORE_IMM32", /* name */
971 FALSE
, /* partial_inplace */
972 0x7f7fff7fe0LL
, /* src_mask */
973 0x7f7fff7fe0LL
, /* dst_mask */
974 FALSE
), /* pcrel_offset */
977 struct score_reloc_map
979 bfd_reloc_code_real_type bfd_reloc_val
;
980 unsigned char elf_reloc_val
;
983 static const struct score_reloc_map elf32_score_reloc_map
[] =
985 {BFD_RELOC_NONE
, R_SCORE_NONE
},
986 {BFD_RELOC_HI16_S
, R_SCORE_HI16
},
987 {BFD_RELOC_LO16
, R_SCORE_LO16
},
988 {BFD_RELOC_SCORE_BCMP
, R_SCORE_BCMP
},
989 {BFD_RELOC_SCORE_JMP
, R_SCORE_24
},
990 {BFD_RELOC_SCORE_BRANCH
, R_SCORE_PC19
},
991 {BFD_RELOC_SCORE16_JMP
, R_SCORE16_11
},
992 {BFD_RELOC_SCORE16_BRANCH
, R_SCORE16_PC8
},
993 {BFD_RELOC_32
, R_SCORE_ABS32
},
994 {BFD_RELOC_16
, R_SCORE_ABS16
},
995 {BFD_RELOC_SCORE_DUMMY2
, R_SCORE_DUMMY2
},
996 {BFD_RELOC_SCORE_GPREL15
, R_SCORE_GP15
},
997 {BFD_RELOC_VTABLE_INHERIT
, R_SCORE_GNU_VTINHERIT
},
998 {BFD_RELOC_VTABLE_ENTRY
, R_SCORE_GNU_VTENTRY
},
999 {BFD_RELOC_SCORE_GOT15
, R_SCORE_GOT15
},
1000 {BFD_RELOC_SCORE_GOT_LO16
, R_SCORE_GOT_LO16
},
1001 {BFD_RELOC_SCORE_CALL15
, R_SCORE_CALL15
},
1002 {BFD_RELOC_GPREL32
, R_SCORE_GPREL32
},
1003 {BFD_RELOC_32_PCREL
, R_SCORE_REL32
},
1004 {BFD_RELOC_SCORE_DUMMY_HI16
, R_SCORE_DUMMY_HI16
},
1005 {BFD_RELOC_SCORE_IMM30
, R_SCORE_IMM30
},
1006 {BFD_RELOC_SCORE_IMM32
, R_SCORE_IMM32
},
1009 /* got_entries only match if they're identical, except for gotidx, so
1010 use all fields to compute the hash, and compare the appropriate
1013 score_elf_got_entry_hash (const void *entry_
)
1015 const struct score_got_entry
*entry
= (struct score_got_entry
*)entry_
;
1017 return entry
->symndx
1018 + (!entry
->abfd
? entry
->d
.address
: entry
->abfd
->id
);
1022 score_elf_got_entry_eq (const void *entry1
, const void *entry2
)
1024 const struct score_got_entry
*e1
= (struct score_got_entry
*)entry1
;
1025 const struct score_got_entry
*e2
= (struct score_got_entry
*)entry2
;
1027 return e1
->abfd
== e2
->abfd
&& e1
->symndx
== e2
->symndx
1028 && (! e1
->abfd
? e1
->d
.address
== e2
->d
.address
1029 : e1
->symndx
>= 0 ? e1
->d
.addend
== e2
->d
.addend
1030 : e1
->d
.h
== e2
->d
.h
);
1033 /* If H needs a GOT entry, assign it the highest available dynamic
1034 index. Otherwise, assign it the lowest available dynamic
1037 score_elf_sort_hash_table_f (struct score_elf_link_hash_entry
*h
, void *data
)
1039 struct score_elf_hash_sort_data
*hsd
= data
;
1041 /* Symbols without dynamic symbol table entries aren't interesting at all. */
1042 if (h
->root
.dynindx
== -1)
1045 /* Global symbols that need GOT entries that are not explicitly
1046 referenced are marked with got offset 2. Those that are
1047 referenced get a 1, and those that don't need GOT entries get
1049 if (h
->root
.got
.offset
== 2)
1051 if (hsd
->max_unref_got_dynindx
== hsd
->min_got_dynindx
)
1052 hsd
->low
= (struct elf_link_hash_entry
*) h
;
1053 h
->root
.dynindx
= hsd
->max_unref_got_dynindx
++;
1055 else if (h
->root
.got
.offset
!= 1)
1056 h
->root
.dynindx
= hsd
->max_non_got_dynindx
++;
1059 h
->root
.dynindx
= --hsd
->min_got_dynindx
;
1060 hsd
->low
= (struct elf_link_hash_entry
*) h
;
1067 score_elf_got_section (bfd
*abfd
, bfd_boolean maybe_excluded
)
1069 asection
*sgot
= bfd_get_linker_section (abfd
, ".got");
1071 if (sgot
== NULL
|| (! maybe_excluded
&& (sgot
->flags
& SEC_EXCLUDE
) != 0))
1076 /* Returns the GOT information associated with the link indicated by
1077 INFO. If SGOTP is non-NULL, it is filled in with the GOT section. */
1078 static struct score_got_info
*
1079 score_elf_got_info (bfd
*abfd
, asection
**sgotp
)
1082 struct score_got_info
*g
;
1084 sgot
= score_elf_got_section (abfd
, TRUE
);
1085 BFD_ASSERT (sgot
!= NULL
);
1086 BFD_ASSERT (elf_section_data (sgot
) != NULL
);
1087 g
= score_elf_section_data (sgot
)->u
.got_info
;
1088 BFD_ASSERT (g
!= NULL
);
1095 /* Sort the dynamic symbol table so that symbols that need GOT entries
1096 appear towards the end. This reduces the amount of GOT space
1097 required. MAX_LOCAL is used to set the number of local symbols
1098 known to be in the dynamic symbol table. During
1099 s3_bfd_score_elf_size_dynamic_sections, this value is 1. Afterward, the
1100 section symbols are added and the count is higher. */
1102 score_elf_sort_hash_table (struct bfd_link_info
*info
,
1103 unsigned long max_local
)
1105 struct score_elf_hash_sort_data hsd
;
1106 struct score_got_info
*g
;
1109 dynobj
= elf_hash_table (info
)->dynobj
;
1111 g
= score_elf_got_info (dynobj
, NULL
);
1114 hsd
.max_unref_got_dynindx
=
1115 hsd
.min_got_dynindx
= elf_hash_table (info
)->dynsymcount
1116 /* In the multi-got case, assigned_gotno of the master got_info
1117 indicate the number of entries that aren't referenced in the
1118 primary GOT, but that must have entries because there are
1119 dynamic relocations that reference it. Since they aren't
1120 referenced, we move them to the end of the GOT, so that they
1121 don't prevent other entries that are referenced from getting
1122 too large offsets. */
1123 - (g
->next
? g
->assigned_gotno
: 0);
1124 hsd
.max_non_got_dynindx
= max_local
;
1125 score_elf_link_hash_traverse (elf_hash_table (info
),
1126 score_elf_sort_hash_table_f
,
1129 /* There should have been enough room in the symbol table to
1130 accommodate both the GOT and non-GOT symbols. */
1131 BFD_ASSERT (hsd
.max_non_got_dynindx
<= hsd
.min_got_dynindx
);
1132 BFD_ASSERT ((unsigned long)hsd
.max_unref_got_dynindx
1133 <= elf_hash_table (info
)->dynsymcount
);
1135 /* Now we know which dynamic symbol has the lowest dynamic symbol
1136 table index in the GOT. */
1137 g
->global_gotsym
= hsd
.low
;
1142 /* Create an entry in an score ELF linker hash table. */
1144 static struct bfd_hash_entry
*
1145 score_elf_link_hash_newfunc (struct bfd_hash_entry
*entry
,
1146 struct bfd_hash_table
*table
,
1149 struct score_elf_link_hash_entry
*ret
= (struct score_elf_link_hash_entry
*) entry
;
1151 /* Allocate the structure if it has not already been allocated by a subclass. */
1153 ret
= bfd_hash_allocate (table
, sizeof (struct score_elf_link_hash_entry
));
1155 return (struct bfd_hash_entry
*) ret
;
1157 /* Call the allocation method of the superclass. */
1158 ret
= ((struct score_elf_link_hash_entry
*)
1159 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
, table
, string
));
1163 ret
->possibly_dynamic_relocs
= 0;
1164 ret
->readonly_reloc
= FALSE
;
1165 ret
->no_fn_stub
= FALSE
;
1166 ret
->forced_local
= FALSE
;
1169 return (struct bfd_hash_entry
*) ret
;
1172 /* Returns the first relocation of type r_type found, beginning with
1173 RELOCATION. RELEND is one-past-the-end of the relocation table. */
1174 static const Elf_Internal_Rela
*
1175 score_elf_next_relocation (bfd
*abfd ATTRIBUTE_UNUSED
, unsigned int r_type
,
1176 const Elf_Internal_Rela
*relocation
,
1177 const Elf_Internal_Rela
*relend
)
1179 while (relocation
< relend
)
1181 if (ELF32_R_TYPE (relocation
->r_info
) == r_type
)
1187 /* We didn't find it. */
1188 bfd_set_error (bfd_error_bad_value
);
1192 /* This function is called via qsort() to sort the dynamic relocation
1193 entries by increasing r_symndx value. */
1195 score_elf_sort_dynamic_relocs (const void *arg1
, const void *arg2
)
1197 Elf_Internal_Rela int_reloc1
;
1198 Elf_Internal_Rela int_reloc2
;
1200 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd
, arg1
, &int_reloc1
);
1201 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd
, arg2
, &int_reloc2
);
1203 return (ELF32_R_SYM (int_reloc1
.r_info
) - ELF32_R_SYM (int_reloc2
.r_info
));
1206 /* Return whether a relocation is against a local symbol. */
1208 score_elf_local_relocation_p (bfd
*input_bfd
,
1209 const Elf_Internal_Rela
*relocation
,
1210 asection
**local_sections
,
1211 bfd_boolean check_forced
)
1213 unsigned long r_symndx
;
1214 Elf_Internal_Shdr
*symtab_hdr
;
1215 struct score_elf_link_hash_entry
*h
;
1218 r_symndx
= ELF32_R_SYM (relocation
->r_info
);
1219 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1220 extsymoff
= (elf_bad_symtab (input_bfd
)) ? 0 : symtab_hdr
->sh_info
;
1222 if (r_symndx
< extsymoff
)
1224 if (elf_bad_symtab (input_bfd
) && local_sections
[r_symndx
] != NULL
)
1229 /* Look up the hash table to check whether the symbol was forced local. */
1230 h
= (struct score_elf_link_hash_entry
*)
1231 elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
];
1232 /* Find the real hash-table entry for this symbol. */
1233 while (h
->root
.root
.type
== bfd_link_hash_indirect
1234 || h
->root
.root
.type
== bfd_link_hash_warning
)
1235 h
= (struct score_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
1236 if (h
->root
.forced_local
)
1243 /* Returns the dynamic relocation section for DYNOBJ. */
1245 score_elf_rel_dyn_section (bfd
*dynobj
, bfd_boolean create_p
)
1247 static const char dname
[] = ".rel.dyn";
1250 sreloc
= bfd_get_linker_section (dynobj
, dname
);
1251 if (sreloc
== NULL
&& create_p
)
1253 sreloc
= bfd_make_section_anyway_with_flags (dynobj
, dname
,
1258 | SEC_LINKER_CREATED
1261 || ! bfd_set_section_alignment (dynobj
, sreloc
,
1262 SCORE_ELF_LOG_FILE_ALIGN (dynobj
)))
1269 score_elf_allocate_dynamic_relocations (bfd
*abfd
, unsigned int n
)
1273 s
= score_elf_rel_dyn_section (abfd
, FALSE
);
1274 BFD_ASSERT (s
!= NULL
);
1278 /* Make room for a null element. */
1279 s
->size
+= SCORE_ELF_REL_SIZE (abfd
);
1282 s
->size
+= n
* SCORE_ELF_REL_SIZE (abfd
);
1285 /* Create a rel.dyn relocation for the dynamic linker to resolve. REL
1286 is the original relocation, which is now being transformed into a
1287 dynamic relocation. The ADDENDP is adjusted if necessary; the
1288 caller should store the result in place of the original addend. */
1290 score_elf_create_dynamic_relocation (bfd
*output_bfd
,
1291 struct bfd_link_info
*info
,
1292 const Elf_Internal_Rela
*rel
,
1293 struct score_elf_link_hash_entry
*h
,
1295 bfd_vma
*addendp
, asection
*input_section
)
1297 Elf_Internal_Rela outrel
[3];
1302 bfd_boolean defined_p
;
1304 r_type
= ELF32_R_TYPE (rel
->r_info
);
1305 dynobj
= elf_hash_table (info
)->dynobj
;
1306 sreloc
= score_elf_rel_dyn_section (dynobj
, FALSE
);
1307 BFD_ASSERT (sreloc
!= NULL
);
1308 BFD_ASSERT (sreloc
->contents
!= NULL
);
1309 BFD_ASSERT (sreloc
->reloc_count
* SCORE_ELF_REL_SIZE (output_bfd
) < sreloc
->size
);
1311 outrel
[0].r_offset
=
1312 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[0].r_offset
);
1313 outrel
[1].r_offset
=
1314 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[1].r_offset
);
1315 outrel
[2].r_offset
=
1316 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[2].r_offset
);
1318 if (outrel
[0].r_offset
== MINUS_ONE
)
1319 /* The relocation field has been deleted. */
1322 if (outrel
[0].r_offset
== MINUS_TWO
)
1324 /* The relocation field has been converted into a relative value of
1325 some sort. Functions like _bfd_elf_write_section_eh_frame expect
1326 the field to be fully relocated, so add in the symbol's value. */
1331 /* We must now calculate the dynamic symbol table index to use
1332 in the relocation. */
1334 && (! info
->symbolic
|| !h
->root
.def_regular
)
1335 /* h->root.dynindx may be -1 if this symbol was marked to
1337 && h
->root
.dynindx
!= -1)
1339 indx
= h
->root
.dynindx
;
1340 /* ??? glibc's ld.so just adds the final GOT entry to the
1341 relocation field. It therefore treats relocs against
1342 defined symbols in the same way as relocs against
1343 undefined symbols. */
1352 /* If the relocation was previously an absolute relocation and
1353 this symbol will not be referred to by the relocation, we must
1354 adjust it by the value we give it in the dynamic symbol table.
1355 Otherwise leave the job up to the dynamic linker. */
1356 if (defined_p
&& r_type
!= R_SCORE_REL32
)
1359 /* The relocation is always an REL32 relocation because we don't
1360 know where the shared library will wind up at load-time. */
1361 outrel
[0].r_info
= ELF32_R_INFO ((unsigned long) indx
, R_SCORE_REL32
);
1363 /* For strict adherence to the ABI specification, we should
1364 generate a R_SCORE_64 relocation record by itself before the
1365 _REL32/_64 record as well, such that the addend is read in as
1366 a 64-bit value (REL32 is a 32-bit relocation, after all).
1367 However, since none of the existing ELF64 SCORE dynamic
1368 loaders seems to care, we don't waste space with these
1369 artificial relocations. If this turns out to not be true,
1370 score_elf_allocate_dynamic_relocations() should be tweaked so
1371 as to make room for a pair of dynamic relocations per
1372 invocation if ABI_64_P, and here we should generate an
1373 additional relocation record with R_SCORE_64 by itself for a
1374 NULL symbol before this relocation record. */
1375 outrel
[1].r_info
= ELF32_R_INFO (0, R_SCORE_NONE
);
1376 outrel
[2].r_info
= ELF32_R_INFO (0, R_SCORE_NONE
);
1378 /* Adjust the output offset of the relocation to reference the
1379 correct location in the output file. */
1380 outrel
[0].r_offset
+= (input_section
->output_section
->vma
1381 + input_section
->output_offset
);
1382 outrel
[1].r_offset
+= (input_section
->output_section
->vma
1383 + input_section
->output_offset
);
1384 outrel
[2].r_offset
+= (input_section
->output_section
->vma
1385 + input_section
->output_offset
);
1387 /* Put the relocation back out. We have to use the special
1388 relocation outputter in the 64-bit case since the 64-bit
1389 relocation format is non-standard. */
1390 bfd_elf32_swap_reloc_out
1391 (output_bfd
, &outrel
[0],
1392 (sreloc
->contents
+ sreloc
->reloc_count
* sizeof (Elf32_External_Rel
)));
1394 /* We've now added another relocation. */
1395 ++sreloc
->reloc_count
;
1397 /* Make sure the output section is writable. The dynamic linker
1398 will be writing to it. */
1399 elf_section_data (input_section
->output_section
)->this_hdr
.sh_flags
|= SHF_WRITE
;
1405 score_elf_create_got_section (bfd
*abfd
,
1406 struct bfd_link_info
*info
,
1407 bfd_boolean maybe_exclude
)
1411 struct elf_link_hash_entry
*h
;
1412 struct bfd_link_hash_entry
*bh
;
1413 struct score_got_info
*g
;
1416 /* This function may be called more than once. */
1417 s
= score_elf_got_section (abfd
, TRUE
);
1420 if (! maybe_exclude
)
1421 s
->flags
&= ~SEC_EXCLUDE
;
1425 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
1428 flags
|= SEC_EXCLUDE
;
1430 /* We have to use an alignment of 2**4 here because this is hardcoded
1431 in the function stub generation and in the linker script. */
1432 s
= bfd_make_section_anyway_with_flags (abfd
, ".got", flags
);
1434 || ! bfd_set_section_alignment (abfd
, s
, 4))
1437 /* Define the symbol _GLOBAL_OFFSET_TABLE_. We don't do this in the
1438 linker script because we don't want to define the symbol if we
1439 are not creating a global offset table. */
1441 if (! (_bfd_generic_link_add_one_symbol
1442 (info
, abfd
, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL
, s
,
1443 0, NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
1446 h
= (struct elf_link_hash_entry
*) bh
;
1449 h
->type
= STT_OBJECT
;
1451 if (info
->shared
&& ! bfd_elf_link_record_dynamic_symbol (info
, h
))
1454 amt
= sizeof (struct score_got_info
);
1455 g
= bfd_alloc (abfd
, amt
);
1459 g
->global_gotsym
= NULL
;
1460 g
->global_gotno
= 0;
1462 g
->local_gotno
= SCORE_RESERVED_GOTNO
;
1463 g
->assigned_gotno
= SCORE_RESERVED_GOTNO
;
1466 g
->got_entries
= htab_try_create (1, score_elf_got_entry_hash
,
1467 score_elf_got_entry_eq
, NULL
);
1468 if (g
->got_entries
== NULL
)
1470 score_elf_section_data (s
)->u
.got_info
= g
;
1471 score_elf_section_data (s
)->elf
.this_hdr
.sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_SCORE_GPREL
;
1476 /* Calculate the %high function. */
1478 score_elf_high (bfd_vma value
)
1480 return ((value
+ (bfd_vma
) 0x8000) >> 16) & 0xffff;
1483 /* Create a local GOT entry for VALUE. Return the index of the entry,
1484 or -1 if it could not be created. */
1485 static struct score_got_entry
*
1486 score_elf_create_local_got_entry (bfd
*abfd
,
1487 bfd
*ibfd ATTRIBUTE_UNUSED
,
1488 struct score_got_info
*gg
,
1489 asection
*sgot
, bfd_vma value
,
1490 unsigned long r_symndx ATTRIBUTE_UNUSED
,
1491 struct score_elf_link_hash_entry
*h ATTRIBUTE_UNUSED
,
1492 int r_type ATTRIBUTE_UNUSED
)
1494 struct score_got_entry entry
, **loc
;
1495 struct score_got_info
*g
;
1499 entry
.d
.address
= value
;
1502 loc
= (struct score_got_entry
**) htab_find_slot (g
->got_entries
, &entry
, INSERT
);
1506 entry
.gotidx
= SCORE_ELF_GOT_SIZE (abfd
) * g
->assigned_gotno
++;
1508 *loc
= bfd_alloc (abfd
, sizeof entry
);
1513 memcpy (*loc
, &entry
, sizeof entry
);
1515 if (g
->assigned_gotno
>= g
->local_gotno
)
1517 (*loc
)->gotidx
= -1;
1518 /* We didn't allocate enough space in the GOT. */
1519 (*_bfd_error_handler
)
1520 (_("not enough GOT space for local GOT entries"));
1521 bfd_set_error (bfd_error_bad_value
);
1525 score_bfd_put_32 (abfd
, value
, (sgot
->contents
+ entry
.gotidx
));
1530 /* Find a GOT entry whose higher-order 16 bits are the same as those
1531 for value. Return the index into the GOT for this entry. */
1533 score_elf_got16_entry (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
1534 bfd_vma value
, bfd_boolean external
)
1537 struct score_got_info
*g
;
1538 struct score_got_entry
*entry
;
1542 /* Although the ABI says that it is "the high-order 16 bits" that we
1543 want, it is really the %high value. The complete value is
1544 calculated with a `addiu' of a LO16 relocation, just as with a
1546 value
= score_elf_high (value
) << 16;
1549 g
= score_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
1551 entry
= score_elf_create_local_got_entry (abfd
, ibfd
, g
, sgot
, value
, 0, NULL
,
1554 return entry
->gotidx
;
1560 s3_bfd_score_elf_hide_symbol (struct bfd_link_info
*info
,
1561 struct elf_link_hash_entry
*entry
,
1562 bfd_boolean force_local
)
1566 struct score_got_info
*g
;
1567 struct score_elf_link_hash_entry
*h
;
1569 h
= (struct score_elf_link_hash_entry
*) entry
;
1570 if (h
->forced_local
)
1572 h
->forced_local
= TRUE
;
1574 dynobj
= elf_hash_table (info
)->dynobj
;
1575 if (dynobj
!= NULL
&& force_local
)
1577 got
= score_elf_got_section (dynobj
, FALSE
);
1580 g
= score_elf_section_data (got
)->u
.got_info
;
1584 struct score_got_entry e
;
1585 struct score_got_info
*gg
= g
;
1587 /* Since we're turning what used to be a global symbol into a
1588 local one, bump up the number of local entries of each GOT
1589 that had an entry for it. This will automatically decrease
1590 the number of global entries, since global_gotno is actually
1591 the upper limit of global entries. */
1596 for (g
= g
->next
; g
!= gg
; g
= g
->next
)
1597 if (htab_find (g
->got_entries
, &e
))
1599 BFD_ASSERT (g
->global_gotno
> 0);
1604 /* If this was a global symbol forced into the primary GOT, we
1605 no longer need an entry for it. We can't release the entry
1606 at this point, but we must at least stop counting it as one
1607 of the symbols that required a forced got entry. */
1608 if (h
->root
.got
.offset
== 2)
1610 BFD_ASSERT (gg
->assigned_gotno
> 0);
1611 gg
->assigned_gotno
--;
1614 else if (g
->global_gotno
== 0 && g
->global_gotsym
== NULL
)
1615 /* If we haven't got through GOT allocation yet, just bump up the
1616 number of local entries, as this symbol won't be counted as
1619 else if (h
->root
.got
.offset
== 1)
1621 /* If we're past non-multi-GOT allocation and this symbol had
1622 been marked for a global got entry, give it a local entry
1624 BFD_ASSERT (g
->global_gotno
> 0);
1630 _bfd_elf_link_hash_hide_symbol (info
, &h
->root
, force_local
);
1633 /* If H is a symbol that needs a global GOT entry, but has a dynamic
1634 symbol table index lower than any we've seen to date, record it for
1637 score_elf_record_global_got_symbol (struct elf_link_hash_entry
*h
,
1639 struct bfd_link_info
*info
,
1640 struct score_got_info
*g
)
1642 struct score_got_entry entry
, **loc
;
1644 /* A global symbol in the GOT must also be in the dynamic symbol table. */
1645 if (h
->dynindx
== -1)
1647 switch (ELF_ST_VISIBILITY (h
->other
))
1651 s3_bfd_score_elf_hide_symbol (info
, h
, TRUE
);
1654 if (!bfd_elf_link_record_dynamic_symbol (info
, h
))
1660 entry
.d
.h
= (struct score_elf_link_hash_entry
*)h
;
1662 loc
= (struct score_got_entry
**)htab_find_slot (g
->got_entries
, &entry
, INSERT
);
1664 /* If we've already marked this entry as needing GOT space, we don't
1665 need to do it again. */
1669 *loc
= bfd_alloc (abfd
, sizeof entry
);
1675 memcpy (*loc
, &entry
, sizeof (entry
));
1677 if (h
->got
.offset
!= MINUS_ONE
)
1680 /* By setting this to a value other than -1, we are indicating that
1681 there needs to be a GOT entry for H. Avoid using zero, as the
1682 generic ELF copy_indirect_symbol tests for <= 0. */
1688 /* Reserve space in G for a GOT entry containing the value of symbol
1689 SYMNDX in input bfd ABDF, plus ADDEND. */
1691 score_elf_record_local_got_symbol (bfd
*abfd
,
1694 struct score_got_info
*g
)
1696 struct score_got_entry entry
, **loc
;
1699 entry
.symndx
= symndx
;
1700 entry
.d
.addend
= addend
;
1701 loc
= (struct score_got_entry
**)htab_find_slot (g
->got_entries
, &entry
, INSERT
);
1706 entry
.gotidx
= g
->local_gotno
++;
1708 *loc
= bfd_alloc (abfd
, sizeof(entry
));
1712 memcpy (*loc
, &entry
, sizeof (entry
));
1717 /* Returns the GOT offset at which the indicated address can be found.
1718 If there is not yet a GOT entry for this value, create one.
1719 Returns -1 if no satisfactory GOT offset can be found. */
1721 score_elf_local_got_index (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
1722 bfd_vma value
, unsigned long r_symndx
,
1723 struct score_elf_link_hash_entry
*h
, int r_type
)
1726 struct score_got_info
*g
;
1727 struct score_got_entry
*entry
;
1729 g
= score_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
1731 entry
= score_elf_create_local_got_entry (abfd
, ibfd
, g
, sgot
, value
,
1732 r_symndx
, h
, r_type
);
1737 return entry
->gotidx
;
1740 /* Returns the GOT index for the global symbol indicated by H. */
1743 score_elf_global_got_index (bfd
*abfd
, struct elf_link_hash_entry
*h
)
1747 struct score_got_info
*g
;
1748 long global_got_dynindx
= 0;
1750 g
= score_elf_got_info (abfd
, &sgot
);
1751 if (g
->global_gotsym
!= NULL
)
1752 global_got_dynindx
= g
->global_gotsym
->dynindx
;
1754 /* Once we determine the global GOT entry with the lowest dynamic
1755 symbol table index, we must put all dynamic symbols with greater
1756 indices into the GOT. That makes it easy to calculate the GOT
1758 BFD_ASSERT (h
->dynindx
>= global_got_dynindx
);
1759 got_index
= ((h
->dynindx
- global_got_dynindx
+ g
->local_gotno
) * SCORE_ELF_GOT_SIZE (abfd
));
1760 BFD_ASSERT (got_index
< sgot
->size
);
1765 /* Returns the offset for the entry at the INDEXth position in the GOT. */
1768 score_elf_got_offset_from_index (bfd
*dynobj
,
1770 bfd
*input_bfd ATTRIBUTE_UNUSED
,
1776 score_elf_got_info (dynobj
, &sgot
);
1777 gp
= _bfd_get_gp_value (output_bfd
);
1779 return sgot
->output_section
->vma
+ sgot
->output_offset
+ got_index
- gp
;
1782 /* Follow indirect and warning hash entries so that each got entry
1783 points to the final symbol definition. P must point to a pointer
1784 to the hash table we're traversing. Since this traversal may
1785 modify the hash table, we set this pointer to NULL to indicate
1786 we've made a potentially-destructive change to the hash table, so
1787 the traversal must be restarted. */
1789 score_elf_resolve_final_got_entry (void **entryp
, void *p
)
1791 struct score_got_entry
*entry
= (struct score_got_entry
*)*entryp
;
1792 htab_t got_entries
= *(htab_t
*)p
;
1794 if (entry
->abfd
!= NULL
&& entry
->symndx
== -1)
1796 struct score_elf_link_hash_entry
*h
= entry
->d
.h
;
1798 while (h
->root
.root
.type
== bfd_link_hash_indirect
1799 || h
->root
.root
.type
== bfd_link_hash_warning
)
1800 h
= (struct score_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
1802 if (entry
->d
.h
== h
)
1807 /* If we can't find this entry with the new bfd hash, re-insert
1808 it, and get the traversal restarted. */
1809 if (! htab_find (got_entries
, entry
))
1811 htab_clear_slot (got_entries
, entryp
);
1812 entryp
= htab_find_slot (got_entries
, entry
, INSERT
);
1815 /* Abort the traversal, since the whole table may have
1816 moved, and leave it up to the parent to restart the
1818 *(htab_t
*)p
= NULL
;
1821 /* We might want to decrement the global_gotno count, but it's
1822 either too early or too late for that at this point. */
1828 /* Turn indirect got entries in a got_entries table into their final locations. */
1830 score_elf_resolve_final_got_entries (struct score_got_info
*g
)
1836 got_entries
= g
->got_entries
;
1838 htab_traverse (got_entries
,
1839 score_elf_resolve_final_got_entry
,
1842 while (got_entries
== NULL
);
1845 /* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS. for -r */
1847 score_elf_add_to_rel (bfd
*abfd
,
1849 reloc_howto_type
*howto
,
1850 bfd_signed_vma increment
)
1852 bfd_signed_vma addend
;
1854 unsigned long offset
;
1855 unsigned long r_type
= howto
->type
;
1856 unsigned long hi16_addend
, hi16_offset
, hi16_value
, uvalue
;
1858 contents
= score_bfd_get_32 (abfd
, address
);
1859 /* Get the (signed) value from the instruction. */
1860 addend
= contents
& howto
->src_mask
;
1861 if (addend
& ((howto
->src_mask
+ 1) >> 1))
1863 bfd_signed_vma mask
;
1866 mask
&= ~howto
->src_mask
;
1869 /* Add in the increment, (which is a byte value). */
1874 (((contents
& howto
->src_mask
) & 0x3ff0000) >> 6) | ((contents
& howto
->src_mask
) & 0x3ff);
1875 offset
+= increment
;
1877 (contents
& ~howto
->
1878 src_mask
) | (((offset
<< 6) & howto
->src_mask
) & 0x3ff0000) | (offset
& 0x3ff);
1879 score_bfd_put_32 (abfd
, contents
, address
);
1884 hi16_addend
= score_bfd_get_32 (abfd
, address
- 4);
1885 hi16_offset
= ((((hi16_addend
>> 16) & 0x3) << 15) | (hi16_addend
& 0x7fff)) >> 1;
1886 offset
= ((((contents
>> 16) & 0x3) << 15) | (contents
& 0x7fff)) >> 1;
1887 offset
= (hi16_offset
<< 16) | (offset
& 0xffff);
1888 uvalue
= increment
+ offset
;
1889 hi16_offset
= (uvalue
>> 16) << 1;
1890 hi16_value
= (hi16_addend
& (~(howto
->dst_mask
)))
1891 | (hi16_offset
& 0x7fff) | ((hi16_offset
<< 1) & 0x30000);
1892 score_bfd_put_32 (abfd
, hi16_value
, address
- 4);
1893 offset
= (uvalue
& 0xffff) << 1;
1894 contents
= (contents
& (~(howto
->dst_mask
))) | (offset
& 0x7fff) | ((offset
<< 1) & 0x30000);
1895 score_bfd_put_32 (abfd
, contents
, address
);
1899 (((contents
& howto
->src_mask
) >> 1) & 0x1ff8000) | ((contents
& howto
->src_mask
) & 0x7fff);
1900 offset
+= increment
;
1902 (contents
& ~howto
->
1903 src_mask
) | (((offset
<< 1) & howto
->src_mask
) & 0x3ff0000) | (offset
& 0x7fff);
1904 score_bfd_put_32 (abfd
, contents
, address
);
1909 contents
= score_bfd_get_16 (abfd
, address
);
1910 offset
= contents
& howto
->src_mask
;
1911 offset
+= increment
;
1912 contents
= (contents
& ~howto
->src_mask
) | (offset
& howto
->src_mask
);
1913 score_bfd_put_16 (abfd
, contents
, address
);
1918 contents
= score_bfd_get_16 (abfd
, address
);
1919 offset
= (contents
& howto
->src_mask
) + ((increment
>> 1) & 0x1ff);
1920 contents
= (contents
& (~howto
->src_mask
)) | (offset
& howto
->src_mask
);
1921 score_bfd_put_16 (abfd
, contents
, address
);
1926 contents
= score_bfd_get_32 (abfd
, address
);
1927 offset
= (contents
& howto
->src_mask
);
1928 offset
<<= howto
->rightshift
;
1929 offset
+= increment
;
1930 offset
>>= howto
->rightshift
;
1931 contents
= (contents
& (~howto
->src_mask
)) | (offset
& howto
->src_mask
);
1932 score_bfd_put_32 (abfd
, contents
, address
);
1936 contents
= score_bfd_get_48 (abfd
, address
);
1937 offset
= (contents
& howto
->src_mask
);
1938 offset
<<= howto
->rightshift
;
1939 offset
+= increment
;
1940 offset
>>= howto
->rightshift
;
1941 contents
= (contents
& (~howto
->src_mask
)) | (offset
& howto
->src_mask
);
1942 score_bfd_put_48 (abfd
, contents
, address
);
1946 contents
= score_bfd_get_48 (abfd
, address
);
1947 offset
= (contents
& howto
->src_mask
);
1948 offset
+= increment
;
1949 contents
= (contents
& (~howto
->src_mask
)) | (offset
& howto
->src_mask
);
1950 score_bfd_put_48 (abfd
, contents
, address
);
1954 addend
+= increment
;
1955 contents
= (contents
& ~howto
->dst_mask
) | (addend
& howto
->dst_mask
);
1956 score_bfd_put_32 (abfd
, contents
, address
);
1961 /* Perform a relocation as part of a final link. */
1962 static bfd_reloc_status_type
1963 score_elf_final_link_relocate (reloc_howto_type
*howto
,
1966 asection
*input_section
,
1968 Elf_Internal_Rela
*rel
,
1969 Elf_Internal_Rela
*relocs
,
1971 struct bfd_link_info
*info
,
1972 const char *sym_name ATTRIBUTE_UNUSED
,
1973 int sym_flags ATTRIBUTE_UNUSED
,
1974 struct score_elf_link_hash_entry
*h
,
1975 asection
**local_sections
,
1976 bfd_boolean gp_disp_p
)
1978 unsigned long r_type
;
1979 unsigned long r_symndx
;
1980 bfd_byte
*hit_data
= contents
+ rel
->r_offset
;
1982 /* The final GP value to be used for the relocatable, executable, or
1983 shared object file being produced. */
1984 bfd_vma gp
= MINUS_ONE
;
1985 /* The place (section offset or address) of the storage unit being relocated. */
1987 /* The offset into the global offset table at which the address of the relocation entry
1988 symbol, adjusted by the addend, resides during execution. */
1989 bfd_vma g
= MINUS_ONE
;
1990 /* TRUE if the symbol referred to by this relocation is a local symbol. */
1991 bfd_boolean local_p
;
1992 /* The eventual value we will relocate. */
1993 bfd_vma value
= symbol
;
1994 unsigned long hi16_addend
, hi16_offset
, hi16_value
, uvalue
, offset
, abs_value
= 0;
1997 if (elf_gp (output_bfd
) == 0)
1999 struct bfd_link_hash_entry
*bh
;
2002 bh
= bfd_link_hash_lookup (info
->hash
, "_gp", 0, 0, 1);
2003 if (bh
!= NULL
&& bh
->type
== bfd_link_hash_defined
)
2004 elf_gp (output_bfd
) = (bh
->u
.def
.value
2005 + bh
->u
.def
.section
->output_section
->vma
2006 + bh
->u
.def
.section
->output_offset
);
2007 else if (info
->relocatable
)
2011 /* Find the GP-relative section with the lowest offset. */
2012 for (o
= output_bfd
->sections
; o
!= NULL
; o
= o
->next
)
2015 /* And calculate GP relative to that. */
2016 elf_gp (output_bfd
) = lo
+ ELF_SCORE_GP_OFFSET (input_bfd
);
2020 /* If the relocate_section function needs to do a reloc
2021 involving the GP value, it should make a reloc_dangerous
2022 callback to warn that GP is not defined. */
2026 /* Parse the relocation. */
2027 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2028 r_type
= ELF32_R_TYPE (rel
->r_info
);
2029 rel_addr
= (input_section
->output_section
->vma
+ input_section
->output_offset
+ rel
->r_offset
);
2030 local_p
= score_elf_local_relocation_p (input_bfd
, rel
, local_sections
, TRUE
);
2032 if (r_type
== R_SCORE_GOT15
)
2034 const Elf_Internal_Rela
*relend
;
2035 const Elf_Internal_Rela
*lo16_rel
;
2036 const struct elf_backend_data
*bed
;
2037 bfd_vma lo_value
= 0;
2039 bed
= get_elf_backend_data (output_bfd
);
2040 relend
= relocs
+ input_section
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
2041 lo16_rel
= score_elf_next_relocation (input_bfd
, R_SCORE_GOT_LO16
, rel
, relend
);
2042 if ((local_p
) && (lo16_rel
!= NULL
))
2045 tmp
= score_bfd_get_32 (input_bfd
, contents
+ lo16_rel
->r_offset
);
2046 lo_value
= (((tmp
>> 16) & 0x3) << 14) | ((tmp
& 0x7fff) >> 1);
2050 /* For score3 R_SCORE_ABS32. */
2051 else if (r_type
== R_SCORE_ABS32
|| r_type
== R_SCORE_REL32
)
2053 addend
= (bfd_get_32 (input_bfd
, hit_data
) >> howto
->bitpos
) & howto
->src_mask
;
2057 addend
= (score_bfd_get_32 (input_bfd
, hit_data
) >> howto
->bitpos
) & howto
->src_mask
;
2060 /* If we haven't already determined the GOT offset, or the GP value,
2061 and we're going to need it, get it now. */
2064 case R_SCORE_CALL15
:
2068 g
= score_elf_global_got_index (elf_hash_table (info
)->dynobj
,
2069 (struct elf_link_hash_entry
*) h
);
2070 if ((! elf_hash_table (info
)->dynamic_sections_created
2072 && (info
->symbolic
|| h
->root
.dynindx
== -1)
2073 && h
->root
.def_regular
)))
2075 /* This is a static link or a -Bsymbolic link. The
2076 symbol is defined locally, or was forced to be local.
2077 We must initialize this entry in the GOT. */
2078 bfd
*tmpbfd
= elf_hash_table (info
)->dynobj
;
2079 asection
*sgot
= score_elf_got_section (tmpbfd
, FALSE
);
2080 score_bfd_put_32 (tmpbfd
, value
, sgot
->contents
+ g
);
2083 else if (r_type
== R_SCORE_GOT15
|| r_type
== R_SCORE_CALL15
)
2085 /* There's no need to create a local GOT entry here; the
2086 calculation for a local GOT15 entry does not involve G. */
2091 g
= score_elf_local_got_index (output_bfd
, input_bfd
, info
,
2092 symbol
+ addend
, r_symndx
, h
, r_type
);
2094 return bfd_reloc_outofrange
;
2097 /* Convert GOT indices to actual offsets. */
2098 g
= score_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
2099 output_bfd
, input_bfd
, g
);
2104 case R_SCORE_GPREL32
:
2105 gp
= _bfd_get_gp_value (output_bfd
);
2109 gp
= _bfd_get_gp_value (output_bfd
);
2118 return bfd_reloc_ok
;
2123 || (elf_hash_table (info
)->dynamic_sections_created
2125 && h
->root
.def_dynamic
2126 && !h
->root
.def_regular
))
2127 && r_symndx
!= STN_UNDEF
2128 && (input_section
->flags
& SEC_ALLOC
) != 0)
2130 /* If we're creating a shared library, or this relocation is against a symbol
2131 in a shared library, then we can't know where the symbol will end up.
2132 So, we create a relocation record in the output, and leave the job up
2133 to the dynamic linker. */
2135 if (!score_elf_create_dynamic_relocation (output_bfd
, info
, rel
, h
,
2138 return bfd_reloc_undefined
;
2140 else if (r_symndx
== STN_UNDEF
)
2141 /* r_symndx will be STN_UNDEF (zero) only for relocs against symbols
2142 from removed linkonce sections, or sections discarded by
2147 if (r_type
!= R_SCORE_REL32
)
2148 value
= symbol
+ addend
;
2152 value
&= howto
->dst_mask
;
2153 bfd_put_32 (input_bfd
, value
, hit_data
);
2154 return bfd_reloc_ok
;
2158 if ((long)value
> 0x7fff || (long)value
< -0x8000)
2159 return bfd_reloc_overflow
;
2160 score_bfd_put_16 (input_bfd
, value
, hit_data
);
2161 return bfd_reloc_ok
;
2164 addend
= score_bfd_get_32 (input_bfd
, hit_data
);
2165 offset
= (((addend
& howto
->src_mask
) >> 1) & 0x1ff8000) | ((addend
& howto
->src_mask
) & 0x7fff);
2166 if ((offset
& 0x1000000) != 0)
2167 offset
|= 0xfe000000;
2169 abs_value
= abs (value
- rel_addr
);
2170 if ((abs_value
& 0xfe000000) != 0)
2171 return bfd_reloc_overflow
;
2172 addend
= (addend
& ~howto
->src_mask
)
2173 | (((value
<< 1) & howto
->src_mask
) & 0x3ff0000) | (value
& 0x7fff);
2174 score_bfd_put_32 (input_bfd
, addend
, hit_data
);
2175 return bfd_reloc_ok
;
2180 int not_word_align_p
= 0;
2181 bfd_vma imm_offset
= 0;
2182 addend
= score_bfd_get_48 (input_bfd
, hit_data
);
2183 imm_offset
= ((addend
>> 7) & 0xff)
2184 | (((addend
>> 16) & 0x7fff) << 8)
2185 | (((addend
>> 32) & 0x7f) << 23);
2186 imm_offset
<<= howto
->rightshift
;
2187 value
+= imm_offset
;
2188 value
&= 0xffffffff;
2190 /* Check lw48/sw48 rd, value/label word align. */
2191 if ((value
& 0x3) != 0)
2192 not_word_align_p
= 1;
2194 value
>>= howto
->rightshift
;
2195 addend
= (addend
& ~howto
->src_mask
)
2196 | (((value
& 0xff) >> 0) << 7)
2197 | (((value
& 0x7fff00) >> 8) << 16)
2198 | (((value
& 0x3f800000) >> 23) << 32);
2199 score_bfd_put_48 (input_bfd
, addend
, hit_data
);
2200 if (not_word_align_p
)
2201 return bfd_reloc_other
;
2203 return bfd_reloc_ok
;
2208 bfd_vma imm_offset
= 0;
2209 addend
= score_bfd_get_48 (input_bfd
, hit_data
);
2210 imm_offset
= ((addend
>> 5) & 0x3ff)
2211 | (((addend
>> 16) & 0x7fff) << 10)
2212 | (((addend
>> 32) & 0x7f) << 25);
2213 value
+= imm_offset
;
2214 value
&= 0xffffffff;
2215 addend
= (addend
& ~howto
->src_mask
)
2216 | ((value
& 0x3ff) << 5)
2217 | (((value
>> 10) & 0x7fff) << 16)
2218 | (((value
>> 25) & 0x7f) << 32);
2219 score_bfd_put_48 (input_bfd
, addend
, hit_data
);
2220 return bfd_reloc_ok
;
2224 addend
= score_bfd_get_32 (input_bfd
, hit_data
);
2225 offset
= (((addend
& howto
->src_mask
) & 0x3ff0000) >> 6) | ((addend
& howto
->src_mask
) & 0x3ff);
2226 if ((offset
& 0x80000) != 0)
2227 offset
|= 0xfff00000;
2228 abs_value
= value
= value
- rel_addr
+ offset
;
2229 /* exceed 20 bit : overflow. */
2230 if ((abs_value
& 0x80000000) == 0x80000000)
2231 abs_value
= 0xffffffff - value
+ 1;
2232 if ((abs_value
& 0xfff80000) != 0)
2233 return bfd_reloc_overflow
;
2234 addend
= (addend
& ~howto
->src_mask
)
2235 | (((value
<< 6) & howto
->src_mask
) & 0x3ff0000) | (value
& 0x3ff);
2236 score_bfd_put_32 (input_bfd
, addend
, hit_data
);
2237 return bfd_reloc_ok
;
2240 addend
= score_bfd_get_16 (input_bfd
, hit_data
);
2241 offset
= addend
& howto
->src_mask
;
2242 if ((offset
& 0x800) != 0) /* Offset is negative. */
2243 offset
|= 0xfffff000;
2245 abs_value
= abs (value
- rel_addr
);
2246 if ((abs_value
& 0xfffff000) != 0)
2247 return bfd_reloc_overflow
;
2248 addend
= (addend
& ~howto
->src_mask
) | (value
& howto
->src_mask
);
2249 score_bfd_put_16 (input_bfd
, addend
, hit_data
);
2250 return bfd_reloc_ok
;
2253 addend
= score_bfd_get_16 (input_bfd
, hit_data
);
2254 offset
= (addend
& howto
->src_mask
) << 1;
2255 if ((offset
& 0x200) != 0) /* Offset is negative. */
2256 offset
|= 0xfffffe00;
2257 abs_value
= value
= value
- rel_addr
+ offset
;
2258 /* Sign bit + exceed 9 bit. */
2259 if (((value
& 0xfffffe00) != 0) && ((value
& 0xfffffe00) != 0xfffffe00))
2260 return bfd_reloc_overflow
;
2262 addend
= (addend
& ~howto
->src_mask
) | (value
& howto
->src_mask
);
2263 score_bfd_put_16 (input_bfd
, addend
, hit_data
);
2264 return bfd_reloc_ok
;
2267 addend
= score_bfd_get_32 (input_bfd
, hit_data
);
2268 offset
= (addend
& howto
->src_mask
) << howto
->rightshift
;
2269 if ((offset
& 0x200) != 0) /* Offset is negative. */
2270 offset
|= 0xfffffe00;
2271 value
= value
- rel_addr
+ offset
;
2272 /* Sign bit + exceed 9 bit. */
2273 if (((value
& 0xfffffe00) != 0) && ((value
& 0xfffffe00) != 0xfffffe00))
2274 return bfd_reloc_overflow
;
2275 value
>>= howto
->rightshift
;
2276 addend
= (addend
& ~howto
->src_mask
)
2278 | (((value
>> 1) & 0x7) << 7)
2279 | (((value
>> 4) & 0x1f) << 21);
2280 score_bfd_put_32 (input_bfd
, addend
, hit_data
);
2281 return bfd_reloc_ok
;
2284 return bfd_reloc_ok
;
2287 hi16_addend
= score_bfd_get_32 (input_bfd
, hit_data
- 4);
2288 hi16_offset
= ((((hi16_addend
>> 16) & 0x3) << 15) | (hi16_addend
& 0x7fff)) >> 1;
2289 addend
= score_bfd_get_32 (input_bfd
, hit_data
);
2290 offset
= ((((addend
>> 16) & 0x3) << 15) | (addend
& 0x7fff)) >> 1;
2291 offset
= (hi16_offset
<< 16) | (offset
& 0xffff);
2294 uvalue
= value
+ offset
;
2296 uvalue
= offset
+ gp
- rel_addr
+ 4;
2298 hi16_offset
= (uvalue
>> 16) << 1;
2299 hi16_value
= (hi16_addend
& (~(howto
->dst_mask
)))
2300 | (hi16_offset
& 0x7fff) | ((hi16_offset
<< 1) & 0x30000);
2301 score_bfd_put_32 (input_bfd
, hi16_value
, hit_data
- 4);
2302 offset
= (uvalue
& 0xffff) << 1;
2303 value
= (addend
& (~(howto
->dst_mask
))) | (offset
& 0x7fff) | ((offset
<< 1) & 0x30000);
2304 score_bfd_put_32 (input_bfd
, value
, hit_data
);
2305 return bfd_reloc_ok
;
2308 addend
= score_bfd_get_32 (input_bfd
, hit_data
);
2309 offset
= addend
& 0x7fff;
2310 if ((offset
& 0x4000) == 0x4000)
2311 offset
|= 0xffffc000;
2312 value
= value
+ offset
- gp
;
2313 if (((value
& 0xffffc000) != 0) && ((value
& 0xffffc000) != 0xffffc000))
2314 return bfd_reloc_overflow
;
2315 value
= (addend
& ~howto
->src_mask
) | (value
& howto
->src_mask
);
2316 score_bfd_put_32 (input_bfd
, value
, hit_data
);
2317 return bfd_reloc_ok
;
2320 case R_SCORE_CALL15
:
2325 /* The special case is when the symbol is forced to be local. We need the
2326 full address in the GOT since no R_SCORE_GOT_LO16 relocation follows. */
2327 forced
= ! score_elf_local_relocation_p (input_bfd
, rel
,
2328 local_sections
, FALSE
);
2329 value
= score_elf_got16_entry (output_bfd
, input_bfd
, info
,
2330 symbol
+ addend
, forced
);
2331 if (value
== MINUS_ONE
)
2332 return bfd_reloc_outofrange
;
2333 value
= score_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
2334 output_bfd
, input_bfd
, value
);
2341 if ((long) value
> 0x3fff || (long) value
< -0x4000)
2342 return bfd_reloc_overflow
;
2344 addend
= score_bfd_get_32 (input_bfd
, hit_data
);
2345 value
= (addend
& ~howto
->dst_mask
) | (value
& howto
->dst_mask
);
2346 score_bfd_put_32 (input_bfd
, value
, hit_data
);
2347 return bfd_reloc_ok
;
2349 case R_SCORE_GPREL32
:
2350 value
= (addend
+ symbol
- gp
);
2351 value
&= howto
->dst_mask
;
2352 score_bfd_put_32 (input_bfd
, value
, hit_data
);
2353 return bfd_reloc_ok
;
2355 case R_SCORE_GOT_LO16
:
2356 addend
= score_bfd_get_32 (input_bfd
, hit_data
);
2357 value
= (((addend
>> 16) & 0x3) << 14) | ((addend
& 0x7fff) >> 1);
2359 value
= (addend
& (~(howto
->dst_mask
))) | ((value
& 0x3fff) << 1)
2360 | (((value
>> 14) & 0x3) << 16);
2362 score_bfd_put_32 (input_bfd
, value
, hit_data
);
2363 return bfd_reloc_ok
;
2365 case R_SCORE_DUMMY_HI16
:
2366 return bfd_reloc_ok
;
2368 case R_SCORE_GNU_VTINHERIT
:
2369 case R_SCORE_GNU_VTENTRY
:
2370 /* We don't do anything with these at present. */
2371 return bfd_reloc_continue
;
2374 return bfd_reloc_notsupported
;
2378 /* Score backend functions. */
2380 s3_bfd_score_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
2382 Elf_Internal_Rela
*elf_reloc
)
2384 unsigned int r_type
;
2386 r_type
= ELF32_R_TYPE (elf_reloc
->r_info
);
2387 if (r_type
>= ARRAY_SIZE (elf32_score_howto_table
))
2388 bfd_reloc
->howto
= NULL
;
2390 bfd_reloc
->howto
= &elf32_score_howto_table
[r_type
];
2393 /* Relocate an score ELF section. */
2395 s3_bfd_score_elf_relocate_section (bfd
*output_bfd
,
2396 struct bfd_link_info
*info
,
2398 asection
*input_section
,
2400 Elf_Internal_Rela
*relocs
,
2401 Elf_Internal_Sym
*local_syms
,
2402 asection
**local_sections
)
2404 Elf_Internal_Shdr
*symtab_hdr
;
2405 Elf_Internal_Rela
*rel
;
2406 Elf_Internal_Rela
*relend
;
2408 unsigned long offset
;
2409 unsigned long hi16_addend
, hi16_offset
, hi16_value
, uvalue
;
2411 bfd_boolean gp_disp_p
= FALSE
;
2414 if (elf_hash_table (info
)->dynamic_sections_created
)
2416 bfd_size_type dynsecsymcount
= 0;
2420 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
2422 for (p
= output_bfd
->sections
; p
; p
= p
->next
)
2423 if ((p
->flags
& SEC_EXCLUDE
) == 0
2424 && (p
->flags
& SEC_ALLOC
) != 0
2425 && !(*bed
->elf_backend_omit_section_dynsym
) (output_bfd
, info
, p
))
2429 if (!score_elf_sort_hash_table (info
, dynsecsymcount
+ 1))
2433 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2434 extsymoff
= (elf_bad_symtab (input_bfd
)) ? 0 : symtab_hdr
->sh_info
;
2436 relend
= relocs
+ input_section
->reloc_count
;
2437 for (; rel
< relend
; rel
++)
2440 reloc_howto_type
*howto
;
2441 unsigned long r_symndx
;
2442 Elf_Internal_Sym
*sym
;
2444 struct score_elf_link_hash_entry
*h
;
2445 bfd_vma relocation
= 0;
2446 bfd_reloc_status_type r
;
2449 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2450 r_type
= ELF32_R_TYPE (rel
->r_info
);
2452 s3_bfd_score_info_to_howto (input_bfd
, &bfd_reloc
, (Elf_Internal_Rela
*) rel
);
2453 howto
= bfd_reloc
.howto
;
2459 if (r_symndx
< extsymoff
)
2461 sym
= local_syms
+ r_symndx
;
2462 sec
= local_sections
[r_symndx
];
2463 relocation
= (sec
->output_section
->vma
2464 + sec
->output_offset
2466 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
, sec
);
2468 if (!info
->relocatable
2469 && (sec
->flags
& SEC_MERGE
)
2470 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
2473 bfd_vma addend
, value
;
2480 hi16_addend
= score_bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
- 4);
2481 hi16_offset
= ((((hi16_addend
>> 16) & 0x3) << 15) | (hi16_addend
& 0x7fff)) >> 1;
2482 value
= score_bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
2483 offset
= ((((value
>> 16) & 0x3) << 15) | (value
& 0x7fff)) >> 1;
2484 addend
= (hi16_offset
<< 16) | (offset
& 0xffff);
2486 addend
= _bfd_elf_rel_local_sym (output_bfd
, sym
, &msec
, addend
);
2487 addend
-= relocation
;
2488 addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
2490 hi16_offset
= (uvalue
>> 16) << 1;
2491 hi16_value
= (hi16_addend
& (~(howto
->dst_mask
)))
2492 | (hi16_offset
& 0x7fff) | ((hi16_offset
<< 1) & 0x30000);
2493 score_bfd_put_32 (input_bfd
, hi16_value
, contents
+ rel
->r_offset
- 4);
2494 offset
= (uvalue
& 0xffff) << 1;
2495 value
= (value
& (~(howto
->dst_mask
)))
2496 | (offset
& 0x7fff) | ((offset
<< 1) & 0x30000);
2497 score_bfd_put_32 (input_bfd
, value
, contents
+ rel
->r_offset
);
2502 value
= score_bfd_get_48 (input_bfd
, contents
+ rel
->r_offset
);
2503 addend
= ((value
>> 5) & 0x3ff)
2504 | (((value
>> 16) & 0x7fff) << 10)
2505 | (((value
>> 32) & 0x7f) << 25);
2507 addend
= _bfd_elf_rel_local_sym (output_bfd
, sym
, &msec
, addend
);
2508 addend
-= relocation
;
2509 addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
2510 addend
&= 0xffffffff;
2511 value
= (value
& ~howto
->src_mask
)
2512 | ((addend
& 0x3ff) << 5)
2513 | (((addend
>> 10) & 0x7fff) << 16)
2514 | (((addend
>> 25) & 0x7f) << 32);
2515 score_bfd_put_48 (input_bfd
, value
, contents
+ rel
->r_offset
);
2521 int not_word_align_p
= 0;
2522 value
= score_bfd_get_48 (input_bfd
, contents
+ rel
->r_offset
);
2523 addend
= ((value
>> 7) & 0xff)
2524 | (((value
>> 16) & 0x7fff) << 8)
2525 | (((value
>> 32) & 0x7f) << 23);
2526 addend
<<= howto
->rightshift
;
2528 addend
= _bfd_elf_rel_local_sym (output_bfd
, sym
, &msec
, addend
);
2529 addend
-= relocation
;
2530 addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
2531 addend
&= 0xffffffff;
2533 /* Check lw48/sw48 rd, value/label word align. */
2534 if ((addend
& 0x3) != 0)
2535 not_word_align_p
= 1;
2537 addend
>>= howto
->rightshift
;
2538 value
= (value
& ~howto
->src_mask
)
2539 | (((addend
& 0xff) >> 0) << 7)
2540 | (((addend
& 0x7fff00) >> 8) << 16)
2541 | (((addend
& 0x3f800000) >> 23) << 32);
2542 score_bfd_put_48 (input_bfd
, value
, contents
+ rel
->r_offset
);
2544 if (not_word_align_p
)
2545 return bfd_reloc_other
;
2550 case R_SCORE_GOT_LO16
:
2551 value
= score_bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
2552 addend
= (((value
>> 16) & 0x3) << 14) | ((value
& 0x7fff) >> 1);
2554 addend
= _bfd_elf_rel_local_sym (output_bfd
, sym
, &msec
, addend
) - relocation
;
2555 addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
2556 value
= (value
& (~(howto
->dst_mask
))) | ((addend
& 0x3fff) << 1)
2557 | (((addend
>> 14) & 0x3) << 16);
2559 score_bfd_put_32 (input_bfd
, value
, contents
+ rel
->r_offset
);
2564 value
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
2565 /* Get the (signed) value from the instruction. */
2566 addend
= value
& howto
->src_mask
;
2567 if (addend
& ((howto
->src_mask
+ 1) >> 1))
2569 bfd_signed_vma mask
;
2572 mask
&= ~howto
->src_mask
;
2576 addend
= _bfd_elf_rel_local_sym (output_bfd
, sym
, &msec
, addend
) - relocation
;
2577 addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
2578 value
= (value
& ~howto
->dst_mask
) | (addend
& howto
->dst_mask
);
2579 bfd_put_32 (input_bfd
, value
, contents
+ rel
->r_offset
);
2583 value
= score_bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
2584 /* Get the (signed) value from the instruction. */
2585 addend
= value
& howto
->src_mask
;
2586 if (addend
& ((howto
->src_mask
+ 1) >> 1))
2588 bfd_signed_vma mask
;
2591 mask
&= ~howto
->src_mask
;
2595 addend
= _bfd_elf_rel_local_sym (output_bfd
, sym
, &msec
, addend
) - relocation
;
2596 addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
2597 value
= (value
& ~howto
->dst_mask
) | (addend
& howto
->dst_mask
);
2598 score_bfd_put_32 (input_bfd
, value
, contents
+ rel
->r_offset
);
2605 /* For global symbols we look up the symbol in the hash-table. */
2606 h
= ((struct score_elf_link_hash_entry
*)
2607 elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
]);
2608 /* Find the real hash-table entry for this symbol. */
2609 while (h
->root
.root
.type
== bfd_link_hash_indirect
2610 || h
->root
.root
.type
== bfd_link_hash_warning
)
2611 h
= (struct score_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
2613 /* Record the name of this symbol, for our caller. */
2614 name
= h
->root
.root
.root
.string
;
2616 /* See if this is the special GP_DISP_LABEL symbol. Note that such a
2617 symbol must always be a global symbol. */
2618 if (strcmp (name
, GP_DISP_LABEL
) == 0)
2620 /* Relocations against GP_DISP_LABEL are permitted only with
2621 R_SCORE_HI16 and R_SCORE_LO16 relocations. */
2622 if (r_type
!= R_SCORE_HI16
&& r_type
!= R_SCORE_LO16
)
2623 return bfd_reloc_notsupported
;
2628 /* If this symbol is defined, calculate its address. Note that
2629 GP_DISP_LABEL is a magic symbol, always implicitly defined by the
2630 linker, so it's inappropriate to check to see whether or not
2632 else if ((h
->root
.root
.type
== bfd_link_hash_defined
2633 || h
->root
.root
.type
== bfd_link_hash_defweak
)
2634 && h
->root
.root
.u
.def
.section
)
2636 sec
= h
->root
.root
.u
.def
.section
;
2637 if (sec
->output_section
)
2638 relocation
= (h
->root
.root
.u
.def
.value
2639 + sec
->output_section
->vma
2640 + sec
->output_offset
);
2643 relocation
= h
->root
.root
.u
.def
.value
;
2646 else if (h
->root
.root
.type
== bfd_link_hash_undefweak
)
2647 /* We allow relocations against undefined weak symbols, giving
2648 it the value zero, so that you can undefined weak functions
2649 and check to see if they exist by looking at their addresses. */
2651 else if (info
->unresolved_syms_in_objects
== RM_IGNORE
2652 && ELF_ST_VISIBILITY (h
->root
.other
) == STV_DEFAULT
)
2654 else if (strcmp (name
, "_DYNAMIC_LINK") == 0)
2656 /* If this is a dynamic link, we should have created a _DYNAMIC_LINK symbol
2657 in s3_bfd_score_elf_create_dynamic_sections. Otherwise, we should define
2658 the symbol with a value of 0. */
2659 BFD_ASSERT (! info
->shared
);
2660 BFD_ASSERT (bfd_get_section_by_name (output_bfd
, ".dynamic") == NULL
);
2663 else if (!info
->relocatable
)
2665 if (! ((*info
->callbacks
->undefined_symbol
)
2666 (info
, h
->root
.root
.root
.string
, input_bfd
,
2667 input_section
, rel
->r_offset
,
2668 (info
->unresolved_syms_in_objects
== RM_GENERATE_ERROR
)
2669 || ELF_ST_VISIBILITY (h
->root
.other
))))
2670 return bfd_reloc_undefined
;
2675 if (sec
!= NULL
&& discarded_section (sec
))
2676 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
2677 rel
, 1, relend
, howto
, 0, contents
);
2679 if (info
->relocatable
)
2681 /* This is a relocatable link. We don't have to change
2682 anything, unless the reloc is against a section symbol,
2683 in which case we have to adjust according to where the
2684 section symbol winds up in the output section. */
2685 if (r_symndx
< symtab_hdr
->sh_info
)
2687 sym
= local_syms
+ r_symndx
;
2688 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
2690 sec
= local_sections
[r_symndx
];
2691 score_elf_add_to_rel (input_bfd
, contents
+ rel
->r_offset
,
2692 howto
, (bfd_signed_vma
) (sec
->output_offset
+ sym
->st_value
));
2698 /* This is a final link. */
2699 r
= score_elf_final_link_relocate (howto
, input_bfd
, output_bfd
,
2700 input_section
, contents
, rel
, relocs
,
2701 relocation
, info
, name
,
2702 (h
? ELF_ST_TYPE ((unsigned int)h
->root
.root
.type
) :
2703 ELF_ST_TYPE ((unsigned int)sym
->st_info
)), h
, local_sections
,
2706 if (r
!= bfd_reloc_ok
)
2708 const char *msg
= (const char *)0;
2712 case bfd_reloc_overflow
:
2713 /* If the overflowing reloc was to an undefined symbol,
2714 we have already printed one error message and there
2715 is no point complaining again. */
2716 if (((!h
) || (h
->root
.root
.type
!= bfd_link_hash_undefined
))
2717 && (!((*info
->callbacks
->reloc_overflow
)
2718 (info
, NULL
, name
, howto
->name
, (bfd_vma
) 0,
2719 input_bfd
, input_section
, rel
->r_offset
))))
2722 case bfd_reloc_undefined
:
2723 if (!((*info
->callbacks
->undefined_symbol
)
2724 (info
, name
, input_bfd
, input_section
, rel
->r_offset
, TRUE
)))
2728 case bfd_reloc_outofrange
:
2729 msg
= _("internal error: out of range error");
2732 case bfd_reloc_notsupported
:
2733 msg
= _("internal error: unsupported relocation error");
2736 case bfd_reloc_dangerous
:
2737 msg
= _("internal error: dangerous error");
2740 /* Use bfd_reloc_other to check lw48, sw48 word align. */
2741 case bfd_reloc_other
:
2742 msg
= _("address not word align");
2746 msg
= _("internal error: unknown error");
2750 if (!((*info
->callbacks
->warning
)
2751 (info
, msg
, name
, input_bfd
, input_section
, rel
->r_offset
)))
2761 /* Look through the relocs for a section during the first phase, and
2762 allocate space in the global offset table. */
2764 s3_bfd_score_elf_check_relocs (bfd
*abfd
,
2765 struct bfd_link_info
*info
,
2767 const Elf_Internal_Rela
*relocs
)
2771 Elf_Internal_Shdr
*symtab_hdr
;
2772 struct elf_link_hash_entry
**sym_hashes
;
2773 struct score_got_info
*g
;
2775 const Elf_Internal_Rela
*rel
;
2776 const Elf_Internal_Rela
*rel_end
;
2779 const struct elf_backend_data
*bed
;
2781 if (info
->relocatable
)
2784 dynobj
= elf_hash_table (info
)->dynobj
;
2785 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2786 sym_hashes
= elf_sym_hashes (abfd
);
2787 extsymoff
= (elf_bad_symtab (abfd
)) ? 0 : symtab_hdr
->sh_info
;
2789 name
= bfd_get_section_name (abfd
, sec
);
2798 sgot
= score_elf_got_section (dynobj
, FALSE
);
2803 BFD_ASSERT (score_elf_section_data (sgot
) != NULL
);
2804 g
= score_elf_section_data (sgot
)->u
.got_info
;
2805 BFD_ASSERT (g
!= NULL
);
2810 bed
= get_elf_backend_data (abfd
);
2811 rel_end
= relocs
+ sec
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
2812 for (rel
= relocs
; rel
< rel_end
; ++rel
)
2814 unsigned long r_symndx
;
2815 unsigned int r_type
;
2816 struct elf_link_hash_entry
*h
;
2818 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2819 r_type
= ELF32_R_TYPE (rel
->r_info
);
2821 if (r_symndx
< extsymoff
)
2825 else if (r_symndx
>= extsymoff
+ NUM_SHDR_ENTRIES (symtab_hdr
))
2827 (*_bfd_error_handler
) (_("%s: Malformed reloc detected for section %s"), abfd
, name
);
2828 bfd_set_error (bfd_error_bad_value
);
2833 h
= sym_hashes
[r_symndx
- extsymoff
];
2835 /* This may be an indirect symbol created because of a version. */
2838 while (h
->root
.type
== bfd_link_hash_indirect
)
2839 h
= (struct elf_link_hash_entry
*)h
->root
.u
.i
.link
;
2841 /* PR15323, ref flags aren't set for references in the
2843 h
->root
.non_ir_ref
= 1;
2847 /* Some relocs require a global offset table. */
2848 if (dynobj
== NULL
|| sgot
== NULL
)
2853 case R_SCORE_CALL15
:
2855 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
2856 if (!score_elf_create_got_section (dynobj
, info
, FALSE
))
2858 g
= score_elf_got_info (dynobj
, &sgot
);
2862 if (dynobj
== NULL
&& (info
->shared
|| h
!= NULL
) && (sec
->flags
& SEC_ALLOC
) != 0)
2863 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
2870 if (!h
&& (r_type
== R_SCORE_GOT_LO16
))
2872 if (! score_elf_record_local_got_symbol (abfd
, r_symndx
, rel
->r_addend
, g
))
2878 case R_SCORE_CALL15
:
2881 (*_bfd_error_handler
)
2882 (_("%B: CALL15 reloc at 0x%lx not against global symbol"),
2883 abfd
, (unsigned long) rel
->r_offset
);
2884 bfd_set_error (bfd_error_bad_value
);
2889 /* This symbol requires a global offset table entry. */
2890 if (! score_elf_record_global_got_symbol (h
, abfd
, info
, g
))
2893 /* We need a stub, not a plt entry for the undefined function. But we record
2894 it as if it needs plt. See _bfd_elf_adjust_dynamic_symbol. */
2900 if (h
&& ! score_elf_record_global_got_symbol (h
, abfd
, info
, g
))
2905 if ((info
->shared
|| h
!= NULL
) && (sec
->flags
& SEC_ALLOC
) != 0)
2909 sreloc
= score_elf_rel_dyn_section (dynobj
, TRUE
);
2913 #define SCORE_READONLY_SECTION (SEC_ALLOC | SEC_LOAD | SEC_READONLY)
2916 /* When creating a shared object, we must copy these reloc types into
2917 the output file as R_SCORE_REL32 relocs. We make room for this reloc
2918 in the .rel.dyn reloc section. */
2919 score_elf_allocate_dynamic_relocations (dynobj
, 1);
2920 if ((sec
->flags
& SCORE_READONLY_SECTION
)
2921 == SCORE_READONLY_SECTION
)
2922 /* We tell the dynamic linker that there are
2923 relocations against the text segment. */
2924 info
->flags
|= DF_TEXTREL
;
2928 struct score_elf_link_hash_entry
*hscore
;
2930 /* We only need to copy this reloc if the symbol is
2931 defined in a dynamic object. */
2932 hscore
= (struct score_elf_link_hash_entry
*)h
;
2933 ++hscore
->possibly_dynamic_relocs
;
2934 if ((sec
->flags
& SCORE_READONLY_SECTION
)
2935 == SCORE_READONLY_SECTION
)
2936 /* We need it to tell the dynamic linker if there
2937 are relocations against the text segment. */
2938 hscore
->readonly_reloc
= TRUE
;
2941 /* Even though we don't directly need a GOT entry for this symbol,
2942 a symbol must have a dynamic symbol table index greater that
2943 DT_SCORE_GOTSYM if there are dynamic relocations against it. */
2947 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
2948 if (! score_elf_create_got_section (dynobj
, info
, TRUE
))
2950 g
= score_elf_got_info (dynobj
, &sgot
);
2951 if (! score_elf_record_global_got_symbol (h
, abfd
, info
, g
))
2957 /* This relocation describes the C++ object vtable hierarchy.
2958 Reconstruct it for later use during GC. */
2959 case R_SCORE_GNU_VTINHERIT
:
2960 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
2964 /* This relocation describes which C++ vtable entries are actually
2965 used. Record for later use during GC. */
2966 case R_SCORE_GNU_VTENTRY
:
2967 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
2974 /* We must not create a stub for a symbol that has relocations
2975 related to taking the function's address. */
2981 struct score_elf_link_hash_entry
*sh
;
2983 sh
= (struct score_elf_link_hash_entry
*) h
;
2984 sh
->no_fn_stub
= TRUE
;
2987 case R_SCORE_CALL15
:
2996 s3_bfd_score_elf_add_symbol_hook (bfd
*abfd
,
2997 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2998 Elf_Internal_Sym
*sym
,
2999 const char **namep ATTRIBUTE_UNUSED
,
3000 flagword
*flagsp ATTRIBUTE_UNUSED
,
3004 switch (sym
->st_shndx
)
3007 if (sym
->st_size
> elf_gp_size (abfd
))
3010 case SHN_SCORE_SCOMMON
:
3011 *secp
= bfd_make_section_old_way (abfd
, ".scommon");
3012 (*secp
)->flags
|= SEC_IS_COMMON
;
3013 *valp
= sym
->st_size
;
3021 s3_bfd_score_elf_symbol_processing (bfd
*abfd
, asymbol
*asym
)
3023 elf_symbol_type
*elfsym
;
3025 elfsym
= (elf_symbol_type
*) asym
;
3026 switch (elfsym
->internal_elf_sym
.st_shndx
)
3029 if (asym
->value
> elf_gp_size (abfd
))
3032 case SHN_SCORE_SCOMMON
:
3033 if (score_elf_scom_section
.name
== NULL
)
3035 /* Initialize the small common section. */
3036 score_elf_scom_section
.name
= ".scommon";
3037 score_elf_scom_section
.flags
= SEC_IS_COMMON
;
3038 score_elf_scom_section
.output_section
= &score_elf_scom_section
;
3039 score_elf_scom_section
.symbol
= &score_elf_scom_symbol
;
3040 score_elf_scom_section
.symbol_ptr_ptr
= &score_elf_scom_symbol_ptr
;
3041 score_elf_scom_symbol
.name
= ".scommon";
3042 score_elf_scom_symbol
.flags
= BSF_SECTION_SYM
;
3043 score_elf_scom_symbol
.section
= &score_elf_scom_section
;
3044 score_elf_scom_symbol_ptr
= &score_elf_scom_symbol
;
3046 asym
->section
= &score_elf_scom_section
;
3047 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
3053 s3_bfd_score_elf_link_output_symbol_hook (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
3054 const char *name ATTRIBUTE_UNUSED
,
3055 Elf_Internal_Sym
*sym
,
3056 asection
*input_sec
,
3057 struct elf_link_hash_entry
*h ATTRIBUTE_UNUSED
)
3059 /* If we see a common symbol, which implies a relocatable link, then
3060 if a symbol was small common in an input file, mark it as small
3061 common in the output file. */
3062 if (sym
->st_shndx
== SHN_COMMON
&& strcmp (input_sec
->name
, ".scommon") == 0)
3063 sym
->st_shndx
= SHN_SCORE_SCOMMON
;
3069 s3_bfd_score_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
3073 if (strcmp (bfd_get_section_name (abfd
, sec
), ".scommon") == 0)
3075 *retval
= SHN_SCORE_SCOMMON
;
3082 /* Adjust a symbol defined by a dynamic object and referenced by a
3083 regular object. The current definition is in some section of the
3084 dynamic object, but we're not including those sections. We have to
3085 change the definition to something the rest of the link can understand. */
3087 s3_bfd_score_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
3088 struct elf_link_hash_entry
*h
)
3091 struct score_elf_link_hash_entry
*hscore
;
3094 dynobj
= elf_hash_table (info
)->dynobj
;
3096 /* Make sure we know what is going on here. */
3097 BFD_ASSERT (dynobj
!= NULL
3099 || h
->u
.weakdef
!= NULL
3100 || (h
->def_dynamic
&& h
->ref_regular
&& !h
->def_regular
)));
3102 /* If this symbol is defined in a dynamic object, we need to copy
3103 any R_SCORE_ABS32 or R_SCORE_REL32 relocs against it into the output
3105 hscore
= (struct score_elf_link_hash_entry
*)h
;
3106 if (!info
->relocatable
3107 && hscore
->possibly_dynamic_relocs
!= 0
3108 && (h
->root
.type
== bfd_link_hash_defweak
|| !h
->def_regular
))
3110 score_elf_allocate_dynamic_relocations (dynobj
, hscore
->possibly_dynamic_relocs
);
3111 if (hscore
->readonly_reloc
)
3112 /* We tell the dynamic linker that there are relocations
3113 against the text segment. */
3114 info
->flags
|= DF_TEXTREL
;
3117 /* For a function, create a stub, if allowed. */
3118 if (!hscore
->no_fn_stub
&& h
->needs_plt
)
3120 if (!elf_hash_table (info
)->dynamic_sections_created
)
3123 /* If this symbol is not defined in a regular file, then set
3124 the symbol to the stub location. This is required to make
3125 function pointers compare as equal between the normal
3126 executable and the shared library. */
3127 if (!h
->def_regular
)
3129 /* We need .stub section. */
3130 s
= bfd_get_linker_section (dynobj
, SCORE_ELF_STUB_SECTION_NAME
);
3131 BFD_ASSERT (s
!= NULL
);
3133 h
->root
.u
.def
.section
= s
;
3134 h
->root
.u
.def
.value
= s
->size
;
3136 /* XXX Write this stub address somewhere. */
3137 h
->plt
.offset
= s
->size
;
3139 /* Make room for this stub code. */
3140 s
->size
+= SCORE_FUNCTION_STUB_SIZE
;
3142 /* The last half word of the stub will be filled with the index
3143 of this symbol in .dynsym section. */
3147 else if ((h
->type
== STT_FUNC
) && !h
->needs_plt
)
3149 /* This will set the entry for this symbol in the GOT to 0, and
3150 the dynamic linker will take care of this. */
3151 h
->root
.u
.def
.value
= 0;
3155 /* If this is a weak symbol, and there is a real definition, the
3156 processor independent code will have arranged for us to see the
3157 real definition first, and we can just use the same value. */
3158 if (h
->u
.weakdef
!= NULL
)
3160 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
3161 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
3162 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
3163 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
3167 /* This is a reference to a symbol defined by a dynamic object which
3168 is not a function. */
3172 /* This function is called after all the input files have been read,
3173 and the input sections have been assigned to output sections. */
3175 s3_bfd_score_elf_always_size_sections (bfd
*output_bfd
,
3176 struct bfd_link_info
*info
)
3180 struct score_got_info
*g
;
3182 bfd_size_type loadable_size
= 0;
3183 bfd_size_type local_gotno
;
3186 dynobj
= elf_hash_table (info
)->dynobj
;
3188 /* Relocatable links don't have it. */
3191 g
= score_elf_got_info (dynobj
, &s
);
3195 /* Calculate the total loadable size of the output. That will give us the
3196 maximum number of GOT_PAGE entries required. */
3197 for (sub
= info
->input_bfds
; sub
; sub
= sub
->link_next
)
3199 asection
*subsection
;
3201 for (subsection
= sub
->sections
;
3203 subsection
= subsection
->next
)
3205 if ((subsection
->flags
& SEC_ALLOC
) == 0)
3207 loadable_size
+= ((subsection
->size
+ 0xf)
3208 &~ (bfd_size_type
) 0xf);
3212 /* There has to be a global GOT entry for every symbol with
3213 a dynamic symbol table index of DT_SCORE_GOTSYM or
3214 higher. Therefore, it make sense to put those symbols
3215 that need GOT entries at the end of the symbol table. We
3217 if (! score_elf_sort_hash_table (info
, 1))
3220 if (g
->global_gotsym
!= NULL
)
3221 i
= elf_hash_table (info
)->dynsymcount
- g
->global_gotsym
->dynindx
;
3223 /* If there are no global symbols, or none requiring
3224 relocations, then GLOBAL_GOTSYM will be NULL. */
3227 /* In the worst case, we'll get one stub per dynamic symbol. */
3228 loadable_size
+= SCORE_FUNCTION_STUB_SIZE
* i
;
3230 /* Assume there are two loadable segments consisting of
3231 contiguous sections. Is 5 enough? */
3232 local_gotno
= (loadable_size
>> 16) + 5;
3234 g
->local_gotno
+= local_gotno
;
3235 s
->size
+= g
->local_gotno
* SCORE_ELF_GOT_SIZE (output_bfd
);
3237 g
->global_gotno
= i
;
3238 s
->size
+= i
* SCORE_ELF_GOT_SIZE (output_bfd
);
3240 score_elf_resolve_final_got_entries (g
);
3242 if (s
->size
> SCORE_ELF_GOT_MAX_SIZE (output_bfd
))
3244 /* Fixme. Error message or Warning message should be issued here. */
3250 /* Set the sizes of the dynamic sections. */
3252 s3_bfd_score_elf_size_dynamic_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
3256 bfd_boolean reltext
;
3258 dynobj
= elf_hash_table (info
)->dynobj
;
3259 BFD_ASSERT (dynobj
!= NULL
);
3261 if (elf_hash_table (info
)->dynamic_sections_created
)
3263 /* Set the contents of the .interp section to the interpreter. */
3266 s
= bfd_get_linker_section (dynobj
, ".interp");
3267 BFD_ASSERT (s
!= NULL
);
3268 s
->size
= strlen (ELF_DYNAMIC_INTERPRETER
) + 1;
3269 s
->contents
= (bfd_byte
*) ELF_DYNAMIC_INTERPRETER
;
3273 /* The check_relocs and adjust_dynamic_symbol entry points have
3274 determined the sizes of the various dynamic sections. Allocate
3277 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3281 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3284 /* It's OK to base decisions on the section name, because none
3285 of the dynobj section names depend upon the input files. */
3286 name
= bfd_get_section_name (dynobj
, s
);
3288 if (CONST_STRNEQ (name
, ".rel"))
3292 /* We only strip the section if the output section name
3293 has the same name. Otherwise, there might be several
3294 input sections for this output section. FIXME: This
3295 code is probably not needed these days anyhow, since
3296 the linker now does not create empty output sections. */
3297 if (s
->output_section
!= NULL
3299 bfd_get_section_name (s
->output_section
->owner
,
3300 s
->output_section
)) == 0)
3301 s
->flags
|= SEC_EXCLUDE
;
3305 const char *outname
;
3308 /* If this relocation section applies to a read only
3309 section, then we probably need a DT_TEXTREL entry.
3310 If the relocation section is .rel.dyn, we always
3311 assert a DT_TEXTREL entry rather than testing whether
3312 there exists a relocation to a read only section or
3314 outname
= bfd_get_section_name (output_bfd
, s
->output_section
);
3315 target
= bfd_get_section_by_name (output_bfd
, outname
+ 4);
3317 && (target
->flags
& SEC_READONLY
) != 0
3318 && (target
->flags
& SEC_ALLOC
) != 0) || strcmp (outname
, ".rel.dyn") == 0)
3321 /* We use the reloc_count field as a counter if we need
3322 to copy relocs into the output file. */
3323 if (strcmp (name
, ".rel.dyn") != 0)
3327 else if (CONST_STRNEQ (name
, ".got"))
3329 /* s3_bfd_score_elf_always_size_sections() has already done
3330 most of the work, but some symbols may have been mapped
3331 to versions that we must now resolve in the got_entries
3334 else if (strcmp (name
, SCORE_ELF_STUB_SECTION_NAME
) == 0)
3336 /* IRIX rld assumes that the function stub isn't at the end
3337 of .text section. So put a dummy. XXX */
3338 s
->size
+= SCORE_FUNCTION_STUB_SIZE
;
3340 else if (! CONST_STRNEQ (name
, ".init"))
3342 /* It's not one of our sections, so don't allocate space. */
3346 /* Allocate memory for the section contents. */
3347 s
->contents
= bfd_zalloc (dynobj
, s
->size
);
3348 if (s
->contents
== NULL
&& s
->size
!= 0)
3350 bfd_set_error (bfd_error_no_memory
);
3355 if (elf_hash_table (info
)->dynamic_sections_created
)
3357 /* Add some entries to the .dynamic section. We fill in the
3358 values later, in s3_bfd_score_elf_finish_dynamic_sections, but we
3359 must add the entries now so that we get the correct size for
3360 the .dynamic section. The DT_DEBUG entry is filled in by the
3361 dynamic linker and used by the debugger. */
3363 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info
, DT_DEBUG
, 0))
3367 info
->flags
|= DF_TEXTREL
;
3369 if ((info
->flags
& DF_TEXTREL
) != 0)
3371 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info
, DT_TEXTREL
, 0))
3375 if (! SCORE_ELF_ADD_DYNAMIC_ENTRY (info
, DT_PLTGOT
, 0))
3378 if (score_elf_rel_dyn_section (dynobj
, FALSE
))
3380 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info
, DT_REL
, 0))
3383 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELSZ
, 0))
3386 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELENT
, 0))
3390 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info
, DT_SCORE_BASE_ADDRESS
, 0))
3393 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info
, DT_SCORE_LOCAL_GOTNO
, 0))
3396 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info
, DT_SCORE_SYMTABNO
, 0))
3399 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info
, DT_SCORE_UNREFEXTNO
, 0))
3402 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info
, DT_SCORE_GOTSYM
, 0))
3405 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info
, DT_SCORE_HIPAGENO
, 0))
3413 s3_bfd_score_elf_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3415 struct elf_link_hash_entry
*h
;
3416 struct bfd_link_hash_entry
*bh
;
3420 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
3421 | SEC_LINKER_CREATED
| SEC_READONLY
);
3423 /* ABI requests the .dynamic section to be read only. */
3424 s
= bfd_get_linker_section (abfd
, ".dynamic");
3427 if (!bfd_set_section_flags (abfd
, s
, flags
))
3431 /* We need to create .got section. */
3432 if (!score_elf_create_got_section (abfd
, info
, FALSE
))
3435 if (!score_elf_rel_dyn_section (elf_hash_table (info
)->dynobj
, TRUE
))
3438 /* Create .stub section. */
3439 if (bfd_get_linker_section (abfd
, SCORE_ELF_STUB_SECTION_NAME
) == NULL
)
3441 s
= bfd_make_section_anyway_with_flags (abfd
, SCORE_ELF_STUB_SECTION_NAME
,
3444 || !bfd_set_section_alignment (abfd
, s
, 2))
3453 name
= "_DYNAMIC_LINK";
3455 if (!(_bfd_generic_link_add_one_symbol
3456 (info
, abfd
, name
, BSF_GLOBAL
, bfd_abs_section_ptr
,
3457 (bfd_vma
) 0, NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
3460 h
= (struct elf_link_hash_entry
*)bh
;
3463 h
->type
= STT_SECTION
;
3465 if (!bfd_elf_link_record_dynamic_symbol (info
, h
))
3473 /* Finish up dynamic symbol handling. We set the contents of various
3474 dynamic sections here. */
3476 s3_bfd_score_elf_finish_dynamic_symbol (bfd
*output_bfd
,
3477 struct bfd_link_info
*info
,
3478 struct elf_link_hash_entry
*h
,
3479 Elf_Internal_Sym
*sym
)
3483 struct score_got_info
*g
;
3486 dynobj
= elf_hash_table (info
)->dynobj
;
3488 if (h
->plt
.offset
!= MINUS_ONE
)
3491 bfd_byte stub
[SCORE_FUNCTION_STUB_SIZE
];
3493 /* This symbol has a stub. Set it up. */
3494 BFD_ASSERT (h
->dynindx
!= -1);
3496 s
= bfd_get_linker_section (dynobj
, SCORE_ELF_STUB_SECTION_NAME
);
3497 BFD_ASSERT (s
!= NULL
);
3499 /* FIXME: Can h->dynindex be more than 64K? */
3500 if (h
->dynindx
& 0xffff0000)
3503 /* Fill the stub. */
3504 score_bfd_put_32 (output_bfd
, STUB_LW
, stub
);
3505 score_bfd_put_32 (output_bfd
, STUB_MOVE
, stub
+ 4);
3506 score_bfd_put_32 (output_bfd
, STUB_LI16
| (h
->dynindx
<< 1), stub
+ 8);
3507 score_bfd_put_32 (output_bfd
, STUB_BRL
, stub
+ 12);
3509 BFD_ASSERT (h
->plt
.offset
<= s
->size
);
3510 memcpy (s
->contents
+ h
->plt
.offset
, stub
, SCORE_FUNCTION_STUB_SIZE
);
3512 /* Mark the symbol as undefined. plt.offset != -1 occurs
3513 only for the referenced symbol. */
3514 sym
->st_shndx
= SHN_UNDEF
;
3516 /* The run-time linker uses the st_value field of the symbol
3517 to reset the global offset table entry for this external
3518 to its stub address when unlinking a shared object. */
3519 sym
->st_value
= (s
->output_section
->vma
+ s
->output_offset
+ h
->plt
.offset
);
3522 BFD_ASSERT (h
->dynindx
!= -1 || h
->forced_local
);
3524 sgot
= score_elf_got_section (dynobj
, FALSE
);
3525 BFD_ASSERT (sgot
!= NULL
);
3526 BFD_ASSERT (score_elf_section_data (sgot
) != NULL
);
3527 g
= score_elf_section_data (sgot
)->u
.got_info
;
3528 BFD_ASSERT (g
!= NULL
);
3530 /* Run through the global symbol table, creating GOT entries for all
3531 the symbols that need them. */
3532 if (g
->global_gotsym
!= NULL
&& h
->dynindx
>= g
->global_gotsym
->dynindx
)
3537 value
= sym
->st_value
;
3538 offset
= score_elf_global_got_index (dynobj
, h
);
3539 score_bfd_put_32 (output_bfd
, value
, sgot
->contents
+ offset
);
3542 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3543 name
= h
->root
.root
.string
;
3544 if (h
== elf_hash_table (info
)->hdynamic
3545 || h
== elf_hash_table (info
)->hgot
)
3546 sym
->st_shndx
= SHN_ABS
;
3547 else if (strcmp (name
, "_DYNAMIC_LINK") == 0)
3549 sym
->st_shndx
= SHN_ABS
;
3550 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
3553 else if (strcmp (name
, GP_DISP_LABEL
) == 0)
3555 sym
->st_shndx
= SHN_ABS
;
3556 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
3557 sym
->st_value
= elf_gp (output_bfd
);
3563 /* Finish up the dynamic sections. */
3565 s3_bfd_score_elf_finish_dynamic_sections (bfd
*output_bfd
,
3566 struct bfd_link_info
*info
)
3572 struct score_got_info
*g
;
3574 dynobj
= elf_hash_table (info
)->dynobj
;
3576 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
3578 sgot
= score_elf_got_section (dynobj
, FALSE
);
3583 BFD_ASSERT (score_elf_section_data (sgot
) != NULL
);
3584 g
= score_elf_section_data (sgot
)->u
.got_info
;
3585 BFD_ASSERT (g
!= NULL
);
3588 if (elf_hash_table (info
)->dynamic_sections_created
)
3592 BFD_ASSERT (sdyn
!= NULL
);
3593 BFD_ASSERT (g
!= NULL
);
3595 for (b
= sdyn
->contents
;
3596 b
< sdyn
->contents
+ sdyn
->size
;
3597 b
+= SCORE_ELF_DYN_SIZE (dynobj
))
3599 Elf_Internal_Dyn dyn
;
3602 bfd_boolean swap_out_p
;
3604 /* Read in the current dynamic entry. */
3605 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_in
) (dynobj
, b
, &dyn
);
3607 /* Assume that we're going to modify it and write it out. */
3613 s
= score_elf_rel_dyn_section (dynobj
, FALSE
);
3614 BFD_ASSERT (s
!= NULL
);
3615 dyn
.d_un
.d_val
= SCORE_ELF_REL_SIZE (dynobj
);
3619 /* Rewrite DT_STRSZ. */
3620 dyn
.d_un
.d_val
= _bfd_elf_strtab_size (elf_hash_table (info
)->dynstr
);
3625 s
= bfd_get_section_by_name (output_bfd
, name
);
3626 BFD_ASSERT (s
!= NULL
);
3627 dyn
.d_un
.d_ptr
= s
->vma
;
3630 case DT_SCORE_BASE_ADDRESS
:
3631 s
= output_bfd
->sections
;
3632 BFD_ASSERT (s
!= NULL
);
3633 dyn
.d_un
.d_ptr
= s
->vma
& ~(bfd_vma
) 0xffff;
3636 case DT_SCORE_LOCAL_GOTNO
:
3637 dyn
.d_un
.d_val
= g
->local_gotno
;
3640 case DT_SCORE_UNREFEXTNO
:
3641 /* The index into the dynamic symbol table which is the
3642 entry of the first external symbol that is not
3643 referenced within the same object. */
3644 dyn
.d_un
.d_val
= bfd_count_sections (output_bfd
) + 1;
3647 case DT_SCORE_GOTSYM
:
3648 if (g
->global_gotsym
)
3650 dyn
.d_un
.d_val
= g
->global_gotsym
->dynindx
;
3653 /* In case if we don't have global got symbols we default
3654 to setting DT_SCORE_GOTSYM to the same value as
3655 DT_SCORE_SYMTABNO, so we just fall through. */
3657 case DT_SCORE_SYMTABNO
:
3659 elemsize
= SCORE_ELF_SYM_SIZE (output_bfd
);
3660 s
= bfd_get_section_by_name (output_bfd
, name
);
3661 BFD_ASSERT (s
!= NULL
);
3663 dyn
.d_un
.d_val
= s
->size
/ elemsize
;
3666 case DT_SCORE_HIPAGENO
:
3667 dyn
.d_un
.d_val
= g
->local_gotno
- SCORE_RESERVED_GOTNO
;
3676 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_out
) (dynobj
, &dyn
, b
);
3680 /* The first entry of the global offset table will be filled at
3681 runtime. The second entry will be used by some runtime loaders.
3682 This isn't the case of IRIX rld. */
3683 if (sgot
!= NULL
&& sgot
->size
> 0)
3685 score_bfd_put_32 (output_bfd
, 0, sgot
->contents
);
3686 score_bfd_put_32 (output_bfd
, 0x80000000, sgot
->contents
+ SCORE_ELF_GOT_SIZE (output_bfd
));
3690 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
3691 = SCORE_ELF_GOT_SIZE (output_bfd
);
3694 /* We need to sort the entries of the dynamic relocation section. */
3695 s
= score_elf_rel_dyn_section (dynobj
, FALSE
);
3697 if (s
!= NULL
&& s
->size
> (bfd_vma
)2 * SCORE_ELF_REL_SIZE (output_bfd
))
3699 reldyn_sorting_bfd
= output_bfd
;
3700 qsort ((Elf32_External_Rel
*) s
->contents
+ 1, s
->reloc_count
- 1,
3701 sizeof (Elf32_External_Rel
), score_elf_sort_dynamic_relocs
);
3707 /* This function set up the ELF section header for a BFD section in preparation for writing
3708 it out. This is where the flags and type fields are set for unusual sections. */
3710 s3_bfd_score_elf_fake_sections (bfd
*abfd ATTRIBUTE_UNUSED
,
3711 Elf_Internal_Shdr
*hdr
,
3716 name
= bfd_get_section_name (abfd
, sec
);
3718 if (strcmp (name
, ".got") == 0
3719 || strcmp (name
, ".srdata") == 0
3720 || strcmp (name
, ".sdata") == 0
3721 || strcmp (name
, ".sbss") == 0)
3722 hdr
->sh_flags
|= SHF_SCORE_GPREL
;
3727 /* This function do additional processing on the ELF section header before writing
3728 it out. This is used to set the flags and type fields for some sections. */
3730 /* assign_file_positions_except_relocs() check section flag and if it is allocatable,
3731 warning message will be issued. backend_fake_section is called before
3732 assign_file_positions_except_relocs(); backend_section_processing after it. so, we
3733 modify section flag there, but not backend_fake_section. */
3735 s3_bfd_score_elf_section_processing (bfd
*abfd ATTRIBUTE_UNUSED
, Elf_Internal_Shdr
*hdr
)
3737 if (hdr
->bfd_section
!= NULL
)
3739 const char *name
= bfd_get_section_name (abfd
, hdr
->bfd_section
);
3741 if (strcmp (name
, ".sdata") == 0)
3743 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_SCORE_GPREL
;
3744 hdr
->sh_type
= SHT_PROGBITS
;
3746 else if (strcmp (name
, ".sbss") == 0)
3748 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_SCORE_GPREL
;
3749 hdr
->sh_type
= SHT_NOBITS
;
3751 else if (strcmp (name
, ".srdata") == 0)
3753 hdr
->sh_flags
|= SHF_ALLOC
| SHF_SCORE_GPREL
;
3754 hdr
->sh_type
= SHT_PROGBITS
;
3762 s3_bfd_score_elf_write_section (bfd
*output_bfd
, asection
*sec
, bfd_byte
*contents
)
3764 bfd_byte
*to
, *from
, *end
;
3767 if (strcmp (sec
->name
, ".pdr") != 0)
3770 if (score_elf_section_data (sec
)->u
.tdata
== NULL
)
3774 end
= contents
+ sec
->size
;
3775 for (from
= contents
, i
= 0; from
< end
; from
+= PDR_SIZE
, i
++)
3777 if ((score_elf_section_data (sec
)->u
.tdata
)[i
] == 1)
3781 memcpy (to
, from
, PDR_SIZE
);
3785 bfd_set_section_contents (output_bfd
, sec
->output_section
, contents
,
3786 (file_ptr
) sec
->output_offset
, sec
->size
);
3791 /* Copy data from a SCORE ELF indirect symbol to its direct symbol, hiding the old
3792 indirect symbol. Process additional relocation information. */
3794 s3_bfd_score_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
3795 struct elf_link_hash_entry
*dir
,
3796 struct elf_link_hash_entry
*ind
)
3798 struct score_elf_link_hash_entry
*dirscore
, *indscore
;
3800 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
3802 if (ind
->root
.type
!= bfd_link_hash_indirect
)
3805 dirscore
= (struct score_elf_link_hash_entry
*) dir
;
3806 indscore
= (struct score_elf_link_hash_entry
*) ind
;
3807 dirscore
->possibly_dynamic_relocs
+= indscore
->possibly_dynamic_relocs
;
3809 if (indscore
->readonly_reloc
)
3810 dirscore
->readonly_reloc
= TRUE
;
3812 if (indscore
->no_fn_stub
)
3813 dirscore
->no_fn_stub
= TRUE
;
3816 /* Remove information about discarded functions from other sections which mention them. */
3818 s3_bfd_score_elf_discard_info (bfd
*abfd
, struct elf_reloc_cookie
*cookie
,
3819 struct bfd_link_info
*info
)
3822 bfd_boolean ret
= FALSE
;
3823 unsigned char *tdata
;
3826 o
= bfd_get_section_by_name (abfd
, ".pdr");
3827 if ((!o
) || (o
->size
== 0) || (o
->size
% PDR_SIZE
!= 0)
3828 || (o
->output_section
!= NULL
&& bfd_is_abs_section (o
->output_section
)))
3831 tdata
= bfd_zmalloc (o
->size
/ PDR_SIZE
);
3835 cookie
->rels
= _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
, info
->keep_memory
);
3842 cookie
->rel
= cookie
->rels
;
3843 cookie
->relend
= cookie
->rels
+ o
->reloc_count
;
3845 for (i
= 0, skip
= 0; i
< o
->size
; i
++)
3847 if (bfd_elf_reloc_symbol_deleted_p (i
* PDR_SIZE
, cookie
))
3856 score_elf_section_data (o
)->u
.tdata
= tdata
;
3857 o
->size
-= skip
* PDR_SIZE
;
3863 if (!info
->keep_memory
)
3864 free (cookie
->rels
);
3869 /* Signal that discard_info() has removed the discarded relocations for this section. */
3871 s3_bfd_score_elf_ignore_discarded_relocs (asection
*sec
)
3873 if (strcmp (sec
->name
, ".pdr") == 0)
3878 /* Return the section that should be marked against GC for a given
3881 s3_bfd_score_elf_gc_mark_hook (asection
*sec
,
3882 struct bfd_link_info
*info
,
3883 Elf_Internal_Rela
*rel
,
3884 struct elf_link_hash_entry
*h
,
3885 Elf_Internal_Sym
*sym
)
3888 switch (ELF32_R_TYPE (rel
->r_info
))
3890 case R_SCORE_GNU_VTINHERIT
:
3891 case R_SCORE_GNU_VTENTRY
:
3895 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
3898 /* Support for core dump NOTE sections. */
3901 s3_bfd_score_elf_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
3904 unsigned int raw_size
;
3906 switch (note
->descsz
)
3911 case 148: /* Linux/Score 32-bit. */
3913 elf_tdata (abfd
)->core
->signal
3914 = score_bfd_get_16 (abfd
, note
->descdata
+ 12);
3917 elf_tdata (abfd
)->core
->lwpid
3918 = score_bfd_get_32 (abfd
, note
->descdata
+ 24);
3927 /* Make a ".reg/999" section. */
3928 return _bfd_elfcore_make_pseudosection (abfd
, ".reg", raw_size
,
3929 note
->descpos
+ offset
);
3933 s3_bfd_score_elf_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
3935 switch (note
->descsz
)
3940 case 124: /* Linux/Score elf_prpsinfo. */
3941 elf_tdata (abfd
)->core
->program
3942 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 28, 16);
3943 elf_tdata (abfd
)->core
->command
3944 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 44, 80);
3947 /* Note that for some reason, a spurious space is tacked
3948 onto the end of the args in some (at least one anyway)
3949 implementations, so strip it off if it exists. */
3952 char *command
= elf_tdata (abfd
)->core
->command
;
3953 int n
= strlen (command
);
3955 if (0 < n
&& command
[n
- 1] == ' ')
3956 command
[n
- 1] = '\0';
3963 /* Score BFD functions. */
3964 static reloc_howto_type
*
3965 s3_elf32_score_reloc_type_lookup (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_reloc_code_real_type code
)
3969 for (i
= 0; i
< ARRAY_SIZE (elf32_score_reloc_map
); i
++)
3970 if (elf32_score_reloc_map
[i
].bfd_reloc_val
== code
)
3971 return &elf32_score_howto_table
[elf32_score_reloc_map
[i
].elf_reloc_val
];
3976 static reloc_howto_type
*
3977 elf32_score_reloc_name_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
3983 i
< (sizeof (elf32_score_howto_table
)
3984 / sizeof (elf32_score_howto_table
[0]));
3986 if (elf32_score_howto_table
[i
].name
!= NULL
3987 && strcasecmp (elf32_score_howto_table
[i
].name
, r_name
) == 0)
3988 return &elf32_score_howto_table
[i
];
3994 s3_elf32_score_print_private_bfd_data (bfd
*abfd
, void * ptr
)
3996 FILE *file
= (FILE *) ptr
;
3998 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
4000 /* Print normal ELF private data. */
4001 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
4003 /* xgettext:c-format */
4004 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
4005 if (elf_elfheader (abfd
)->e_flags
& EF_SCORE_PIC
)
4007 fprintf (file
, _(" [pic]"));
4009 if (elf_elfheader (abfd
)->e_flags
& EF_SCORE_FIXDEP
)
4011 fprintf (file
, _(" [fix dep]"));
4019 s3_elf32_score_merge_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
4024 if (!_bfd_generic_verify_endian_match (ibfd
, obfd
))
4027 in_flags
= elf_elfheader (ibfd
)->e_flags
;
4028 out_flags
= elf_elfheader (obfd
)->e_flags
;
4030 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
4031 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
4034 in_flags
= elf_elfheader (ibfd
)->e_flags
;
4035 out_flags
= elf_elfheader (obfd
)->e_flags
;
4037 if (! elf_flags_init (obfd
))
4039 elf_flags_init (obfd
) = TRUE
;
4040 elf_elfheader (obfd
)->e_flags
= in_flags
;
4042 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
4043 && bfd_get_arch_info (obfd
)->the_default
)
4045 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
), bfd_get_mach (ibfd
));
4051 if (((in_flags
& EF_SCORE_PIC
) != 0) != ((out_flags
& EF_SCORE_PIC
) != 0))
4053 (*_bfd_error_handler
) (_("%B: warning: linking PIC files with non-PIC files"), ibfd
);
4056 /* FIXME: Maybe dependency fix compatibility should be checked here. */
4062 s3_elf32_score_new_section_hook (bfd
*abfd
, asection
*sec
)
4064 struct _score_elf_section_data
*sdata
;
4065 bfd_size_type amt
= sizeof (*sdata
);
4067 sdata
= bfd_zalloc (abfd
, amt
);
4070 sec
->used_by_bfd
= sdata
;
4072 return _bfd_elf_new_section_hook (abfd
, sec
);
4075 /*****************************************************************************/
4077 /* s3_s7: backend hooks. */
4079 _bfd_score_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
4081 Elf_Internal_Rela
*elf_reloc
)
4083 if (bfd_get_mach (abfd
) == bfd_mach_score3
)
4084 return s3_bfd_score_info_to_howto (abfd
, bfd_reloc
, elf_reloc
);
4086 return s7_bfd_score_info_to_howto (abfd
, bfd_reloc
, elf_reloc
);
4090 _bfd_score_elf_relocate_section (bfd
*output_bfd
,
4091 struct bfd_link_info
*info
,
4093 asection
*input_section
,
4095 Elf_Internal_Rela
*relocs
,
4096 Elf_Internal_Sym
*local_syms
,
4097 asection
**local_sections
)
4099 if (bfd_get_mach (output_bfd
) == bfd_mach_score3
)
4100 return s3_bfd_score_elf_relocate_section (output_bfd
,
4101 info
, input_bfd
, input_section
, contents
, relocs
,
4102 local_syms
, local_sections
);
4104 return s7_bfd_score_elf_relocate_section (output_bfd
,
4105 info
, input_bfd
, input_section
, contents
, relocs
,
4106 local_syms
, local_sections
);
4110 _bfd_score_elf_check_relocs (bfd
*abfd
,
4111 struct bfd_link_info
*info
,
4113 const Elf_Internal_Rela
*relocs
)
4115 if (bfd_get_mach (abfd
) == bfd_mach_score3
)
4116 return s3_bfd_score_elf_check_relocs (abfd
, info
, sec
, relocs
);
4118 return s7_bfd_score_elf_check_relocs (abfd
, info
, sec
, relocs
);
4122 _bfd_score_elf_add_symbol_hook (bfd
*abfd
,
4123 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
4124 Elf_Internal_Sym
*sym
,
4125 const char **namep ATTRIBUTE_UNUSED
,
4126 flagword
*flagsp ATTRIBUTE_UNUSED
,
4130 if (bfd_get_mach (abfd
) == bfd_mach_score3
)
4131 return s3_bfd_score_elf_add_symbol_hook (abfd
, info
, sym
, namep
, flagsp
,
4134 return s7_bfd_score_elf_add_symbol_hook (abfd
, info
, sym
, namep
, flagsp
,
4139 _bfd_score_elf_symbol_processing (bfd
*abfd
, asymbol
*asym
)
4141 if (bfd_get_mach (abfd
) == bfd_mach_score3
)
4142 return s3_bfd_score_elf_symbol_processing (abfd
, asym
);
4144 return s7_bfd_score_elf_symbol_processing (abfd
, asym
);
4148 _bfd_score_elf_link_output_symbol_hook (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
4149 const char *name ATTRIBUTE_UNUSED
,
4150 Elf_Internal_Sym
*sym
,
4151 asection
*input_sec
,
4152 struct elf_link_hash_entry
*h ATTRIBUTE_UNUSED
)
4154 /* If link a empty .o, then this filed is NULL. */
4155 if (info
->input_bfds
== NULL
)
4157 /* If we see a common symbol, which implies a relocatable link, then
4158 if a symbol was small common in an input file, mark it as small
4159 common in the output file. */
4160 if (sym
->st_shndx
== SHN_COMMON
&& strcmp (input_sec
->name
, ".scommon") == 0)
4161 sym
->st_shndx
= SHN_SCORE_SCOMMON
;
4165 if (bfd_get_mach (info
->input_bfds
) == bfd_mach_score3
)
4166 return s3_bfd_score_elf_link_output_symbol_hook (info
, name
, sym
, input_sec
, h
);
4168 return s7_bfd_score_elf_link_output_symbol_hook (info
, name
, sym
, input_sec
, h
);
4172 _bfd_score_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
4176 if (bfd_get_mach (abfd
) == bfd_mach_score3
)
4177 return s3_bfd_score_elf_section_from_bfd_section (abfd
, sec
, retval
);
4179 return s7_bfd_score_elf_section_from_bfd_section (abfd
, sec
, retval
);
4183 _bfd_score_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
4184 struct elf_link_hash_entry
*h
)
4186 if (bfd_get_mach (info
->input_bfds
) == bfd_mach_score3
)
4187 return s3_bfd_score_elf_adjust_dynamic_symbol (info
, h
);
4189 return s7_bfd_score_elf_adjust_dynamic_symbol (info
, h
);
4193 _bfd_score_elf_always_size_sections (bfd
*output_bfd
,
4194 struct bfd_link_info
*info
)
4196 if (bfd_get_mach (output_bfd
) == bfd_mach_score3
)
4197 return s3_bfd_score_elf_always_size_sections (output_bfd
, info
);
4199 return s7_bfd_score_elf_always_size_sections (output_bfd
, info
);
4203 _bfd_score_elf_size_dynamic_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
4205 if (bfd_get_mach (output_bfd
) == bfd_mach_score3
)
4206 return s3_bfd_score_elf_size_dynamic_sections (output_bfd
, info
);
4208 return s7_bfd_score_elf_size_dynamic_sections (output_bfd
, info
);
4212 _bfd_score_elf_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
4214 if (bfd_get_mach (abfd
) == bfd_mach_score3
)
4215 return s3_bfd_score_elf_create_dynamic_sections (abfd
, info
);
4217 return s7_bfd_score_elf_create_dynamic_sections (abfd
, info
);
4221 _bfd_score_elf_finish_dynamic_symbol (bfd
*output_bfd
,
4222 struct bfd_link_info
*info
,
4223 struct elf_link_hash_entry
*h
,
4224 Elf_Internal_Sym
*sym
)
4226 if (bfd_get_mach (output_bfd
) == bfd_mach_score3
)
4227 return s3_bfd_score_elf_finish_dynamic_symbol (output_bfd
, info
, h
, sym
);
4229 return s7_bfd_score_elf_finish_dynamic_symbol (output_bfd
, info
, h
, sym
);
4233 _bfd_score_elf_finish_dynamic_sections (bfd
*output_bfd
,
4234 struct bfd_link_info
*info
)
4236 if (bfd_get_mach (output_bfd
) == bfd_mach_score3
)
4237 return s3_bfd_score_elf_finish_dynamic_sections (output_bfd
, info
);
4239 return s7_bfd_score_elf_finish_dynamic_sections (output_bfd
, info
);
4243 _bfd_score_elf_fake_sections (bfd
*abfd ATTRIBUTE_UNUSED
,
4244 Elf_Internal_Shdr
*hdr
,
4247 if (bfd_get_mach (abfd
) == bfd_mach_score3
)
4248 return s3_bfd_score_elf_fake_sections (abfd
, hdr
, sec
);
4250 return s7_bfd_score_elf_fake_sections (abfd
, hdr
, sec
);
4254 _bfd_score_elf_section_processing (bfd
*abfd ATTRIBUTE_UNUSED
, Elf_Internal_Shdr
*hdr
)
4256 if (bfd_get_mach (abfd
) == bfd_mach_score3
)
4257 return s3_bfd_score_elf_section_processing (abfd
, hdr
);
4259 return s7_bfd_score_elf_section_processing (abfd
, hdr
);
4263 _bfd_score_elf_write_section (bfd
*output_bfd
,
4264 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
,
4265 asection
*sec
, bfd_byte
*contents
)
4267 if (bfd_get_mach (output_bfd
) == bfd_mach_score3
)
4268 return s3_bfd_score_elf_write_section (output_bfd
, sec
, contents
);
4270 return s7_bfd_score_elf_write_section (output_bfd
, sec
, contents
);
4274 _bfd_score_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
4275 struct elf_link_hash_entry
*dir
,
4276 struct elf_link_hash_entry
*ind
)
4278 if (bfd_get_mach (info
->input_bfds
) == bfd_mach_score3
)
4279 return s3_bfd_score_elf_copy_indirect_symbol (info
, dir
, ind
);
4281 return s7_bfd_score_elf_copy_indirect_symbol (info
, dir
, ind
);
4285 _bfd_score_elf_hide_symbol (struct bfd_link_info
*info
,
4286 struct elf_link_hash_entry
*entry
,
4287 bfd_boolean force_local
)
4289 if (bfd_get_mach (info
->input_bfds
) == bfd_mach_score3
)
4290 return s3_bfd_score_elf_hide_symbol (info
, entry
, force_local
);
4292 return s7_bfd_score_elf_hide_symbol (info
, entry
, force_local
);
4296 _bfd_score_elf_discard_info (bfd
*abfd
, struct elf_reloc_cookie
*cookie
,
4297 struct bfd_link_info
*info
)
4299 if (bfd_get_mach (abfd
) == bfd_mach_score3
)
4300 return s3_bfd_score_elf_discard_info (abfd
, cookie
, info
);
4302 return s7_bfd_score_elf_discard_info (abfd
, cookie
, info
);
4306 _bfd_score_elf_ignore_discarded_relocs (asection
*sec
)
4308 if (bfd_get_mach (sec
->owner
) == bfd_mach_score3
)
4309 return s3_bfd_score_elf_ignore_discarded_relocs (sec
);
4311 return s7_bfd_score_elf_ignore_discarded_relocs (sec
);
4315 _bfd_score_elf_gc_mark_hook (asection
*sec
,
4316 struct bfd_link_info
*info
,
4317 Elf_Internal_Rela
*rel
,
4318 struct elf_link_hash_entry
*h
,
4319 Elf_Internal_Sym
*sym
)
4321 if (bfd_get_mach (info
->input_bfds
) == bfd_mach_score3
)
4322 return s3_bfd_score_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
4324 return s7_bfd_score_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
4328 _bfd_score_elf_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
4330 if (bfd_get_mach (abfd
) == bfd_mach_score3
)
4331 return s3_bfd_score_elf_grok_prstatus (abfd
, note
);
4333 return s7_bfd_score_elf_grok_prstatus (abfd
, note
);
4337 _bfd_score_elf_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
4339 if (bfd_get_mach (abfd
) == bfd_mach_score3
)
4340 return s3_bfd_score_elf_grok_psinfo (abfd
, note
);
4342 return s7_bfd_score_elf_grok_psinfo (abfd
, note
);
4345 static reloc_howto_type
*
4346 elf32_score_reloc_type_lookup (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_reloc_code_real_type code
)
4349 gas will call elf32_score_reloc_type_lookup, and don't write elf file.
4350 So just using score3, but we don't know ld will call this or not.
4351 If so, this way can't work. */
4354 return s3_elf32_score_reloc_type_lookup (abfd
, code
);
4356 return s7_elf32_score_reloc_type_lookup (abfd
, code
);
4359 /* Create a score elf linker hash table.
4360 This is a copy of _bfd_elf_link_hash_table_create() except with a
4361 different hash table entry creation function. */
4363 static struct bfd_link_hash_table
*
4364 elf32_score_link_hash_table_create (bfd
*abfd
)
4366 struct elf_link_hash_table
*ret
;
4367 bfd_size_type amt
= sizeof (struct elf_link_hash_table
);
4369 ret
= (struct elf_link_hash_table
*) bfd_zmalloc (amt
);
4373 if (!_bfd_elf_link_hash_table_init (ret
, abfd
, score_elf_link_hash_newfunc
,
4374 sizeof (struct score_elf_link_hash_entry
),
4385 elf32_score_print_private_bfd_data (bfd
*abfd
, void * ptr
)
4387 if (bfd_get_mach (abfd
) == bfd_mach_score3
)
4388 return s3_elf32_score_print_private_bfd_data (abfd
, ptr
);
4390 return s7_elf32_score_print_private_bfd_data (abfd
, ptr
);
4394 elf32_score_merge_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
4396 if (bfd_get_mach (obfd
) == bfd_mach_score3
)
4397 return s3_elf32_score_merge_private_bfd_data (ibfd
, obfd
);
4399 return s7_elf32_score_merge_private_bfd_data (ibfd
, obfd
);
4403 elf32_score_new_section_hook (bfd
*abfd
, asection
*sec
)
4405 if (bfd_get_mach (abfd
) == bfd_mach_score3
)
4406 return s3_elf32_score_new_section_hook (abfd
, sec
);
4408 return s7_elf32_score_new_section_hook (abfd
, sec
);
4412 /* s3_s7: don't need to split. */
4414 /* Set the right machine number. */
4416 _bfd_score_elf_score_object_p (bfd
* abfd
)
4418 int e_set
= bfd_mach_score7
;
4420 if (elf_elfheader (abfd
)->e_machine
== EM_SCORE
)
4422 int e_mach
= elf_elfheader (abfd
)->e_flags
& EF_SCORE_MACH
& EF_OMIT_PIC_FIXDD
;
4425 /* Set default target is score7. */
4427 case E_SCORE_MACH_SCORE7
:
4428 e_set
= bfd_mach_score7
;
4431 case E_SCORE_MACH_SCORE3
:
4432 e_set
= bfd_mach_score3
;
4437 return bfd_default_set_arch_mach (abfd
, bfd_arch_score
, e_set
);
4441 _bfd_score_elf_common_definition (Elf_Internal_Sym
*sym
)
4443 return (sym
->st_shndx
== SHN_COMMON
|| sym
->st_shndx
== SHN_SCORE_SCOMMON
);
4446 /*****************************************************************************/
4450 #define TARGET_LITTLE_SYM bfd_elf32_littlescore_vec
4451 #define TARGET_LITTLE_NAME "elf32-littlescore"
4452 #define TARGET_BIG_SYM bfd_elf32_bigscore_vec
4453 #define TARGET_BIG_NAME "elf32-bigscore"
4454 #define ELF_ARCH bfd_arch_score
4455 #define ELF_MACHINE_CODE EM_SCORE
4456 #define ELF_MACHINE_ALT1 EM_SCORE_OLD
4457 #define ELF_MAXPAGESIZE 0x8000
4459 #define elf_info_to_howto 0
4460 #define elf_info_to_howto_rel _bfd_score_info_to_howto
4461 #define elf_backend_relocate_section _bfd_score_elf_relocate_section
4462 #define elf_backend_check_relocs _bfd_score_elf_check_relocs
4463 #define elf_backend_add_symbol_hook _bfd_score_elf_add_symbol_hook
4464 #define elf_backend_symbol_processing _bfd_score_elf_symbol_processing
4465 #define elf_backend_link_output_symbol_hook \
4466 _bfd_score_elf_link_output_symbol_hook
4467 #define elf_backend_section_from_bfd_section \
4468 _bfd_score_elf_section_from_bfd_section
4469 #define elf_backend_adjust_dynamic_symbol \
4470 _bfd_score_elf_adjust_dynamic_symbol
4471 #define elf_backend_always_size_sections \
4472 _bfd_score_elf_always_size_sections
4473 #define elf_backend_size_dynamic_sections \
4474 _bfd_score_elf_size_dynamic_sections
4475 #define elf_backend_omit_section_dynsym \
4476 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
4477 #define elf_backend_create_dynamic_sections \
4478 _bfd_score_elf_create_dynamic_sections
4479 #define elf_backend_finish_dynamic_symbol \
4480 _bfd_score_elf_finish_dynamic_symbol
4481 #define elf_backend_finish_dynamic_sections \
4482 _bfd_score_elf_finish_dynamic_sections
4483 #define elf_backend_fake_sections _bfd_score_elf_fake_sections
4484 #define elf_backend_section_processing _bfd_score_elf_section_processing
4485 #define elf_backend_write_section _bfd_score_elf_write_section
4486 #define elf_backend_copy_indirect_symbol _bfd_score_elf_copy_indirect_symbol
4487 #define elf_backend_hide_symbol _bfd_score_elf_hide_symbol
4488 #define elf_backend_discard_info _bfd_score_elf_discard_info
4489 #define elf_backend_ignore_discarded_relocs \
4490 _bfd_score_elf_ignore_discarded_relocs
4491 #define elf_backend_gc_mark_hook _bfd_score_elf_gc_mark_hook
4492 #define elf_backend_grok_prstatus _bfd_score_elf_grok_prstatus
4493 #define elf_backend_grok_psinfo _bfd_score_elf_grok_psinfo
4494 #define elf_backend_can_gc_sections 1
4495 #define elf_backend_want_plt_sym 0
4496 #define elf_backend_got_header_size (4 * SCORE_RESERVED_GOTNO)
4497 #define elf_backend_plt_header_size 0
4498 #define elf_backend_collect TRUE
4499 #define elf_backend_type_change_ok TRUE
4500 #define elf_backend_object_p _bfd_score_elf_score_object_p
4502 #define bfd_elf32_bfd_reloc_type_lookup elf32_score_reloc_type_lookup
4503 #define bfd_elf32_bfd_reloc_name_lookup \
4504 elf32_score_reloc_name_lookup
4505 #define bfd_elf32_bfd_link_hash_table_create elf32_score_link_hash_table_create
4506 #define bfd_elf32_bfd_print_private_bfd_data elf32_score_print_private_bfd_data
4507 #define bfd_elf32_bfd_merge_private_bfd_data elf32_score_merge_private_bfd_data
4508 #define bfd_elf32_new_section_hook elf32_score_new_section_hook
4510 #include "elf32-target.h"