1 /* 32-bit ELF support for S+core.
2 Copyright 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
4 Brain.lin (brain.lin@sunplusct.com)
5 Mei Ligang (ligang@sunnorth.com.cn)
6 Pei-Lin Tsai (pltsai@sunplus.com)
8 This file is part of BFD, the Binary File Descriptor library.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
23 MA 02110-1301, USA. */
28 #include "libiberty.h"
30 #include "elf/score.h"
31 #include "elf/common.h"
32 #include "elf/internal.h"
34 #include "elf32-score.h"
40 /* Score ELF linker hash table. */
41 struct score_elf_link_hash_table
43 /* The main hash table. */
44 struct elf_link_hash_table root
;
47 /* The SCORE ELF linker needs additional information for each symbol in
48 the global hash table. */
49 struct score_elf_link_hash_entry
51 struct elf_link_hash_entry root
;
53 /* Number of R_SCORE_ABS32, R_SCORE_REL32 relocs against this symbol. */
54 unsigned int possibly_dynamic_relocs
;
56 /* If the R_SCORE_ABS32, R_SCORE_REL32 reloc is against a readonly section. */
57 bfd_boolean readonly_reloc
;
59 /* We must not create a stub for a symbol that has relocations related to
60 taking the function's address, i.e. any but R_SCORE_CALL15 ones. */
61 bfd_boolean no_fn_stub
;
63 /* Are we forced local? This will only be set if we have converted
64 the initial global GOT entry to a local GOT entry. */
65 bfd_boolean forced_local
;
68 /* Traverse a score ELF linker hash table. */
69 #define score_elf_link_hash_traverse(table, func, info) \
70 (elf_link_hash_traverse \
72 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
75 /* Get the SCORE elf linker hash table from a link_info structure. */
76 #define score_elf_hash_table(info) \
77 ((struct score_elf_link_hash_table *) ((info)->hash))
79 /* This structure is used to hold .got entries while estimating got sizes. */
80 struct score_got_entry
82 /* The input bfd in which the symbol is defined. */
84 /* The index of the symbol, as stored in the relocation r_info, if
85 we have a local symbol; -1 otherwise. */
89 /* If abfd == NULL, an address that must be stored in the got. */
91 /* If abfd != NULL && symndx != -1, the addend of the relocation
92 that should be added to the symbol value. */
94 /* If abfd != NULL && symndx == -1, the hash table entry
95 corresponding to a global symbol in the got (or, local, if
97 struct score_elf_link_hash_entry
*h
;
100 /* The offset from the beginning of the .got section to the entry
101 corresponding to this symbol+addend. If it's a global symbol
102 whose offset is yet to be decided, it's going to be -1. */
106 /* This structure is passed to score_elf_sort_hash_table_f when sorting
107 the dynamic symbols. */
109 struct score_elf_hash_sort_data
111 /* The symbol in the global GOT with the lowest dynamic symbol table index. */
112 struct elf_link_hash_entry
*low
;
113 /* The least dynamic symbol table index corresponding to a symbol with a GOT entry. */
114 long min_got_dynindx
;
115 /* The greatest dynamic symbol table index corresponding to a symbol
116 with a GOT entry that is not referenced (e.g., a dynamic symbol
117 with dynamic relocations pointing to it from non-primary GOTs). */
118 long max_unref_got_dynindx
;
119 /* The greatest dynamic symbol table index not corresponding to a
120 symbol without a GOT entry. */
121 long max_non_got_dynindx
;
124 struct score_got_info
126 /* The global symbol in the GOT with the lowest index in the dynamic
128 struct elf_link_hash_entry
*global_gotsym
;
129 /* The number of global .got entries. */
130 unsigned int global_gotno
;
131 /* The number of local .got entries. */
132 unsigned int local_gotno
;
133 /* The number of local .got entries we have used. */
134 unsigned int assigned_gotno
;
135 /* A hash table holding members of the got. */
136 struct htab
*got_entries
;
137 /* In multi-got links, a pointer to the next got (err, rather, most
138 of the time, it points to the previous got). */
139 struct score_got_info
*next
;
142 /* A structure used to count GOT entries, for GOT entry or ELF symbol table traversal. */
143 struct _score_elf_section_data
145 struct bfd_elf_section_data elf
;
148 struct score_got_info
*got_info
;
154 #define score_elf_section_data(sec) \
155 ((struct _score_elf_section_data *) elf_section_data (sec))
157 /* The size of a symbol-table entry. */
158 #define SCORE_ELF_SYM_SIZE(abfd) \
159 (get_elf_backend_data (abfd)->s->sizeof_sym)
161 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
162 from smaller values. Start with zero, widen, *then* decrement. */
163 #define MINUS_ONE (((bfd_vma)0) - 1)
164 #define MINUS_TWO (((bfd_vma)0) - 2)
169 /* The number of local .got entries we reserve. */
170 #define SCORE_RESERVED_GOTNO (2)
171 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
173 /* The offset of $gp from the beginning of the .got section. */
174 #define ELF_SCORE_GP_OFFSET(abfd) (0x3ff0)
175 /* The maximum size of the GOT for it to be addressable using 15-bit offsets from $gp. */
176 #define SCORE_ELF_GOT_MAX_SIZE(abfd) (ELF_SCORE_GP_OFFSET(abfd) + 0x3fff)
178 #define SCORE_ELF_STUB_SECTION_NAME (".SCORE.stub")
179 #define SCORE_FUNCTION_STUB_SIZE (16)
181 #define STUB_LW 0xc3bcc010 /* lw r29, [r28, -0x3ff0] */
182 #define STUB_MOVE 0x8363bc56 /* mv r27, r3 */
183 #define STUB_LI16 0x87548000 /* ori r26, .dynsym_index */
184 #define STUB_BRL 0x801dbc09 /* brl r29 */
186 #define SCORE_ELF_GOT_SIZE(abfd) \
187 (get_elf_backend_data (abfd)->s->arch_size / 8)
189 #define SCORE_ELF_ADD_DYNAMIC_ENTRY(info, tag, val) \
190 (_bfd_elf_add_dynamic_entry (info, (bfd_vma) tag, (bfd_vma) val))
192 /* The size of an external dynamic table entry. */
193 #define SCORE_ELF_DYN_SIZE(abfd) \
194 (get_elf_backend_data (abfd)->s->sizeof_dyn)
196 /* The size of an external REL relocation. */
197 #define SCORE_ELF_REL_SIZE(abfd) \
198 (get_elf_backend_data (abfd)->s->sizeof_rel)
200 /* The default alignment for sections, as a power of two. */
201 #define SCORE_ELF_LOG_FILE_ALIGN(abfd)\
202 (get_elf_backend_data (abfd)->s->log_file_align)
204 static bfd_byte
*hi16_rel_addr
;
206 /* This will be used when we sort the dynamic relocation records. */
207 static bfd
*reldyn_sorting_bfd
;
209 /* SCORE ELF uses two common sections. One is the usual one, and the
210 other is for small objects. All the small objects are kept
211 together, and then referenced via the gp pointer, which yields
212 faster assembler code. This is what we use for the small common
213 section. This approach is copied from ecoff.c. */
214 static asection score_elf_scom_section
;
215 static asymbol score_elf_scom_symbol
;
216 static asymbol
*score_elf_scom_symbol_ptr
;
219 score_bfd_get_16 (bfd
*abfd
, const void *data
)
221 return bfd_get_16 (abfd
, data
);
225 score3_bfd_getl32 (const void *p
)
227 const bfd_byte
*addr
= p
;
230 v
= (unsigned long) addr
[2];
231 v
|= (unsigned long) addr
[3] << 8;
232 v
|= (unsigned long) addr
[0] << 16;
233 v
|= (unsigned long) addr
[1] << 24;
238 score3_bfd_getl48 (const void *p
)
240 const bfd_byte
*addr
= p
;
241 unsigned long long v
;
243 v
= (unsigned long long) addr
[4];
244 v
|= (unsigned long long) addr
[5] << 8;
245 v
|= (unsigned long long) addr
[2] << 16;
246 v
|= (unsigned long long) addr
[3] << 24;
247 v
|= (unsigned long long) addr
[0] << 32;
248 v
|= (unsigned long long) addr
[1] << 40;
253 score_bfd_get_32 (bfd
*abfd
, const void *data
)
255 if (/* score3 && */ abfd
->xvec
->byteorder
== BFD_ENDIAN_LITTLE
)
256 return score3_bfd_getl32 (data
);
258 return bfd_get_32 (abfd
, data
);
262 score_bfd_get_48 (bfd
*abfd
, const void *p
)
264 if (/* score3 && */ abfd
->xvec
->byteorder
== BFD_ENDIAN_LITTLE
)
265 return score3_bfd_getl48 (p
);
267 return bfd_get_bits (p
, 48, 1);
271 score_bfd_put_16 (bfd
*abfd
, bfd_vma addr
, void *data
)
273 return bfd_put_16 (abfd
, addr
, data
);
277 score3_bfd_putl32 (bfd_vma data
, void *p
)
280 addr
[0] = (data
>> 16) & 0xff;
281 addr
[1] = (data
>> 24) & 0xff;
282 addr
[2] = data
& 0xff;
283 addr
[3] = (data
>> 8) & 0xff;
287 score3_bfd_putl48 (bfd_vma data
, void *p
)
290 addr
[0] = (data
>> 32) & 0xff;
291 addr
[1] = (data
>> 40) & 0xff;
292 addr
[2] = (data
>> 16) & 0xff;
293 addr
[3] = (data
>> 24) & 0xff;
294 addr
[4] = data
& 0xff;
295 addr
[5] = (data
>> 8) & 0xff;
299 score_bfd_put_32 (bfd
*abfd
, bfd_vma addr
, void *data
)
301 if (/* score3 && */ abfd
->xvec
->byteorder
== BFD_ENDIAN_LITTLE
)
302 return score3_bfd_putl32 (addr
, data
);
304 return bfd_put_32 (abfd
, addr
, data
);
308 score_bfd_put_48 (bfd
*abfd
, bfd_vma val
, void *p
)
310 if (/* score3 && */ abfd
->xvec
->byteorder
== BFD_ENDIAN_LITTLE
)
311 return score3_bfd_putl48 (val
, p
);
313 return bfd_put_bits (val
, p
, 48, 1);
316 static bfd_reloc_status_type
317 score_elf_hi16_reloc (bfd
*abfd ATTRIBUTE_UNUSED
,
318 arelent
*reloc_entry
,
319 asymbol
*symbol ATTRIBUTE_UNUSED
,
321 asection
*input_section ATTRIBUTE_UNUSED
,
322 bfd
*output_bfd ATTRIBUTE_UNUSED
,
323 char **error_message ATTRIBUTE_UNUSED
)
325 hi16_rel_addr
= (bfd_byte
*) data
+ reloc_entry
->address
;
329 static bfd_reloc_status_type
330 score_elf_lo16_reloc (bfd
*abfd
,
331 arelent
*reloc_entry
,
332 asymbol
*symbol ATTRIBUTE_UNUSED
,
334 asection
*input_section
,
335 bfd
*output_bfd ATTRIBUTE_UNUSED
,
336 char **error_message ATTRIBUTE_UNUSED
)
338 bfd_vma addend
= 0, offset
= 0;
340 unsigned long hi16_offset
, hi16_value
, uvalue
;
342 hi16_value
= score_bfd_get_32 (abfd
, hi16_rel_addr
);
343 hi16_offset
= ((((hi16_value
>> 16) & 0x3) << 15) | (hi16_value
& 0x7fff)) >> 1;
344 addend
= score_bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
345 offset
= ((((addend
>> 16) & 0x3) << 15) | (addend
& 0x7fff)) >> 1;
346 val
= reloc_entry
->addend
;
347 if (reloc_entry
->address
> input_section
->size
)
348 return bfd_reloc_outofrange
;
349 uvalue
= ((hi16_offset
<< 16) | (offset
& 0xffff)) + val
;
350 hi16_offset
= (uvalue
>> 16) << 1;
351 hi16_value
= (hi16_value
& ~0x37fff) | (hi16_offset
& 0x7fff) | ((hi16_offset
<< 1) & 0x30000);
352 score_bfd_put_32 (abfd
, hi16_value
, hi16_rel_addr
);
353 offset
= (uvalue
& 0xffff) << 1;
354 addend
= (addend
& ~0x37fff) | (offset
& 0x7fff) | ((offset
<< 1) & 0x30000);
355 score_bfd_put_32 (abfd
, addend
, (bfd_byte
*) data
+ reloc_entry
->address
);
359 /* Set the GP value for OUTPUT_BFD. Returns FALSE if this is a
360 dangerous relocation. */
363 score_elf_assign_gp (bfd
*output_bfd
, bfd_vma
*pgp
)
369 /* If we've already figured out what GP will be, just return it. */
370 *pgp
= _bfd_get_gp_value (output_bfd
);
374 count
= bfd_get_symcount (output_bfd
);
375 sym
= bfd_get_outsymbols (output_bfd
);
377 /* The linker script will have created a symbol named `_gp' with the
378 appropriate value. */
383 for (i
= 0; i
< count
; i
++, sym
++)
387 name
= bfd_asymbol_name (*sym
);
388 if (*name
== '_' && strcmp (name
, "_gp") == 0)
390 *pgp
= bfd_asymbol_value (*sym
);
391 _bfd_set_gp_value (output_bfd
, *pgp
);
399 /* Only get the error once. */
401 _bfd_set_gp_value (output_bfd
, *pgp
);
408 /* We have to figure out the gp value, so that we can adjust the
409 symbol value correctly. We look up the symbol _gp in the output
410 BFD. If we can't find it, we're stuck. We cache it in the ELF
411 target data. We don't need to adjust the symbol value for an
412 external symbol if we are producing relocatable output. */
413 static bfd_reloc_status_type
414 score_elf_final_gp (bfd
*output_bfd
,
416 bfd_boolean relocatable
,
417 char **error_message
,
420 if (bfd_is_und_section (symbol
->section
)
424 return bfd_reloc_undefined
;
427 *pgp
= _bfd_get_gp_value (output_bfd
);
430 || (symbol
->flags
& BSF_SECTION_SYM
) != 0))
434 /* Make up a value. */
435 *pgp
= symbol
->section
->output_section
->vma
+ 0x4000;
436 _bfd_set_gp_value (output_bfd
, *pgp
);
438 else if (!score_elf_assign_gp (output_bfd
, pgp
))
441 (char *) _("GP relative relocation when _gp not defined");
442 return bfd_reloc_dangerous
;
449 static bfd_reloc_status_type
450 score_elf_gprel15_with_gp (bfd
*abfd
,
452 arelent
*reloc_entry
,
453 asection
*input_section
,
454 bfd_boolean relocateable
,
456 bfd_vma gp ATTRIBUTE_UNUSED
)
461 if (bfd_is_com_section (symbol
->section
))
464 relocation
= symbol
->value
;
466 relocation
+= symbol
->section
->output_section
->vma
;
467 relocation
+= symbol
->section
->output_offset
;
468 if (reloc_entry
->address
> input_section
->size
)
469 return bfd_reloc_outofrange
;
471 insn
= score_bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
472 if (((reloc_entry
->addend
& 0xffffc000) != 0)
473 && ((reloc_entry
->addend
& 0xffffc000) != 0xffffc000))
474 return bfd_reloc_overflow
;
476 insn
= (insn
& ~0x7fff) | (reloc_entry
->addend
& 0x7fff);
477 score_bfd_put_32 (abfd
, insn
, (bfd_byte
*) data
+ reloc_entry
->address
);
479 reloc_entry
->address
+= input_section
->output_offset
;
484 static bfd_reloc_status_type
485 gprel32_with_gp (bfd
*abfd
, asymbol
*symbol
, arelent
*reloc_entry
,
486 asection
*input_section
, bfd_boolean relocatable
,
487 void *data
, bfd_vma gp
)
492 if (bfd_is_com_section (symbol
->section
))
495 relocation
= symbol
->value
;
497 relocation
+= symbol
->section
->output_section
->vma
;
498 relocation
+= symbol
->section
->output_offset
;
500 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
501 return bfd_reloc_outofrange
;
503 /* Set val to the offset into the section or symbol. */
504 val
= reloc_entry
->addend
;
506 if (reloc_entry
->howto
->partial_inplace
)
507 val
+= score_bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
509 /* Adjust val for the final section location and GP value. If we
510 are producing relocatable output, we don't want to do this for
511 an external symbol. */
513 || (symbol
->flags
& BSF_SECTION_SYM
) != 0)
514 val
+= relocation
- gp
;
516 if (reloc_entry
->howto
->partial_inplace
)
517 score_bfd_put_32 (abfd
, val
, (bfd_byte
*) data
+ reloc_entry
->address
);
519 reloc_entry
->addend
= val
;
522 reloc_entry
->address
+= input_section
->output_offset
;
527 static bfd_reloc_status_type
528 score_elf_gprel15_reloc (bfd
*abfd
,
529 arelent
*reloc_entry
,
532 asection
*input_section
,
534 char **error_message
)
536 bfd_boolean relocateable
;
537 bfd_reloc_status_type ret
;
540 if (output_bfd
!= NULL
541 && (symbol
->flags
& BSF_SECTION_SYM
) == 0 && reloc_entry
->addend
== 0)
543 reloc_entry
->address
+= input_section
->output_offset
;
546 if (output_bfd
!= NULL
)
550 relocateable
= FALSE
;
551 output_bfd
= symbol
->section
->output_section
->owner
;
554 ret
= score_elf_final_gp (output_bfd
, symbol
, relocateable
, error_message
, &gp
);
555 if (ret
!= bfd_reloc_ok
)
558 return score_elf_gprel15_with_gp (abfd
, symbol
, reloc_entry
,
559 input_section
, relocateable
, data
, gp
);
562 /* Do a R_SCORE_GPREL32 relocation. This is a 32 bit value which must
563 become the offset from the gp register. */
565 static bfd_reloc_status_type
566 score_elf_gprel32_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
567 void *data
, asection
*input_section
, bfd
*output_bfd
,
568 char **error_message
)
570 bfd_boolean relocatable
;
571 bfd_reloc_status_type ret
;
574 /* R_SCORE_GPREL32 relocations are defined for local symbols only. */
575 if (output_bfd
!= NULL
576 && (symbol
->flags
& BSF_SECTION_SYM
) == 0
577 && (symbol
->flags
& BSF_LOCAL
) != 0)
579 *error_message
= (char *)
580 _("32bits gp relative relocation occurs for an external symbol");
581 return bfd_reloc_outofrange
;
584 if (output_bfd
!= NULL
)
589 output_bfd
= symbol
->section
->output_section
->owner
;
592 ret
= score_elf_final_gp (output_bfd
, symbol
, relocatable
, error_message
, &gp
);
593 if (ret
!= bfd_reloc_ok
)
597 return gprel32_with_gp (abfd
, symbol
, reloc_entry
, input_section
,
598 relocatable
, data
, gp
);
601 /* A howto special_function for R_SCORE_GOT15 relocations. This is just
602 like any other 16-bit relocation when applied to global symbols, but is
603 treated in the same as R_SCORE_HI16 when applied to local symbols. */
604 static bfd_reloc_status_type
605 score_elf_got15_reloc (bfd
*abfd
, arelent
*reloc_entry
, asymbol
*symbol
,
606 void *data
, asection
*input_section
,
607 bfd
*output_bfd
, char **error_message
)
609 if ((symbol
->flags
& (BSF_GLOBAL
| BSF_WEAK
)) != 0
610 || bfd_is_und_section (bfd_get_section (symbol
))
611 || bfd_is_com_section (bfd_get_section (symbol
)))
612 /* The relocation is against a global symbol. */
613 return bfd_elf_generic_reloc (abfd
, reloc_entry
, symbol
, data
,
614 input_section
, output_bfd
,
617 return score_elf_hi16_reloc (abfd
, reloc_entry
, symbol
, data
,
618 input_section
, output_bfd
, error_message
);
621 static bfd_reloc_status_type
622 score_elf_got_lo16_reloc (bfd
*abfd
,
623 arelent
*reloc_entry
,
624 asymbol
*symbol ATTRIBUTE_UNUSED
,
626 asection
*input_section
,
627 bfd
*output_bfd ATTRIBUTE_UNUSED
,
628 char **error_message ATTRIBUTE_UNUSED
)
630 bfd_vma addend
= 0, offset
= 0;
632 signed long hi16_offset
, hi16_value
, uvalue
;
634 hi16_value
= score_bfd_get_32 (abfd
, hi16_rel_addr
);
635 hi16_offset
= ((((hi16_value
>> 16) & 0x3) << 15) | (hi16_value
& 0x7fff)) >> 1;
636 addend
= score_bfd_get_32 (abfd
, (bfd_byte
*) data
+ reloc_entry
->address
);
637 offset
= ((((addend
>> 16) & 0x3) << 15) | (addend
& 0x7fff)) >> 1;
638 val
= reloc_entry
->addend
;
639 if (reloc_entry
->address
> input_section
->size
)
640 return bfd_reloc_outofrange
;
641 uvalue
= ((hi16_offset
<< 16) | (offset
& 0xffff)) + val
;
642 if ((uvalue
> -0x8000) && (uvalue
< 0x7fff))
645 hi16_offset
= (uvalue
>> 16) & 0x7fff;
646 hi16_value
= (hi16_value
& ~0x37fff) | (hi16_offset
& 0x7fff) | ((hi16_offset
<< 1) & 0x30000);
647 score_bfd_put_32 (abfd
, hi16_value
, hi16_rel_addr
);
648 offset
= (uvalue
& 0xffff) << 1;
649 addend
= (addend
& ~0x37fff) | (offset
& 0x7fff) | ((offset
<< 1) & 0x30000);
650 score_bfd_put_32 (abfd
, addend
, (bfd_byte
*) data
+ reloc_entry
->address
);
654 static reloc_howto_type elf32_score_howto_table
[] =
657 HOWTO (R_SCORE_NONE
, /* type */
659 0, /* size (0 = byte, 1 = short, 2 = long) */
661 FALSE
, /* pc_relative */
663 complain_overflow_dont
,/* complain_on_overflow */
664 bfd_elf_generic_reloc
, /* special_function */
665 "R_SCORE_NONE", /* name */
666 FALSE
, /* partial_inplace */
669 FALSE
), /* pcrel_offset */
672 HOWTO (R_SCORE_HI16
, /* type */
674 2, /* size (0 = byte, 1 = short, 2 = long) */
676 FALSE
, /* pc_relative */
678 complain_overflow_dont
,/* complain_on_overflow */
679 score_elf_hi16_reloc
, /* special_function */
680 "R_SCORE_HI16", /* name */
681 TRUE
, /* partial_inplace */
682 0x37fff, /* src_mask */
683 0x37fff, /* dst_mask */
684 FALSE
), /* pcrel_offset */
687 HOWTO (R_SCORE_LO16
, /* type */
689 2, /* size (0 = byte, 1 = short, 2 = long) */
691 FALSE
, /* pc_relative */
693 complain_overflow_dont
,/* complain_on_overflow */
694 score_elf_lo16_reloc
, /* special_function */
695 "R_SCORE_LO16", /* name */
696 TRUE
, /* partial_inplace */
697 0x37fff, /* src_mask */
698 0x37fff, /* dst_mask */
699 FALSE
), /* pcrel_offset */
702 HOWTO (R_SCORE_BCMP
, /* type */
704 2, /* size (0 = byte, 1 = short, 2 = long) */
706 TRUE
, /* pc_relative */
708 complain_overflow_dont
,/* complain_on_overflow */
709 bfd_elf_generic_reloc
, /* special_function */
710 "R_SCORE_BCMP", /* name */
711 FALSE
, /* partial_inplace */
712 0x03e00381, /* src_mask */
713 0x03e00381, /* dst_mask */
714 FALSE
), /* pcrel_offset */
717 HOWTO (R_SCORE_24
, /* type */
719 2, /* size (0 = byte, 1 = short, 2 = long) */
721 FALSE
, /* pc_relative */
723 complain_overflow_dont
,/* complain_on_overflow */
724 bfd_elf_generic_reloc
, /* special_function */
725 "R_SCORE_24", /* name */
726 FALSE
, /* partial_inplace */
727 0x3ff7fff, /* src_mask */
728 0x3ff7fff, /* dst_mask */
729 FALSE
), /* pcrel_offset */
732 HOWTO (R_SCORE_PC19
, /* type */
734 2, /* size (0 = byte, 1 = short, 2 = long) */
736 TRUE
, /* pc_relative */
738 complain_overflow_dont
,/* complain_on_overflow */
739 bfd_elf_generic_reloc
, /* special_function */
740 "R_SCORE_PC19", /* name */
741 FALSE
, /* partial_inplace */
742 0x3ff03fe, /* src_mask */
743 0x3ff03fe, /* dst_mask */
744 FALSE
), /* pcrel_offset */
747 HOWTO (R_SCORE16_11
, /* type */
749 1, /* size (0 = byte, 1 = short, 2 = long) */
751 FALSE
, /* pc_relative */
753 complain_overflow_dont
,/* complain_on_overflow */
754 bfd_elf_generic_reloc
, /* special_function */
755 "R_SCORE16_11", /* name */
756 FALSE
, /* partial_inplace */
757 0x000000ffe, /* src_mask */
758 0x000000ffe, /* dst_mask */
759 FALSE
), /* pcrel_offset */
762 HOWTO (R_SCORE16_PC8
, /* type */
764 1, /* size (0 = byte, 1 = short, 2 = long) */
766 TRUE
, /* pc_relative */
768 complain_overflow_dont
,/* complain_on_overflow */
769 bfd_elf_generic_reloc
, /* special_function */
770 "R_SCORE16_PC8", /* name */
771 FALSE
, /* partial_inplace */
772 0x000001ff, /* src_mask */
773 0x000001ff, /* dst_mask */
774 FALSE
), /* pcrel_offset */
776 /* 32 bit absolute */
777 HOWTO (R_SCORE_ABS32
, /* type 8 */
779 2, /* size (0 = byte, 1 = short, 2 = long) */
781 FALSE
, /* pc_relative */
783 complain_overflow_bitfield
, /* complain_on_overflow */
784 bfd_elf_generic_reloc
, /* special_function */
785 "R_SCORE_ABS32", /* name */
786 FALSE
, /* partial_inplace */
787 0xffffffff, /* src_mask */
788 0xffffffff, /* dst_mask */
789 FALSE
), /* pcrel_offset */
791 /* 16 bit absolute */
792 HOWTO (R_SCORE_ABS16
, /* type 11 */
794 1, /* size (0 = byte, 1 = short, 2 = long) */
796 FALSE
, /* pc_relative */
798 complain_overflow_bitfield
, /* complain_on_overflow */
799 bfd_elf_generic_reloc
, /* special_function */
800 "R_SCORE_ABS16", /* name */
801 FALSE
, /* partial_inplace */
802 0x0000ffff, /* src_mask */
803 0x0000ffff, /* dst_mask */
804 FALSE
), /* pcrel_offset */
807 HOWTO (R_SCORE_DUMMY2
, /* type */
809 2, /* size (0 = byte, 1 = short, 2 = long) */
811 FALSE
, /* pc_relative */
813 complain_overflow_dont
,/* complain_on_overflow */
814 bfd_elf_generic_reloc
, /* special_function */
815 "R_SCORE_DUMMY2", /* name */
816 TRUE
, /* partial_inplace */
817 0x00007fff, /* src_mask */
818 0x00007fff, /* dst_mask */
819 FALSE
), /* pcrel_offset */
822 HOWTO (R_SCORE_GP15
, /* type */
824 2, /* size (0 = byte, 1 = short, 2 = long) */
826 FALSE
, /* pc_relative */
828 complain_overflow_dont
,/* complain_on_overflow */
829 score_elf_gprel15_reloc
,/* special_function */
830 "R_SCORE_GP15", /* name */
831 TRUE
, /* partial_inplace */
832 0x00007fff, /* src_mask */
833 0x00007fff, /* dst_mask */
834 FALSE
), /* pcrel_offset */
836 /* GNU extension to record C++ vtable hierarchy. */
837 HOWTO (R_SCORE_GNU_VTINHERIT
, /* type */
839 2, /* size (0 = byte, 1 = short, 2 = long) */
841 FALSE
, /* pc_relative */
843 complain_overflow_dont
,/* complain_on_overflow */
844 NULL
, /* special_function */
845 "R_SCORE_GNU_VTINHERIT", /* name */
846 FALSE
, /* partial_inplace */
849 FALSE
), /* pcrel_offset */
851 /* GNU extension to record C++ vtable member usage */
852 HOWTO (R_SCORE_GNU_VTENTRY
, /* type */
854 2, /* size (0 = byte, 1 = short, 2 = long) */
856 FALSE
, /* pc_relative */
858 complain_overflow_dont
,/* complain_on_overflow */
859 _bfd_elf_rel_vtable_reloc_fn
, /* special_function */
860 "R_SCORE_GNU_VTENTRY", /* name */
861 FALSE
, /* partial_inplace */
864 FALSE
), /* pcrel_offset */
866 /* Reference to global offset table. */
867 HOWTO (R_SCORE_GOT15
, /* type */
869 2, /* size (0 = byte, 1 = short, 2 = long) */
871 FALSE
, /* pc_relative */
873 complain_overflow_signed
, /* complain_on_overflow */
874 score_elf_got15_reloc
, /* special_function */
875 "R_SCORE_GOT15", /* name */
876 TRUE
, /* partial_inplace */
877 0x00007fff, /* src_mask */
878 0x00007fff, /* dst_mask */
879 FALSE
), /* pcrel_offset */
881 /* Low 16 bits of displacement in global offset table. */
882 HOWTO (R_SCORE_GOT_LO16
, /* type */
884 2, /* size (0 = byte, 1 = short, 2 = long) */
886 FALSE
, /* pc_relative */
888 complain_overflow_dont
,/* complain_on_overflow */
889 score_elf_got_lo16_reloc
, /* special_function */
890 "R_SCORE_GOT_LO16", /* name */
891 TRUE
, /* partial_inplace */
892 0x37ffe, /* src_mask */
893 0x37ffe, /* dst_mask */
894 FALSE
), /* pcrel_offset */
896 /* 15 bit call through global offset table. */
897 HOWTO (R_SCORE_CALL15
, /* type */
899 2, /* size (0 = byte, 1 = short, 2 = long) */
901 FALSE
, /* pc_relative */
903 complain_overflow_signed
, /* complain_on_overflow */
904 bfd_elf_generic_reloc
, /* special_function */
905 "R_SCORE_CALL15", /* name */
906 TRUE
, /* partial_inplace */
907 0x0000ffff, /* src_mask */
908 0x0000ffff, /* dst_mask */
909 FALSE
), /* pcrel_offset */
911 /* 32 bit GP relative reference. */
912 HOWTO (R_SCORE_GPREL32
, /* type */
914 2, /* size (0 = byte, 1 = short, 2 = long) */
916 FALSE
, /* pc_relative */
918 complain_overflow_dont
,/* complain_on_overflow */
919 score_elf_gprel32_reloc
, /* special_function */
920 "R_SCORE_GPREL32", /* name */
921 TRUE
, /* partial_inplace */
922 0xffffffff, /* src_mask */
923 0xffffffff, /* dst_mask */
924 FALSE
), /* pcrel_offset */
926 /* 32 bit symbol relative relocation. */
927 HOWTO (R_SCORE_REL32
, /* type */
929 2, /* size (0 = byte, 1 = short, 2 = long) */
931 FALSE
, /* pc_relative */
933 complain_overflow_dont
,/* complain_on_overflow */
934 bfd_elf_generic_reloc
, /* special_function */
935 "R_SCORE_REL32", /* name */
936 TRUE
, /* partial_inplace */
937 0xffffffff, /* src_mask */
938 0xffffffff, /* dst_mask */
939 FALSE
), /* pcrel_offset */
941 /* R_SCORE_DUMMY_HI16 */
942 HOWTO (R_SCORE_DUMMY_HI16
, /* type */
944 2, /* size (0 = byte, 1 = short, 2 = long) */
946 FALSE
, /* pc_relative */
948 complain_overflow_dont
,/* complain_on_overflow */
949 score_elf_hi16_reloc
, /* special_function */
950 "R_SCORE_DUMMY_HI16", /* name */
951 TRUE
, /* partial_inplace */
952 0x37fff, /* src_mask */
953 0x37fff, /* dst_mask */
954 FALSE
), /* pcrel_offset */
957 HOWTO (R_SCORE_IMM30
, /* type */
959 2, /* size (0 = byte, 1 = short, 2 = long) */
961 FALSE
, /* pc_relative */
963 complain_overflow_dont
,/* complain_on_overflow */
964 bfd_elf_generic_reloc
, /* special_function */
965 "R_SCORE_IMM30", /* name */
966 FALSE
, /* partial_inplace */
967 0x7f7fff7f80LL
, /* src_mask */
968 0x7f7fff7f80LL
, /* dst_mask */
969 FALSE
), /* pcrel_offset */
972 HOWTO (R_SCORE_IMM32
, /* type */
974 2, /* size (0 = byte, 1 = short, 2 = long) */
976 FALSE
, /* pc_relative */
978 complain_overflow_dont
,/* complain_on_overflow */
979 bfd_elf_generic_reloc
, /* special_function */
980 "R_SCORE_IMM32", /* name */
981 FALSE
, /* partial_inplace */
982 0x7f7fff7fe0LL
, /* src_mask */
983 0x7f7fff7fe0LL
, /* dst_mask */
984 FALSE
), /* pcrel_offset */
987 struct score_reloc_map
989 bfd_reloc_code_real_type bfd_reloc_val
;
990 unsigned char elf_reloc_val
;
993 static const struct score_reloc_map elf32_score_reloc_map
[] =
995 {BFD_RELOC_NONE
, R_SCORE_NONE
},
996 {BFD_RELOC_HI16_S
, R_SCORE_HI16
},
997 {BFD_RELOC_LO16
, R_SCORE_LO16
},
998 {BFD_RELOC_SCORE_BCMP
, R_SCORE_BCMP
},
999 {BFD_RELOC_SCORE_JMP
, R_SCORE_24
},
1000 {BFD_RELOC_SCORE_BRANCH
, R_SCORE_PC19
},
1001 {BFD_RELOC_SCORE16_JMP
, R_SCORE16_11
},
1002 {BFD_RELOC_SCORE16_BRANCH
, R_SCORE16_PC8
},
1003 {BFD_RELOC_32
, R_SCORE_ABS32
},
1004 {BFD_RELOC_16
, R_SCORE_ABS16
},
1005 {BFD_RELOC_SCORE_DUMMY2
, R_SCORE_DUMMY2
},
1006 {BFD_RELOC_SCORE_GPREL15
, R_SCORE_GP15
},
1007 {BFD_RELOC_VTABLE_INHERIT
, R_SCORE_GNU_VTINHERIT
},
1008 {BFD_RELOC_VTABLE_ENTRY
, R_SCORE_GNU_VTENTRY
},
1009 {BFD_RELOC_SCORE_GOT15
, R_SCORE_GOT15
},
1010 {BFD_RELOC_SCORE_GOT_LO16
, R_SCORE_GOT_LO16
},
1011 {BFD_RELOC_SCORE_CALL15
, R_SCORE_CALL15
},
1012 {BFD_RELOC_GPREL32
, R_SCORE_GPREL32
},
1013 {BFD_RELOC_32_PCREL
, R_SCORE_REL32
},
1014 {BFD_RELOC_SCORE_DUMMY_HI16
, R_SCORE_DUMMY_HI16
},
1015 {BFD_RELOC_SCORE_IMM30
, R_SCORE_IMM30
},
1016 {BFD_RELOC_SCORE_IMM32
, R_SCORE_IMM32
},
1019 /* got_entries only match if they're identical, except for gotidx, so
1020 use all fields to compute the hash, and compare the appropriate
1023 score_elf_got_entry_hash (const void *entry_
)
1025 const struct score_got_entry
*entry
= (struct score_got_entry
*)entry_
;
1027 return entry
->symndx
1028 + (!entry
->abfd
? entry
->d
.address
: entry
->abfd
->id
);
1032 score_elf_got_entry_eq (const void *entry1
, const void *entry2
)
1034 const struct score_got_entry
*e1
= (struct score_got_entry
*)entry1
;
1035 const struct score_got_entry
*e2
= (struct score_got_entry
*)entry2
;
1037 return e1
->abfd
== e2
->abfd
&& e1
->symndx
== e2
->symndx
1038 && (! e1
->abfd
? e1
->d
.address
== e2
->d
.address
1039 : e1
->symndx
>= 0 ? e1
->d
.addend
== e2
->d
.addend
1040 : e1
->d
.h
== e2
->d
.h
);
1043 /* If H needs a GOT entry, assign it the highest available dynamic
1044 index. Otherwise, assign it the lowest available dynamic
1047 score_elf_sort_hash_table_f (struct score_elf_link_hash_entry
*h
, void *data
)
1049 struct score_elf_hash_sort_data
*hsd
= data
;
1051 if (h
->root
.root
.type
== bfd_link_hash_warning
)
1052 h
= (struct score_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
1054 /* Symbols without dynamic symbol table entries aren't interesting at all. */
1055 if (h
->root
.dynindx
== -1)
1058 /* Global symbols that need GOT entries that are not explicitly
1059 referenced are marked with got offset 2. Those that are
1060 referenced get a 1, and those that don't need GOT entries get
1062 if (h
->root
.got
.offset
== 2)
1064 if (hsd
->max_unref_got_dynindx
== hsd
->min_got_dynindx
)
1065 hsd
->low
= (struct elf_link_hash_entry
*) h
;
1066 h
->root
.dynindx
= hsd
->max_unref_got_dynindx
++;
1068 else if (h
->root
.got
.offset
!= 1)
1069 h
->root
.dynindx
= hsd
->max_non_got_dynindx
++;
1072 h
->root
.dynindx
= --hsd
->min_got_dynindx
;
1073 hsd
->low
= (struct elf_link_hash_entry
*) h
;
1080 score_elf_got_section (bfd
*abfd
, bfd_boolean maybe_excluded
)
1082 asection
*sgot
= bfd_get_section_by_name (abfd
, ".got");
1084 if (sgot
== NULL
|| (! maybe_excluded
&& (sgot
->flags
& SEC_EXCLUDE
) != 0))
1089 /* Returns the GOT information associated with the link indicated by
1090 INFO. If SGOTP is non-NULL, it is filled in with the GOT section. */
1091 static struct score_got_info
*
1092 score_elf_got_info (bfd
*abfd
, asection
**sgotp
)
1095 struct score_got_info
*g
;
1097 sgot
= score_elf_got_section (abfd
, TRUE
);
1098 BFD_ASSERT (sgot
!= NULL
);
1099 BFD_ASSERT (elf_section_data (sgot
) != NULL
);
1100 g
= score_elf_section_data (sgot
)->u
.got_info
;
1101 BFD_ASSERT (g
!= NULL
);
1108 /* Sort the dynamic symbol table so that symbols that need GOT entries
1109 appear towards the end. This reduces the amount of GOT space
1110 required. MAX_LOCAL is used to set the number of local symbols
1111 known to be in the dynamic symbol table. During
1112 s3_bfd_score_elf_size_dynamic_sections, this value is 1. Afterward, the
1113 section symbols are added and the count is higher. */
1115 score_elf_sort_hash_table (struct bfd_link_info
*info
,
1116 unsigned long max_local
)
1118 struct score_elf_hash_sort_data hsd
;
1119 struct score_got_info
*g
;
1122 dynobj
= elf_hash_table (info
)->dynobj
;
1124 g
= score_elf_got_info (dynobj
, NULL
);
1127 hsd
.max_unref_got_dynindx
=
1128 hsd
.min_got_dynindx
= elf_hash_table (info
)->dynsymcount
1129 /* In the multi-got case, assigned_gotno of the master got_info
1130 indicate the number of entries that aren't referenced in the
1131 primary GOT, but that must have entries because there are
1132 dynamic relocations that reference it. Since they aren't
1133 referenced, we move them to the end of the GOT, so that they
1134 don't prevent other entries that are referenced from getting
1135 too large offsets. */
1136 - (g
->next
? g
->assigned_gotno
: 0);
1137 hsd
.max_non_got_dynindx
= max_local
;
1138 score_elf_link_hash_traverse (((struct score_elf_link_hash_table
*)
1139 elf_hash_table (info
)),
1140 score_elf_sort_hash_table_f
,
1143 /* There should have been enough room in the symbol table to
1144 accommodate both the GOT and non-GOT symbols. */
1145 BFD_ASSERT (hsd
.max_non_got_dynindx
<= hsd
.min_got_dynindx
);
1146 BFD_ASSERT ((unsigned long)hsd
.max_unref_got_dynindx
1147 <= elf_hash_table (info
)->dynsymcount
);
1149 /* Now we know which dynamic symbol has the lowest dynamic symbol
1150 table index in the GOT. */
1151 g
->global_gotsym
= hsd
.low
;
1156 /* Create an entry in an score ELF linker hash table. */
1157 static struct bfd_hash_entry
*
1158 score_elf_link_hash_newfunc (struct bfd_hash_entry
*entry
,
1159 struct bfd_hash_table
*table
,
1162 struct score_elf_link_hash_entry
*ret
= (struct score_elf_link_hash_entry
*)entry
;
1164 /* Allocate the structure if it has not already been allocated by a subclass. */
1166 ret
= bfd_hash_allocate (table
, sizeof (struct score_elf_link_hash_entry
));
1168 return (struct bfd_hash_entry
*)ret
;
1170 /* Call the allocation method of the superclass. */
1171 ret
= ((struct score_elf_link_hash_entry
*)
1172 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*)ret
, table
, string
));
1176 ret
->possibly_dynamic_relocs
= 0;
1177 ret
->readonly_reloc
= FALSE
;
1178 ret
->no_fn_stub
= FALSE
;
1179 ret
->forced_local
= FALSE
;
1182 return (struct bfd_hash_entry
*)ret
;
1185 /* Returns the first relocation of type r_type found, beginning with
1186 RELOCATION. RELEND is one-past-the-end of the relocation table. */
1187 static const Elf_Internal_Rela
*
1188 score_elf_next_relocation (bfd
*abfd ATTRIBUTE_UNUSED
, unsigned int r_type
,
1189 const Elf_Internal_Rela
*relocation
,
1190 const Elf_Internal_Rela
*relend
)
1192 while (relocation
< relend
)
1194 if (ELF32_R_TYPE (relocation
->r_info
) == r_type
)
1200 /* We didn't find it. */
1201 bfd_set_error (bfd_error_bad_value
);
1205 /* This function is called via qsort() to sort the dynamic relocation
1206 entries by increasing r_symndx value. */
1208 score_elf_sort_dynamic_relocs (const void *arg1
, const void *arg2
)
1210 Elf_Internal_Rela int_reloc1
;
1211 Elf_Internal_Rela int_reloc2
;
1213 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd
, arg1
, &int_reloc1
);
1214 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd
, arg2
, &int_reloc2
);
1216 return (ELF32_R_SYM (int_reloc1
.r_info
) - ELF32_R_SYM (int_reloc2
.r_info
));
1219 /* Return whether a relocation is against a local symbol. */
1221 score_elf_local_relocation_p (bfd
*input_bfd
,
1222 const Elf_Internal_Rela
*relocation
,
1223 asection
**local_sections
,
1224 bfd_boolean check_forced
)
1226 unsigned long r_symndx
;
1227 Elf_Internal_Shdr
*symtab_hdr
;
1228 struct score_elf_link_hash_entry
*h
;
1231 r_symndx
= ELF32_R_SYM (relocation
->r_info
);
1232 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1233 extsymoff
= (elf_bad_symtab (input_bfd
)) ? 0 : symtab_hdr
->sh_info
;
1235 if (r_symndx
< extsymoff
)
1237 if (elf_bad_symtab (input_bfd
) && local_sections
[r_symndx
] != NULL
)
1242 /* Look up the hash table to check whether the symbol was forced local. */
1243 h
= (struct score_elf_link_hash_entry
*)
1244 elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
];
1245 /* Find the real hash-table entry for this symbol. */
1246 while (h
->root
.root
.type
== bfd_link_hash_indirect
1247 || h
->root
.root
.type
== bfd_link_hash_warning
)
1248 h
= (struct score_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
1249 if (h
->root
.forced_local
)
1256 /* Returns the dynamic relocation section for DYNOBJ. */
1258 score_elf_rel_dyn_section (bfd
*dynobj
, bfd_boolean create_p
)
1260 static const char dname
[] = ".rel.dyn";
1263 sreloc
= bfd_get_section_by_name (dynobj
, dname
);
1264 if (sreloc
== NULL
&& create_p
)
1266 sreloc
= bfd_make_section_with_flags (dynobj
, dname
,
1271 | SEC_LINKER_CREATED
1274 || ! bfd_set_section_alignment (dynobj
, sreloc
,
1275 SCORE_ELF_LOG_FILE_ALIGN (dynobj
)))
1282 score_elf_allocate_dynamic_relocations (bfd
*abfd
, unsigned int n
)
1286 s
= score_elf_rel_dyn_section (abfd
, FALSE
);
1287 BFD_ASSERT (s
!= NULL
);
1291 /* Make room for a null element. */
1292 s
->size
+= SCORE_ELF_REL_SIZE (abfd
);
1295 s
->size
+= n
* SCORE_ELF_REL_SIZE (abfd
);
1298 /* Create a rel.dyn relocation for the dynamic linker to resolve. REL
1299 is the original relocation, which is now being transformed into a
1300 dynamic relocation. The ADDENDP is adjusted if necessary; the
1301 caller should store the result in place of the original addend. */
1303 score_elf_create_dynamic_relocation (bfd
*output_bfd
,
1304 struct bfd_link_info
*info
,
1305 const Elf_Internal_Rela
*rel
,
1306 struct score_elf_link_hash_entry
*h
,
1308 bfd_vma
*addendp
, asection
*input_section
)
1310 Elf_Internal_Rela outrel
[3];
1315 bfd_boolean defined_p
;
1317 r_type
= ELF32_R_TYPE (rel
->r_info
);
1318 dynobj
= elf_hash_table (info
)->dynobj
;
1319 sreloc
= score_elf_rel_dyn_section (dynobj
, FALSE
);
1320 BFD_ASSERT (sreloc
!= NULL
);
1321 BFD_ASSERT (sreloc
->contents
!= NULL
);
1322 BFD_ASSERT (sreloc
->reloc_count
* SCORE_ELF_REL_SIZE (output_bfd
) < sreloc
->size
);
1324 outrel
[0].r_offset
=
1325 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[0].r_offset
);
1326 outrel
[1].r_offset
=
1327 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[1].r_offset
);
1328 outrel
[2].r_offset
=
1329 _bfd_elf_section_offset (output_bfd
, info
, input_section
, rel
[2].r_offset
);
1331 if (outrel
[0].r_offset
== MINUS_ONE
)
1332 /* The relocation field has been deleted. */
1335 if (outrel
[0].r_offset
== MINUS_TWO
)
1337 /* The relocation field has been converted into a relative value of
1338 some sort. Functions like _bfd_elf_write_section_eh_frame expect
1339 the field to be fully relocated, so add in the symbol's value. */
1344 /* We must now calculate the dynamic symbol table index to use
1345 in the relocation. */
1347 && (! info
->symbolic
|| !h
->root
.def_regular
)
1348 /* h->root.dynindx may be -1 if this symbol was marked to
1350 && h
->root
.dynindx
!= -1)
1352 indx
= h
->root
.dynindx
;
1353 /* ??? glibc's ld.so just adds the final GOT entry to the
1354 relocation field. It therefore treats relocs against
1355 defined symbols in the same way as relocs against
1356 undefined symbols. */
1365 /* If the relocation was previously an absolute relocation and
1366 this symbol will not be referred to by the relocation, we must
1367 adjust it by the value we give it in the dynamic symbol table.
1368 Otherwise leave the job up to the dynamic linker. */
1369 if (defined_p
&& r_type
!= R_SCORE_REL32
)
1372 /* The relocation is always an REL32 relocation because we don't
1373 know where the shared library will wind up at load-time. */
1374 outrel
[0].r_info
= ELF32_R_INFO ((unsigned long) indx
, R_SCORE_REL32
);
1376 /* For strict adherence to the ABI specification, we should
1377 generate a R_SCORE_64 relocation record by itself before the
1378 _REL32/_64 record as well, such that the addend is read in as
1379 a 64-bit value (REL32 is a 32-bit relocation, after all).
1380 However, since none of the existing ELF64 SCORE dynamic
1381 loaders seems to care, we don't waste space with these
1382 artificial relocations. If this turns out to not be true,
1383 score_elf_allocate_dynamic_relocations() should be tweaked so
1384 as to make room for a pair of dynamic relocations per
1385 invocation if ABI_64_P, and here we should generate an
1386 additional relocation record with R_SCORE_64 by itself for a
1387 NULL symbol before this relocation record. */
1388 outrel
[1].r_info
= ELF32_R_INFO (0, R_SCORE_NONE
);
1389 outrel
[2].r_info
= ELF32_R_INFO (0, R_SCORE_NONE
);
1391 /* Adjust the output offset of the relocation to reference the
1392 correct location in the output file. */
1393 outrel
[0].r_offset
+= (input_section
->output_section
->vma
1394 + input_section
->output_offset
);
1395 outrel
[1].r_offset
+= (input_section
->output_section
->vma
1396 + input_section
->output_offset
);
1397 outrel
[2].r_offset
+= (input_section
->output_section
->vma
1398 + input_section
->output_offset
);
1400 /* Put the relocation back out. We have to use the special
1401 relocation outputter in the 64-bit case since the 64-bit
1402 relocation format is non-standard. */
1403 bfd_elf32_swap_reloc_out
1404 (output_bfd
, &outrel
[0],
1405 (sreloc
->contents
+ sreloc
->reloc_count
* sizeof (Elf32_External_Rel
)));
1407 /* We've now added another relocation. */
1408 ++sreloc
->reloc_count
;
1410 /* Make sure the output section is writable. The dynamic linker
1411 will be writing to it. */
1412 elf_section_data (input_section
->output_section
)->this_hdr
.sh_flags
|= SHF_WRITE
;
1418 score_elf_create_got_section (bfd
*abfd
,
1419 struct bfd_link_info
*info
,
1420 bfd_boolean maybe_exclude
)
1424 struct elf_link_hash_entry
*h
;
1425 struct bfd_link_hash_entry
*bh
;
1426 struct score_got_info
*g
;
1429 /* This function may be called more than once. */
1430 s
= score_elf_got_section (abfd
, TRUE
);
1433 if (! maybe_exclude
)
1434 s
->flags
&= ~SEC_EXCLUDE
;
1438 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
| SEC_LINKER_CREATED
);
1441 flags
|= SEC_EXCLUDE
;
1443 /* We have to use an alignment of 2**4 here because this is hardcoded
1444 in the function stub generation and in the linker script. */
1445 s
= bfd_make_section_with_flags (abfd
, ".got", flags
);
1447 || ! bfd_set_section_alignment (abfd
, s
, 4))
1450 /* Define the symbol _GLOBAL_OFFSET_TABLE_. We don't do this in the
1451 linker script because we don't want to define the symbol if we
1452 are not creating a global offset table. */
1454 if (! (_bfd_generic_link_add_one_symbol
1455 (info
, abfd
, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL
, s
,
1456 0, NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
1459 h
= (struct elf_link_hash_entry
*) bh
;
1462 h
->type
= STT_OBJECT
;
1464 if (info
->shared
&& ! bfd_elf_link_record_dynamic_symbol (info
, h
))
1467 amt
= sizeof (struct score_got_info
);
1468 g
= bfd_alloc (abfd
, amt
);
1472 g
->global_gotsym
= NULL
;
1473 g
->global_gotno
= 0;
1475 g
->local_gotno
= SCORE_RESERVED_GOTNO
;
1476 g
->assigned_gotno
= SCORE_RESERVED_GOTNO
;
1479 g
->got_entries
= htab_try_create (1, score_elf_got_entry_hash
,
1480 score_elf_got_entry_eq
, NULL
);
1481 if (g
->got_entries
== NULL
)
1483 score_elf_section_data (s
)->u
.got_info
= g
;
1484 score_elf_section_data (s
)->elf
.this_hdr
.sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_SCORE_GPREL
;
1489 /* Calculate the %high function. */
1491 score_elf_high (bfd_vma value
)
1493 return ((value
+ (bfd_vma
) 0x8000) >> 16) & 0xffff;
1496 /* Create a local GOT entry for VALUE. Return the index of the entry,
1497 or -1 if it could not be created. */
1498 static struct score_got_entry
*
1499 score_elf_create_local_got_entry (bfd
*abfd
,
1500 bfd
*ibfd ATTRIBUTE_UNUSED
,
1501 struct score_got_info
*gg
,
1502 asection
*sgot
, bfd_vma value
,
1503 unsigned long r_symndx ATTRIBUTE_UNUSED
,
1504 struct score_elf_link_hash_entry
*h ATTRIBUTE_UNUSED
,
1505 int r_type ATTRIBUTE_UNUSED
)
1507 struct score_got_entry entry
, **loc
;
1508 struct score_got_info
*g
;
1512 entry
.d
.address
= value
;
1515 loc
= (struct score_got_entry
**) htab_find_slot (g
->got_entries
, &entry
, INSERT
);
1519 entry
.gotidx
= SCORE_ELF_GOT_SIZE (abfd
) * g
->assigned_gotno
++;
1521 *loc
= bfd_alloc (abfd
, sizeof entry
);
1526 memcpy (*loc
, &entry
, sizeof entry
);
1528 if (g
->assigned_gotno
>= g
->local_gotno
)
1530 (*loc
)->gotidx
= -1;
1531 /* We didn't allocate enough space in the GOT. */
1532 (*_bfd_error_handler
)
1533 (_("not enough GOT space for local GOT entries"));
1534 bfd_set_error (bfd_error_bad_value
);
1538 score_bfd_put_32 (abfd
, value
, (sgot
->contents
+ entry
.gotidx
));
1543 /* Find a GOT entry whose higher-order 16 bits are the same as those
1544 for value. Return the index into the GOT for this entry. */
1546 score_elf_got16_entry (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
1547 bfd_vma value
, bfd_boolean external
)
1550 struct score_got_info
*g
;
1551 struct score_got_entry
*entry
;
1555 /* Although the ABI says that it is "the high-order 16 bits" that we
1556 want, it is really the %high value. The complete value is
1557 calculated with a `addiu' of a LO16 relocation, just as with a
1559 value
= score_elf_high (value
) << 16;
1562 g
= score_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
1564 entry
= score_elf_create_local_got_entry (abfd
, ibfd
, g
, sgot
, value
, 0, NULL
,
1567 return entry
->gotidx
;
1573 s3_bfd_score_elf_hide_symbol (struct bfd_link_info
*info
,
1574 struct elf_link_hash_entry
*entry
,
1575 bfd_boolean force_local
)
1579 struct score_got_info
*g
;
1580 struct score_elf_link_hash_entry
*h
;
1582 h
= (struct score_elf_link_hash_entry
*) entry
;
1583 if (h
->forced_local
)
1585 h
->forced_local
= TRUE
;
1587 dynobj
= elf_hash_table (info
)->dynobj
;
1588 if (dynobj
!= NULL
&& force_local
)
1590 got
= score_elf_got_section (dynobj
, FALSE
);
1593 g
= score_elf_section_data (got
)->u
.got_info
;
1597 struct score_got_entry e
;
1598 struct score_got_info
*gg
= g
;
1600 /* Since we're turning what used to be a global symbol into a
1601 local one, bump up the number of local entries of each GOT
1602 that had an entry for it. This will automatically decrease
1603 the number of global entries, since global_gotno is actually
1604 the upper limit of global entries. */
1609 for (g
= g
->next
; g
!= gg
; g
= g
->next
)
1610 if (htab_find (g
->got_entries
, &e
))
1612 BFD_ASSERT (g
->global_gotno
> 0);
1617 /* If this was a global symbol forced into the primary GOT, we
1618 no longer need an entry for it. We can't release the entry
1619 at this point, but we must at least stop counting it as one
1620 of the symbols that required a forced got entry. */
1621 if (h
->root
.got
.offset
== 2)
1623 BFD_ASSERT (gg
->assigned_gotno
> 0);
1624 gg
->assigned_gotno
--;
1627 else if (g
->global_gotno
== 0 && g
->global_gotsym
== NULL
)
1628 /* If we haven't got through GOT allocation yet, just bump up the
1629 number of local entries, as this symbol won't be counted as
1632 else if (h
->root
.got
.offset
== 1)
1634 /* If we're past non-multi-GOT allocation and this symbol had
1635 been marked for a global got entry, give it a local entry
1637 BFD_ASSERT (g
->global_gotno
> 0);
1643 _bfd_elf_link_hash_hide_symbol (info
, &h
->root
, force_local
);
1646 /* If H is a symbol that needs a global GOT entry, but has a dynamic
1647 symbol table index lower than any we've seen to date, record it for
1650 score_elf_record_global_got_symbol (struct elf_link_hash_entry
*h
,
1652 struct bfd_link_info
*info
,
1653 struct score_got_info
*g
)
1655 struct score_got_entry entry
, **loc
;
1657 /* A global symbol in the GOT must also be in the dynamic symbol table. */
1658 if (h
->dynindx
== -1)
1660 switch (ELF_ST_VISIBILITY (h
->other
))
1664 s3_bfd_score_elf_hide_symbol (info
, h
, TRUE
);
1667 if (!bfd_elf_link_record_dynamic_symbol (info
, h
))
1673 entry
.d
.h
= (struct score_elf_link_hash_entry
*)h
;
1675 loc
= (struct score_got_entry
**)htab_find_slot (g
->got_entries
, &entry
, INSERT
);
1677 /* If we've already marked this entry as needing GOT space, we don't
1678 need to do it again. */
1682 *loc
= bfd_alloc (abfd
, sizeof entry
);
1688 memcpy (*loc
, &entry
, sizeof (entry
));
1690 if (h
->got
.offset
!= MINUS_ONE
)
1693 /* By setting this to a value other than -1, we are indicating that
1694 there needs to be a GOT entry for H. Avoid using zero, as the
1695 generic ELF copy_indirect_symbol tests for <= 0. */
1701 /* Reserve space in G for a GOT entry containing the value of symbol
1702 SYMNDX in input bfd ABDF, plus ADDEND. */
1704 score_elf_record_local_got_symbol (bfd
*abfd
,
1707 struct score_got_info
*g
)
1709 struct score_got_entry entry
, **loc
;
1712 entry
.symndx
= symndx
;
1713 entry
.d
.addend
= addend
;
1714 loc
= (struct score_got_entry
**)htab_find_slot (g
->got_entries
, &entry
, INSERT
);
1719 entry
.gotidx
= g
->local_gotno
++;
1721 *loc
= bfd_alloc (abfd
, sizeof(entry
));
1725 memcpy (*loc
, &entry
, sizeof (entry
));
1730 /* Returns the GOT offset at which the indicated address can be found.
1731 If there is not yet a GOT entry for this value, create one.
1732 Returns -1 if no satisfactory GOT offset can be found. */
1734 score_elf_local_got_index (bfd
*abfd
, bfd
*ibfd
, struct bfd_link_info
*info
,
1735 bfd_vma value
, unsigned long r_symndx
,
1736 struct score_elf_link_hash_entry
*h
, int r_type
)
1739 struct score_got_info
*g
;
1740 struct score_got_entry
*entry
;
1742 g
= score_elf_got_info (elf_hash_table (info
)->dynobj
, &sgot
);
1744 entry
= score_elf_create_local_got_entry (abfd
, ibfd
, g
, sgot
, value
,
1745 r_symndx
, h
, r_type
);
1750 return entry
->gotidx
;
1753 /* Returns the GOT index for the global symbol indicated by H. */
1756 score_elf_global_got_index (bfd
*abfd
, struct elf_link_hash_entry
*h
)
1760 struct score_got_info
*g
;
1761 long global_got_dynindx
= 0;
1763 g
= score_elf_got_info (abfd
, &sgot
);
1764 if (g
->global_gotsym
!= NULL
)
1765 global_got_dynindx
= g
->global_gotsym
->dynindx
;
1767 /* Once we determine the global GOT entry with the lowest dynamic
1768 symbol table index, we must put all dynamic symbols with greater
1769 indices into the GOT. That makes it easy to calculate the GOT
1771 BFD_ASSERT (h
->dynindx
>= global_got_dynindx
);
1772 got_index
= ((h
->dynindx
- global_got_dynindx
+ g
->local_gotno
) * SCORE_ELF_GOT_SIZE (abfd
));
1773 BFD_ASSERT (got_index
< sgot
->size
);
1778 /* Returns the offset for the entry at the INDEXth position in the GOT. */
1781 score_elf_got_offset_from_index (bfd
*dynobj
,
1783 bfd
*input_bfd ATTRIBUTE_UNUSED
,
1788 struct score_got_info
*g
;
1790 g
= score_elf_got_info (dynobj
, &sgot
);
1791 gp
= _bfd_get_gp_value (output_bfd
);
1793 return sgot
->output_section
->vma
+ sgot
->output_offset
+ got_index
- gp
;
1796 /* Follow indirect and warning hash entries so that each got entry
1797 points to the final symbol definition. P must point to a pointer
1798 to the hash table we're traversing. Since this traversal may
1799 modify the hash table, we set this pointer to NULL to indicate
1800 we've made a potentially-destructive change to the hash table, so
1801 the traversal must be restarted. */
1803 score_elf_resolve_final_got_entry (void **entryp
, void *p
)
1805 struct score_got_entry
*entry
= (struct score_got_entry
*)*entryp
;
1806 htab_t got_entries
= *(htab_t
*)p
;
1808 if (entry
->abfd
!= NULL
&& entry
->symndx
== -1)
1810 struct score_elf_link_hash_entry
*h
= entry
->d
.h
;
1812 while (h
->root
.root
.type
== bfd_link_hash_indirect
1813 || h
->root
.root
.type
== bfd_link_hash_warning
)
1814 h
= (struct score_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
1816 if (entry
->d
.h
== h
)
1821 /* If we can't find this entry with the new bfd hash, re-insert
1822 it, and get the traversal restarted. */
1823 if (! htab_find (got_entries
, entry
))
1825 htab_clear_slot (got_entries
, entryp
);
1826 entryp
= htab_find_slot (got_entries
, entry
, INSERT
);
1829 /* Abort the traversal, since the whole table may have
1830 moved, and leave it up to the parent to restart the
1832 *(htab_t
*)p
= NULL
;
1835 /* We might want to decrement the global_gotno count, but it's
1836 either too early or too late for that at this point. */
1842 /* Turn indirect got entries in a got_entries table into their final locations. */
1844 score_elf_resolve_final_got_entries (struct score_got_info
*g
)
1850 got_entries
= g
->got_entries
;
1852 htab_traverse (got_entries
,
1853 score_elf_resolve_final_got_entry
,
1856 while (got_entries
== NULL
);
1859 /* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS. for -r */
1861 score_elf_add_to_rel (bfd
*abfd
,
1863 reloc_howto_type
*howto
,
1864 bfd_signed_vma increment
)
1866 bfd_signed_vma addend
;
1868 unsigned long offset
;
1869 unsigned long r_type
= howto
->type
;
1870 unsigned long hi16_addend
, hi16_offset
, hi16_value
, uvalue
;
1872 contents
= score_bfd_get_32 (abfd
, address
);
1873 /* Get the (signed) value from the instruction. */
1874 addend
= contents
& howto
->src_mask
;
1875 if (addend
& ((howto
->src_mask
+ 1) >> 1))
1877 bfd_signed_vma mask
;
1880 mask
&= ~howto
->src_mask
;
1883 /* Add in the increment, (which is a byte value). */
1888 (((contents
& howto
->src_mask
) & 0x3ff0000) >> 6) | ((contents
& howto
->src_mask
) & 0x3ff);
1889 offset
+= increment
;
1891 (contents
& ~howto
->
1892 src_mask
) | (((offset
<< 6) & howto
->src_mask
) & 0x3ff0000) | (offset
& 0x3ff);
1893 score_bfd_put_32 (abfd
, contents
, address
);
1898 hi16_addend
= score_bfd_get_32 (abfd
, address
- 4);
1899 hi16_offset
= ((((hi16_addend
>> 16) & 0x3) << 15) | (hi16_addend
& 0x7fff)) >> 1;
1900 offset
= ((((contents
>> 16) & 0x3) << 15) | (contents
& 0x7fff)) >> 1;
1901 offset
= (hi16_offset
<< 16) | (offset
& 0xffff);
1902 uvalue
= increment
+ offset
;
1903 hi16_offset
= (uvalue
>> 16) << 1;
1904 hi16_value
= (hi16_addend
& (~(howto
->dst_mask
)))
1905 | (hi16_offset
& 0x7fff) | ((hi16_offset
<< 1) & 0x30000);
1906 score_bfd_put_32 (abfd
, hi16_value
, address
- 4);
1907 offset
= (uvalue
& 0xffff) << 1;
1908 contents
= (contents
& (~(howto
->dst_mask
))) | (offset
& 0x7fff) | ((offset
<< 1) & 0x30000);
1909 score_bfd_put_32 (abfd
, contents
, address
);
1913 (((contents
& howto
->src_mask
) >> 1) & 0x1ff8000) | ((contents
& howto
->src_mask
) & 0x7fff);
1914 offset
+= increment
;
1916 (contents
& ~howto
->
1917 src_mask
) | (((offset
<< 1) & howto
->src_mask
) & 0x3ff0000) | (offset
& 0x7fff);
1918 score_bfd_put_32 (abfd
, contents
, address
);
1923 contents
= score_bfd_get_16 (abfd
, address
);
1924 offset
= contents
& howto
->src_mask
;
1925 offset
+= increment
;
1926 contents
= (contents
& ~howto
->src_mask
) | (offset
& howto
->src_mask
);
1927 score_bfd_put_16 (abfd
, contents
, address
);
1932 contents
= score_bfd_get_16 (abfd
, address
);
1933 offset
= (contents
& howto
->src_mask
) + ((increment
>> 1) & 0x1ff);
1934 contents
= (contents
& (~howto
->src_mask
)) | (offset
& howto
->src_mask
);
1935 score_bfd_put_16 (abfd
, contents
, address
);
1940 contents
= score_bfd_get_32 (abfd
, address
);
1941 offset
= (contents
& howto
->src_mask
);
1942 offset
<<= howto
->rightshift
;
1943 offset
+= increment
;
1944 offset
>>= howto
->rightshift
;
1945 contents
= (contents
& (~howto
->src_mask
)) | (offset
& howto
->src_mask
);
1946 score_bfd_put_32 (abfd
, contents
, address
);
1950 contents
= score_bfd_get_48 (abfd
, address
);
1951 offset
= (contents
& howto
->src_mask
);
1952 offset
<<= howto
->rightshift
;
1953 offset
+= increment
;
1954 offset
>>= howto
->rightshift
;
1955 contents
= (contents
& (~howto
->src_mask
)) | (offset
& howto
->src_mask
);
1956 score_bfd_put_48 (abfd
, contents
, address
);
1960 contents
= score_bfd_get_48 (abfd
, address
);
1961 offset
= (contents
& howto
->src_mask
);
1962 offset
+= increment
;
1963 contents
= (contents
& (~howto
->src_mask
)) | (offset
& howto
->src_mask
);
1964 score_bfd_put_48 (abfd
, contents
, address
);
1968 addend
+= increment
;
1969 contents
= (contents
& ~howto
->dst_mask
) | (addend
& howto
->dst_mask
);
1970 score_bfd_put_32 (abfd
, contents
, address
);
1975 /* Perform a relocation as part of a final link. */
1976 static bfd_reloc_status_type
1977 score_elf_final_link_relocate (reloc_howto_type
*howto
,
1980 asection
*input_section
,
1982 Elf_Internal_Rela
*rel
,
1983 Elf_Internal_Rela
*relocs
,
1985 struct bfd_link_info
*info
,
1986 const char *sym_name ATTRIBUTE_UNUSED
,
1987 int sym_flags ATTRIBUTE_UNUSED
,
1988 struct score_elf_link_hash_entry
*h
,
1989 asection
**local_sections
,
1990 bfd_boolean gp_disp_p
)
1992 unsigned long r_type
;
1993 unsigned long r_symndx
;
1994 bfd_byte
*hit_data
= contents
+ rel
->r_offset
;
1996 /* The final GP value to be used for the relocatable, executable, or
1997 shared object file being produced. */
1998 bfd_vma gp
= MINUS_ONE
;
1999 /* The place (section offset or address) of the storage unit being relocated. */
2001 /* The value of GP used to create the relocatable object. */
2002 bfd_vma gp0
= MINUS_ONE
;
2003 /* The offset into the global offset table at which the address of the relocation entry
2004 symbol, adjusted by the addend, resides during execution. */
2005 bfd_vma g
= MINUS_ONE
;
2006 /* TRUE if the symbol referred to by this relocation is a local symbol. */
2007 bfd_boolean local_p
;
2008 /* The eventual value we will relocate. */
2009 bfd_vma value
= symbol
;
2010 unsigned long hi16_addend
, hi16_offset
, hi16_value
, uvalue
, offset
, abs_value
= 0;
2013 if (elf_gp (output_bfd
) == 0)
2015 struct bfd_link_hash_entry
*bh
;
2018 bh
= bfd_link_hash_lookup (info
->hash
, "_gp", 0, 0, 1);
2019 if (bh
!= NULL
&& bh
->type
== bfd_link_hash_defined
)
2020 elf_gp (output_bfd
) = (bh
->u
.def
.value
2021 + bh
->u
.def
.section
->output_section
->vma
2022 + bh
->u
.def
.section
->output_offset
);
2023 else if (info
->relocatable
)
2027 /* Find the GP-relative section with the lowest offset. */
2028 for (o
= output_bfd
->sections
; o
!= NULL
; o
= o
->next
)
2031 /* And calculate GP relative to that. */
2032 elf_gp (output_bfd
) = lo
+ ELF_SCORE_GP_OFFSET (input_bfd
);
2036 /* If the relocate_section function needs to do a reloc
2037 involving the GP value, it should make a reloc_dangerous
2038 callback to warn that GP is not defined. */
2042 /* Parse the relocation. */
2043 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2044 r_type
= ELF32_R_TYPE (rel
->r_info
);
2045 rel_addr
= (input_section
->output_section
->vma
+ input_section
->output_offset
+ rel
->r_offset
);
2046 local_p
= score_elf_local_relocation_p (input_bfd
, rel
, local_sections
, TRUE
);
2048 if (r_type
== R_SCORE_GOT15
)
2050 const Elf_Internal_Rela
*relend
;
2051 const Elf_Internal_Rela
*lo16_rel
;
2052 const struct elf_backend_data
*bed
;
2053 bfd_vma lo_value
= 0;
2055 bed
= get_elf_backend_data (output_bfd
);
2056 relend
= relocs
+ input_section
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
2057 lo16_rel
= score_elf_next_relocation (input_bfd
, R_SCORE_GOT_LO16
, rel
, relend
);
2058 if ((local_p
) && (lo16_rel
!= NULL
))
2061 tmp
= score_bfd_get_32 (input_bfd
, contents
+ lo16_rel
->r_offset
);
2062 lo_value
= (((tmp
>> 16) & 0x3) << 14) | ((tmp
& 0x7fff) >> 1);
2066 /* For score3 R_SCORE_ABS32. */
2067 else if (r_type
== R_SCORE_ABS32
|| r_type
== R_SCORE_REL32
)
2069 addend
= (bfd_get_32 (input_bfd
, hit_data
) >> howto
->bitpos
) & howto
->src_mask
;
2073 addend
= (score_bfd_get_32 (input_bfd
, hit_data
) >> howto
->bitpos
) & howto
->src_mask
;
2076 /* If we haven't already determined the GOT offset, or the GP value,
2077 and we're going to need it, get it now. */
2080 case R_SCORE_CALL15
:
2084 g
= score_elf_global_got_index (elf_hash_table (info
)->dynobj
,
2085 (struct elf_link_hash_entry
*) h
);
2086 if ((! elf_hash_table(info
)->dynamic_sections_created
2088 && (info
->symbolic
|| h
->root
.dynindx
== -1)
2089 && h
->root
.def_regular
)))
2091 /* This is a static link or a -Bsymbolic link. The
2092 symbol is defined locally, or was forced to be local.
2093 We must initialize this entry in the GOT. */
2094 bfd
*tmpbfd
= elf_hash_table (info
)->dynobj
;
2095 asection
*sgot
= score_elf_got_section (tmpbfd
, FALSE
);
2096 score_bfd_put_32 (tmpbfd
, value
, sgot
->contents
+ g
);
2099 else if (r_type
== R_SCORE_GOT15
|| r_type
== R_SCORE_CALL15
)
2101 /* There's no need to create a local GOT entry here; the
2102 calculation for a local GOT15 entry does not involve G. */
2107 g
= score_elf_local_got_index (output_bfd
, input_bfd
, info
,
2108 symbol
+ addend
, r_symndx
, h
, r_type
);
2110 return bfd_reloc_outofrange
;
2113 /* Convert GOT indices to actual offsets. */
2114 g
= score_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
2115 output_bfd
, input_bfd
, g
);
2120 case R_SCORE_GPREL32
:
2121 gp0
= _bfd_get_gp_value (input_bfd
);
2122 gp
= _bfd_get_gp_value (output_bfd
);
2126 gp
= _bfd_get_gp_value (output_bfd
);
2135 return bfd_reloc_ok
;
2140 || (elf_hash_table (info
)->dynamic_sections_created
2142 && h
->root
.def_dynamic
2143 && !h
->root
.def_regular
))
2145 && (input_section
->flags
& SEC_ALLOC
) != 0)
2147 /* If we're creating a shared library, or this relocation is against a symbol
2148 in a shared library, then we can't know where the symbol will end up.
2149 So, we create a relocation record in the output, and leave the job up
2150 to the dynamic linker. */
2152 if (!score_elf_create_dynamic_relocation (output_bfd
, info
, rel
, h
,
2155 return bfd_reloc_undefined
;
2157 else if (r_symndx
== 0)
2158 /* r_symndx will be zero only for relocs against symbols
2159 from removed linkonce sections, or sections discarded by
2164 if (r_type
!= R_SCORE_REL32
)
2165 value
= symbol
+ addend
;
2169 value
&= howto
->dst_mask
;
2170 bfd_put_32 (input_bfd
, value
, hit_data
);
2171 return bfd_reloc_ok
;
2175 if ((long)value
> 0x7fff || (long)value
< -0x8000)
2176 return bfd_reloc_overflow
;
2177 score_bfd_put_16 (input_bfd
, value
, hit_data
);
2178 return bfd_reloc_ok
;
2181 addend
= score_bfd_get_32 (input_bfd
, hit_data
);
2182 offset
= (((addend
& howto
->src_mask
) >> 1) & 0x1ff8000) | ((addend
& howto
->src_mask
) & 0x7fff);
2183 if ((offset
& 0x1000000) != 0)
2184 offset
|= 0xfe000000;
2186 abs_value
= abs (value
- rel_addr
);
2187 if ((abs_value
& 0xfe000000) != 0)
2188 return bfd_reloc_overflow
;
2189 addend
= (addend
& ~howto
->src_mask
)
2190 | (((value
<< 1) & howto
->src_mask
) & 0x3ff0000) | (value
& 0x7fff);
2191 score_bfd_put_32 (input_bfd
, addend
, hit_data
);
2192 return bfd_reloc_ok
;
2197 int not_word_align_p
= 0;
2198 bfd_vma imm_offset
= 0;
2199 addend
= score_bfd_get_48 (input_bfd
, hit_data
);
2200 imm_offset
= ((addend
>> 7) & 0xff)
2201 | (((addend
>> 16) & 0x7fff) << 8)
2202 | (((addend
>> 32) & 0x7f) << 23);
2203 imm_offset
<<= howto
->rightshift
;
2204 value
+= imm_offset
;
2205 value
&= 0xffffffff;
2207 /* Check lw48/sw48 rd, value/label word align. */
2208 if ((value
& 0x3) != 0)
2209 not_word_align_p
= 1;
2211 value
>>= howto
->rightshift
;
2212 addend
= (addend
& ~howto
->src_mask
)
2213 | (((value
& 0xff) >> 0) << 7)
2214 | (((value
& 0x7fff00) >> 8) << 16)
2215 | (((value
& 0x3f800000) >> 23) << 32);
2216 score_bfd_put_48 (input_bfd
, addend
, hit_data
);
2217 if (not_word_align_p
)
2218 return bfd_reloc_other
;
2220 return bfd_reloc_ok
;
2225 bfd_vma imm_offset
= 0;
2226 addend
= score_bfd_get_48 (input_bfd
, hit_data
);
2227 imm_offset
= ((addend
>> 5) & 0x3ff)
2228 | (((addend
>> 16) & 0x7fff) << 10)
2229 | (((addend
>> 32) & 0x7f) << 25);
2230 value
+= imm_offset
;
2231 value
&= 0xffffffff;
2232 addend
= (addend
& ~howto
->src_mask
)
2233 | ((value
& 0x3ff) << 5)
2234 | (((value
>> 10) & 0x7fff) << 16)
2235 | (((value
>> 25) & 0x7f) << 32);
2236 score_bfd_put_48 (input_bfd
, addend
, hit_data
);
2237 return bfd_reloc_ok
;
2241 addend
= score_bfd_get_32 (input_bfd
, hit_data
);
2242 offset
= (((addend
& howto
->src_mask
) & 0x3ff0000) >> 6) | ((addend
& howto
->src_mask
) & 0x3ff);
2243 if ((offset
& 0x80000) != 0)
2244 offset
|= 0xfff00000;
2245 abs_value
= value
= value
- rel_addr
+ offset
;
2246 /* exceed 20 bit : overflow. */
2247 if ((abs_value
& 0x80000000) == 0x80000000)
2248 abs_value
= 0xffffffff - value
+ 1;
2249 if ((abs_value
& 0xfff80000) != 0)
2250 return bfd_reloc_overflow
;
2251 addend
= (addend
& ~howto
->src_mask
)
2252 | (((value
<< 6) & howto
->src_mask
) & 0x3ff0000) | (value
& 0x3ff);
2253 score_bfd_put_32 (input_bfd
, addend
, hit_data
);
2254 return bfd_reloc_ok
;
2257 addend
= score_bfd_get_16 (input_bfd
, hit_data
);
2258 offset
= addend
& howto
->src_mask
;
2259 if ((offset
& 0x800) != 0) /* Offset is negative. */
2260 offset
|= 0xfffff000;
2262 abs_value
= abs (value
- rel_addr
);
2263 if ((abs_value
& 0xfffff000) != 0)
2264 return bfd_reloc_overflow
;
2265 addend
= (addend
& ~howto
->src_mask
) | (value
& howto
->src_mask
);
2266 score_bfd_put_16 (input_bfd
, addend
, hit_data
);
2267 return bfd_reloc_ok
;
2270 addend
= score_bfd_get_16 (input_bfd
, hit_data
);
2271 offset
= (addend
& howto
->src_mask
) << 1;
2272 if ((offset
& 0x200) != 0) /* Offset is negative. */
2273 offset
|= 0xfffffe00;
2274 abs_value
= value
= value
- rel_addr
+ offset
;
2275 /* Sign bit + exceed 9 bit. */
2276 if (((value
& 0xfffffe00) != 0) && ((value
& 0xfffffe00) != 0xfffffe00))
2277 return bfd_reloc_overflow
;
2279 addend
= (addend
& ~howto
->src_mask
) | (value
& howto
->src_mask
);
2280 score_bfd_put_16 (input_bfd
, addend
, hit_data
);
2281 return bfd_reloc_ok
;
2284 addend
= score_bfd_get_32 (input_bfd
, hit_data
);
2285 offset
= (addend
& howto
->src_mask
) << howto
->rightshift
;
2286 if ((offset
& 0x200) != 0) /* Offset is negative. */
2287 offset
|= 0xfffffe00;
2288 value
= value
- rel_addr
+ offset
;
2289 /* Sign bit + exceed 9 bit. */
2290 if (((value
& 0xfffffe00) != 0) && ((value
& 0xfffffe00) != 0xfffffe00))
2291 return bfd_reloc_overflow
;
2292 value
>>= howto
->rightshift
;
2293 addend
= (addend
& ~howto
->src_mask
)
2295 | (((value
>> 1) & 0x7) << 7)
2296 | (((value
>> 4) & 0x1f) << 21);
2297 score_bfd_put_32 (input_bfd
, addend
, hit_data
);
2298 return bfd_reloc_ok
;
2301 return bfd_reloc_ok
;
2304 hi16_addend
= score_bfd_get_32 (input_bfd
, hit_data
- 4);
2305 hi16_offset
= ((((hi16_addend
>> 16) & 0x3) << 15) | (hi16_addend
& 0x7fff)) >> 1;
2306 addend
= score_bfd_get_32 (input_bfd
, hit_data
);
2307 offset
= ((((addend
>> 16) & 0x3) << 15) | (addend
& 0x7fff)) >> 1;
2308 offset
= (hi16_offset
<< 16) | (offset
& 0xffff);
2311 uvalue
= value
+ offset
;
2313 uvalue
= offset
+ gp
- rel_addr
+ 4;
2315 hi16_offset
= (uvalue
>> 16) << 1;
2316 hi16_value
= (hi16_addend
& (~(howto
->dst_mask
)))
2317 | (hi16_offset
& 0x7fff) | ((hi16_offset
<< 1) & 0x30000);
2318 score_bfd_put_32 (input_bfd
, hi16_value
, hit_data
- 4);
2319 offset
= (uvalue
& 0xffff) << 1;
2320 value
= (addend
& (~(howto
->dst_mask
))) | (offset
& 0x7fff) | ((offset
<< 1) & 0x30000);
2321 score_bfd_put_32 (input_bfd
, value
, hit_data
);
2322 return bfd_reloc_ok
;
2325 addend
= score_bfd_get_32 (input_bfd
, hit_data
);
2326 offset
= addend
& 0x7fff;
2327 if ((offset
& 0x4000) == 0x4000)
2328 offset
|= 0xffffc000;
2329 value
= value
+ offset
- gp
;
2330 if (((value
& 0xffffc000) != 0) && ((value
& 0xffffc000) != 0xffffc000))
2331 return bfd_reloc_overflow
;
2332 value
= (addend
& ~howto
->src_mask
) | (value
& howto
->src_mask
);
2333 score_bfd_put_32 (input_bfd
, value
, hit_data
);
2334 return bfd_reloc_ok
;
2337 case R_SCORE_CALL15
:
2342 /* The special case is when the symbol is forced to be local. We need the
2343 full address in the GOT since no R_SCORE_GOT_LO16 relocation follows. */
2344 forced
= ! score_elf_local_relocation_p (input_bfd
, rel
,
2345 local_sections
, FALSE
);
2346 value
= score_elf_got16_entry (output_bfd
, input_bfd
, info
,
2347 symbol
+ addend
, forced
);
2348 if (value
== MINUS_ONE
)
2349 return bfd_reloc_outofrange
;
2350 value
= score_elf_got_offset_from_index (elf_hash_table (info
)->dynobj
,
2351 output_bfd
, input_bfd
, value
);
2358 if ((long) value
> 0x3fff || (long) value
< -0x4000)
2359 return bfd_reloc_overflow
;
2361 addend
= score_bfd_get_32 (input_bfd
, hit_data
);
2362 value
= (addend
& ~howto
->dst_mask
) | (value
& howto
->dst_mask
);
2363 score_bfd_put_32 (input_bfd
, value
, hit_data
);
2364 return bfd_reloc_ok
;
2366 case R_SCORE_GPREL32
:
2367 value
= (addend
+ symbol
- gp
);
2368 value
&= howto
->dst_mask
;
2369 score_bfd_put_32 (input_bfd
, value
, hit_data
);
2370 return bfd_reloc_ok
;
2372 case R_SCORE_GOT_LO16
:
2373 addend
= score_bfd_get_32 (input_bfd
, hit_data
);
2374 value
= (((addend
>> 16) & 0x3) << 14) | ((addend
& 0x7fff) >> 1);
2376 value
= (addend
& (~(howto
->dst_mask
))) | ((value
& 0x3fff) << 1)
2377 | (((value
>> 14) & 0x3) << 16);
2379 score_bfd_put_32 (input_bfd
, value
, hit_data
);
2380 return bfd_reloc_ok
;
2382 case R_SCORE_DUMMY_HI16
:
2383 return bfd_reloc_ok
;
2385 case R_SCORE_GNU_VTINHERIT
:
2386 case R_SCORE_GNU_VTENTRY
:
2387 /* We don't do anything with these at present. */
2388 return bfd_reloc_continue
;
2391 return bfd_reloc_notsupported
;
2395 /* Score backend functions. */
2397 s3_bfd_score_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
2399 Elf_Internal_Rela
*elf_reloc
)
2401 unsigned int r_type
;
2403 r_type
= ELF32_R_TYPE (elf_reloc
->r_info
);
2404 if (r_type
>= ARRAY_SIZE (elf32_score_howto_table
))
2405 bfd_reloc
->howto
= NULL
;
2407 bfd_reloc
->howto
= &elf32_score_howto_table
[r_type
];
2410 /* Relocate an score ELF section. */
2412 s3_bfd_score_elf_relocate_section (bfd
*output_bfd
,
2413 struct bfd_link_info
*info
,
2415 asection
*input_section
,
2417 Elf_Internal_Rela
*relocs
,
2418 Elf_Internal_Sym
*local_syms
,
2419 asection
**local_sections
)
2421 Elf_Internal_Shdr
*symtab_hdr
;
2422 struct elf_link_hash_entry
**sym_hashes
;
2423 Elf_Internal_Rela
*rel
;
2424 Elf_Internal_Rela
*relend
;
2426 unsigned long offset
;
2427 unsigned long hi16_addend
, hi16_offset
, hi16_value
, uvalue
;
2429 bfd_boolean gp_disp_p
= FALSE
;
2432 if (elf_hash_table (info
)->dynamic_sections_created
)
2434 bfd_size_type dynsecsymcount
= 0;
2438 const struct elf_backend_data
*bed
= get_elf_backend_data (output_bfd
);
2440 for (p
= output_bfd
->sections
; p
; p
= p
->next
)
2441 if ((p
->flags
& SEC_EXCLUDE
) == 0
2442 && (p
->flags
& SEC_ALLOC
) != 0
2443 && !(*bed
->elf_backend_omit_section_dynsym
) (output_bfd
, info
, p
))
2447 if (!score_elf_sort_hash_table (info
, dynsecsymcount
+ 1))
2451 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2452 extsymoff
= (elf_bad_symtab (input_bfd
)) ? 0 : symtab_hdr
->sh_info
;
2453 sym_hashes
= elf_sym_hashes (input_bfd
);
2455 relend
= relocs
+ input_section
->reloc_count
;
2456 for (; rel
< relend
; rel
++)
2459 reloc_howto_type
*howto
;
2460 unsigned long r_symndx
;
2461 Elf_Internal_Sym
*sym
;
2463 struct score_elf_link_hash_entry
*h
;
2464 bfd_vma relocation
= 0;
2465 bfd_reloc_status_type r
;
2468 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2469 r_type
= ELF32_R_TYPE (rel
->r_info
);
2471 s3_bfd_score_info_to_howto (input_bfd
, &bfd_reloc
, (Elf_Internal_Rela
*) rel
);
2472 howto
= bfd_reloc
.howto
;
2478 if (r_symndx
< extsymoff
)
2480 sym
= local_syms
+ r_symndx
;
2481 sec
= local_sections
[r_symndx
];
2482 relocation
= (sec
->output_section
->vma
2483 + sec
->output_offset
2485 name
= bfd_elf_sym_name (input_bfd
, symtab_hdr
, sym
, sec
);
2487 if (!info
->relocatable
2488 && (sec
->flags
& SEC_MERGE
)
2489 && ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
2492 bfd_vma addend
, value
;
2499 hi16_addend
= score_bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
- 4);
2500 hi16_offset
= ((((hi16_addend
>> 16) & 0x3) << 15) | (hi16_addend
& 0x7fff)) >> 1;
2501 value
= score_bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
2502 offset
= ((((value
>> 16) & 0x3) << 15) | (value
& 0x7fff)) >> 1;
2503 addend
= (hi16_offset
<< 16) | (offset
& 0xffff);
2505 addend
= _bfd_elf_rel_local_sym (output_bfd
, sym
, &msec
, addend
);
2506 addend
-= relocation
;
2507 addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
2509 hi16_offset
= (uvalue
>> 16) << 1;
2510 hi16_value
= (hi16_addend
& (~(howto
->dst_mask
)))
2511 | (hi16_offset
& 0x7fff) | ((hi16_offset
<< 1) & 0x30000);
2512 score_bfd_put_32 (input_bfd
, hi16_value
, contents
+ rel
->r_offset
- 4);
2513 offset
= (uvalue
& 0xffff) << 1;
2514 value
= (value
& (~(howto
->dst_mask
)))
2515 | (offset
& 0x7fff) | ((offset
<< 1) & 0x30000);
2516 score_bfd_put_32 (input_bfd
, value
, contents
+ rel
->r_offset
);
2521 value
= score_bfd_get_48 (input_bfd
, contents
+ rel
->r_offset
);
2522 addend
= ((value
>> 5) & 0x3ff)
2523 | (((value
>> 16) & 0x7fff) << 10)
2524 | (((value
>> 32) & 0x7f) << 25);
2526 addend
= _bfd_elf_rel_local_sym (output_bfd
, sym
, &msec
, addend
);
2527 addend
-= relocation
;
2528 addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
2529 addend
&= 0xffffffff;
2530 value
= (value
& ~howto
->src_mask
)
2531 | ((addend
& 0x3ff) << 5)
2532 | (((addend
>> 10) & 0x7fff) << 16)
2533 | (((addend
>> 25) & 0x7f) << 32);
2534 score_bfd_put_48 (input_bfd
, value
, contents
+ rel
->r_offset
);
2540 int not_word_align_p
= 0;
2541 value
= score_bfd_get_48 (input_bfd
, contents
+ rel
->r_offset
);
2542 addend
= ((value
>> 7) & 0xff)
2543 | (((value
>> 16) & 0x7fff) << 8)
2544 | (((value
>> 32) & 0x7f) << 23);
2545 addend
<<= howto
->rightshift
;
2547 addend
= _bfd_elf_rel_local_sym (output_bfd
, sym
, &msec
, addend
);
2548 addend
-= relocation
;
2549 addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
2550 addend
&= 0xffffffff;
2552 /* Check lw48/sw48 rd, value/label word align. */
2553 if ((addend
& 0x3) != 0)
2554 not_word_align_p
= 1;
2556 addend
>>= howto
->rightshift
;
2557 value
= (value
& ~howto
->src_mask
)
2558 | (((addend
& 0xff) >> 0) << 7)
2559 | (((addend
& 0x7fff00) >> 8) << 16)
2560 | (((addend
& 0x3f800000) >> 23) << 32);
2561 score_bfd_put_48 (input_bfd
, value
, contents
+ rel
->r_offset
);
2563 if (not_word_align_p
)
2564 return bfd_reloc_other
;
2569 case R_SCORE_GOT_LO16
:
2570 value
= score_bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
2571 addend
= (((value
>> 16) & 0x3) << 14) | ((value
& 0x7fff) >> 1);
2573 addend
= _bfd_elf_rel_local_sym (output_bfd
, sym
, &msec
, addend
) - relocation
;
2574 addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
2575 value
= (value
& (~(howto
->dst_mask
))) | ((addend
& 0x3fff) << 1)
2576 | (((addend
>> 14) & 0x3) << 16);
2578 score_bfd_put_32 (input_bfd
, value
, contents
+ rel
->r_offset
);
2583 value
= 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 bfd_put_32 (input_bfd
, value
, contents
+ rel
->r_offset
);
2602 value
= score_bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
2603 /* Get the (signed) value from the instruction. */
2604 addend
= value
& howto
->src_mask
;
2605 if (addend
& ((howto
->src_mask
+ 1) >> 1))
2607 bfd_signed_vma mask
;
2610 mask
&= ~howto
->src_mask
;
2614 addend
= _bfd_elf_rel_local_sym (output_bfd
, sym
, &msec
, addend
) - relocation
;
2615 addend
+= msec
->output_section
->vma
+ msec
->output_offset
;
2616 value
= (value
& ~howto
->dst_mask
) | (addend
& howto
->dst_mask
);
2617 score_bfd_put_32 (input_bfd
, value
, contents
+ rel
->r_offset
);
2624 /* For global symbols we look up the symbol in the hash-table. */
2625 h
= ((struct score_elf_link_hash_entry
*)
2626 elf_sym_hashes (input_bfd
) [r_symndx
- extsymoff
]);
2627 /* Find the real hash-table entry for this symbol. */
2628 while (h
->root
.root
.type
== bfd_link_hash_indirect
2629 || h
->root
.root
.type
== bfd_link_hash_warning
)
2630 h
= (struct score_elf_link_hash_entry
*) h
->root
.root
.u
.i
.link
;
2632 /* Record the name of this symbol, for our caller. */
2633 name
= h
->root
.root
.root
.string
;
2635 /* See if this is the special GP_DISP_LABEL symbol. Note that such a
2636 symbol must always be a global symbol. */
2637 if (strcmp (name
, GP_DISP_LABEL
) == 0)
2639 /* Relocations against GP_DISP_LABEL are permitted only with
2640 R_SCORE_HI16 and R_SCORE_LO16 relocations. */
2641 if (r_type
!= R_SCORE_HI16
&& r_type
!= R_SCORE_LO16
)
2642 return bfd_reloc_notsupported
;
2647 /* If this symbol is defined, calculate its address. Note that
2648 GP_DISP_LABEL is a magic symbol, always implicitly defined by the
2649 linker, so it's inappropriate to check to see whether or not
2651 else if ((h
->root
.root
.type
== bfd_link_hash_defined
2652 || h
->root
.root
.type
== bfd_link_hash_defweak
)
2653 && h
->root
.root
.u
.def
.section
)
2655 sec
= h
->root
.root
.u
.def
.section
;
2656 if (sec
->output_section
)
2657 relocation
= (h
->root
.root
.u
.def
.value
2658 + sec
->output_section
->vma
2659 + sec
->output_offset
);
2662 relocation
= h
->root
.root
.u
.def
.value
;
2665 else if (h
->root
.root
.type
== bfd_link_hash_undefweak
)
2666 /* We allow relocations against undefined weak symbols, giving
2667 it the value zero, so that you can undefined weak functions
2668 and check to see if they exist by looking at their addresses. */
2670 else if (info
->unresolved_syms_in_objects
== RM_IGNORE
2671 && ELF_ST_VISIBILITY (h
->root
.other
) == STV_DEFAULT
)
2673 else if (strcmp (name
, "_DYNAMIC_LINK") == 0)
2675 /* If this is a dynamic link, we should have created a _DYNAMIC_LINK symbol
2676 in s3_bfd_score_elf_create_dynamic_sections. Otherwise, we should define
2677 the symbol with a value of 0. */
2678 BFD_ASSERT (! info
->shared
);
2679 BFD_ASSERT (bfd_get_section_by_name (output_bfd
, ".dynamic") == NULL
);
2682 else if (!info
->relocatable
)
2684 if (! ((*info
->callbacks
->undefined_symbol
)
2685 (info
, h
->root
.root
.root
.string
, input_bfd
,
2686 input_section
, rel
->r_offset
,
2687 (info
->unresolved_syms_in_objects
== RM_GENERATE_ERROR
)
2688 || ELF_ST_VISIBILITY (h
->root
.other
))))
2689 return bfd_reloc_undefined
;
2694 if (sec
!= NULL
&& elf_discarded_section (sec
))
2696 /* For relocs against symbols from removed linkonce sections,
2697 or sections discarded by a linker script, we just want the
2698 section contents zeroed. Avoid any special processing. */
2699 _bfd_clear_contents (howto
, input_bfd
, contents
+ rel
->r_offset
);
2705 if (info
->relocatable
)
2707 /* This is a relocatable link. We don't have to change
2708 anything, unless the reloc is against a section symbol,
2709 in which case we have to adjust according to where the
2710 section symbol winds up in the output section. */
2711 if (r_symndx
< symtab_hdr
->sh_info
)
2713 sym
= local_syms
+ r_symndx
;
2714 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
2716 sec
= local_sections
[r_symndx
];
2717 score_elf_add_to_rel (input_bfd
, contents
+ rel
->r_offset
,
2718 howto
, (bfd_signed_vma
) (sec
->output_offset
+ sym
->st_value
));
2724 /* This is a final link. */
2725 r
= score_elf_final_link_relocate (howto
, input_bfd
, output_bfd
,
2726 input_section
, contents
, rel
, relocs
,
2727 relocation
, info
, name
,
2728 (h
? ELF_ST_TYPE ((unsigned int)h
->root
.root
.type
) :
2729 ELF_ST_TYPE ((unsigned int)sym
->st_info
)), h
, local_sections
,
2732 if (r
!= bfd_reloc_ok
)
2734 const char *msg
= (const char *)0;
2738 case bfd_reloc_overflow
:
2739 /* If the overflowing reloc was to an undefined symbol,
2740 we have already printed one error message and there
2741 is no point complaining again. */
2742 if (((!h
) || (h
->root
.root
.type
!= bfd_link_hash_undefined
))
2743 && (!((*info
->callbacks
->reloc_overflow
)
2744 (info
, NULL
, name
, howto
->name
, (bfd_vma
) 0,
2745 input_bfd
, input_section
, rel
->r_offset
))))
2748 case bfd_reloc_undefined
:
2749 if (!((*info
->callbacks
->undefined_symbol
)
2750 (info
, name
, input_bfd
, input_section
, rel
->r_offset
, TRUE
)))
2754 case bfd_reloc_outofrange
:
2755 msg
= _("internal error: out of range error");
2758 case bfd_reloc_notsupported
:
2759 msg
= _("internal error: unsupported relocation error");
2762 case bfd_reloc_dangerous
:
2763 msg
= _("internal error: dangerous error");
2766 /* Use bfd_reloc_other to check lw48, sw48 word align. */
2767 case bfd_reloc_other
:
2768 msg
= _("address not word align");
2772 msg
= _("internal error: unknown error");
2776 if (!((*info
->callbacks
->warning
)
2777 (info
, msg
, name
, input_bfd
, input_section
, rel
->r_offset
)))
2787 /* Look through the relocs for a section during the first phase, and
2788 allocate space in the global offset table. */
2790 s3_bfd_score_elf_check_relocs (bfd
*abfd
,
2791 struct bfd_link_info
*info
,
2793 const Elf_Internal_Rela
*relocs
)
2797 Elf_Internal_Shdr
*symtab_hdr
;
2798 struct elf_link_hash_entry
**sym_hashes
;
2799 struct score_got_info
*g
;
2801 const Elf_Internal_Rela
*rel
;
2802 const Elf_Internal_Rela
*rel_end
;
2805 const struct elf_backend_data
*bed
;
2807 if (info
->relocatable
)
2810 dynobj
= elf_hash_table (info
)->dynobj
;
2811 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2812 sym_hashes
= elf_sym_hashes (abfd
);
2813 extsymoff
= (elf_bad_symtab (abfd
)) ? 0 : symtab_hdr
->sh_info
;
2815 name
= bfd_get_section_name (abfd
, sec
);
2824 sgot
= score_elf_got_section (dynobj
, FALSE
);
2829 BFD_ASSERT (score_elf_section_data (sgot
) != NULL
);
2830 g
= score_elf_section_data (sgot
)->u
.got_info
;
2831 BFD_ASSERT (g
!= NULL
);
2836 bed
= get_elf_backend_data (abfd
);
2837 rel_end
= relocs
+ sec
->reloc_count
* bed
->s
->int_rels_per_ext_rel
;
2838 for (rel
= relocs
; rel
< rel_end
; ++rel
)
2840 unsigned long r_symndx
;
2841 unsigned int r_type
;
2842 struct elf_link_hash_entry
*h
;
2844 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2845 r_type
= ELF32_R_TYPE (rel
->r_info
);
2847 if (r_symndx
< extsymoff
)
2851 else if (r_symndx
>= extsymoff
+ NUM_SHDR_ENTRIES (symtab_hdr
))
2853 (*_bfd_error_handler
) (_("%s: Malformed reloc detected for section %s"), abfd
, name
);
2854 bfd_set_error (bfd_error_bad_value
);
2859 h
= sym_hashes
[r_symndx
- extsymoff
];
2861 /* This may be an indirect symbol created because of a version. */
2864 while (h
->root
.type
== bfd_link_hash_indirect
)
2865 h
= (struct elf_link_hash_entry
*)h
->root
.u
.i
.link
;
2869 /* Some relocs require a global offset table. */
2870 if (dynobj
== NULL
|| sgot
== NULL
)
2875 case R_SCORE_CALL15
:
2877 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
2878 if (!score_elf_create_got_section (dynobj
, info
, FALSE
))
2880 g
= score_elf_got_info (dynobj
, &sgot
);
2884 if (dynobj
== NULL
&& (info
->shared
|| h
!= NULL
) && (sec
->flags
& SEC_ALLOC
) != 0)
2885 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
2892 if (!h
&& (r_type
== R_SCORE_GOT_LO16
))
2894 if (! score_elf_record_local_got_symbol (abfd
, r_symndx
, rel
->r_addend
, g
))
2900 case R_SCORE_CALL15
:
2903 (*_bfd_error_handler
)
2904 (_("%B: CALL15 reloc at 0x%lx not against global symbol"),
2905 abfd
, (unsigned long) rel
->r_offset
);
2906 bfd_set_error (bfd_error_bad_value
);
2911 /* This symbol requires a global offset table entry. */
2912 if (! score_elf_record_global_got_symbol (h
, abfd
, info
, g
))
2915 /* We need a stub, not a plt entry for the undefined function. But we record
2916 it as if it needs plt. See _bfd_elf_adjust_dynamic_symbol. */
2922 if (h
&& ! score_elf_record_global_got_symbol (h
, abfd
, info
, g
))
2927 if ((info
->shared
|| h
!= NULL
) && (sec
->flags
& SEC_ALLOC
) != 0)
2931 sreloc
= score_elf_rel_dyn_section (dynobj
, TRUE
);
2935 #define SCORE_READONLY_SECTION (SEC_ALLOC | SEC_LOAD | SEC_READONLY)
2938 /* When creating a shared object, we must copy these reloc types into
2939 the output file as R_SCORE_REL32 relocs. We make room for this reloc
2940 in the .rel.dyn reloc section. */
2941 score_elf_allocate_dynamic_relocations (dynobj
, 1);
2942 if ((sec
->flags
& SCORE_READONLY_SECTION
)
2943 == SCORE_READONLY_SECTION
)
2944 /* We tell the dynamic linker that there are
2945 relocations against the text segment. */
2946 info
->flags
|= DF_TEXTREL
;
2950 struct score_elf_link_hash_entry
*hscore
;
2952 /* We only need to copy this reloc if the symbol is
2953 defined in a dynamic object. */
2954 hscore
= (struct score_elf_link_hash_entry
*)h
;
2955 ++hscore
->possibly_dynamic_relocs
;
2956 if ((sec
->flags
& SCORE_READONLY_SECTION
)
2957 == SCORE_READONLY_SECTION
)
2958 /* We need it to tell the dynamic linker if there
2959 are relocations against the text segment. */
2960 hscore
->readonly_reloc
= TRUE
;
2963 /* Even though we don't directly need a GOT entry for this symbol,
2964 a symbol must have a dynamic symbol table index greater that
2965 DT_SCORE_GOTSYM if there are dynamic relocations against it. */
2969 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
2970 if (! score_elf_create_got_section (dynobj
, info
, TRUE
))
2972 g
= score_elf_got_info (dynobj
, &sgot
);
2973 if (! score_elf_record_global_got_symbol (h
, abfd
, info
, g
))
2979 /* This relocation describes the C++ object vtable hierarchy.
2980 Reconstruct it for later use during GC. */
2981 case R_SCORE_GNU_VTINHERIT
:
2982 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
2986 /* This relocation describes which C++ vtable entries are actually
2987 used. Record for later use during GC. */
2988 case R_SCORE_GNU_VTENTRY
:
2989 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_offset
))
2996 /* We must not create a stub for a symbol that has relocations
2997 related to taking the function's address. */
3003 struct score_elf_link_hash_entry
*sh
;
3005 sh
= (struct score_elf_link_hash_entry
*) h
;
3006 sh
->no_fn_stub
= TRUE
;
3009 case R_SCORE_CALL15
:
3018 s3_bfd_score_elf_add_symbol_hook (bfd
*abfd
,
3019 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
3020 Elf_Internal_Sym
*sym
,
3021 const char **namep ATTRIBUTE_UNUSED
,
3022 flagword
*flagsp ATTRIBUTE_UNUSED
,
3026 switch (sym
->st_shndx
)
3029 if (sym
->st_size
> elf_gp_size (abfd
))
3032 case SHN_SCORE_SCOMMON
:
3033 *secp
= bfd_make_section_old_way (abfd
, ".scommon");
3034 (*secp
)->flags
|= SEC_IS_COMMON
;
3035 *valp
= sym
->st_size
;
3043 s3_bfd_score_elf_symbol_processing (bfd
*abfd
, asymbol
*asym
)
3045 elf_symbol_type
*elfsym
;
3047 elfsym
= (elf_symbol_type
*) asym
;
3048 switch (elfsym
->internal_elf_sym
.st_shndx
)
3051 if (asym
->value
> elf_gp_size (abfd
))
3054 case SHN_SCORE_SCOMMON
:
3055 if (score_elf_scom_section
.name
== NULL
)
3057 /* Initialize the small common section. */
3058 score_elf_scom_section
.name
= ".scommon";
3059 score_elf_scom_section
.flags
= SEC_IS_COMMON
;
3060 score_elf_scom_section
.output_section
= &score_elf_scom_section
;
3061 score_elf_scom_section
.symbol
= &score_elf_scom_symbol
;
3062 score_elf_scom_section
.symbol_ptr_ptr
= &score_elf_scom_symbol_ptr
;
3063 score_elf_scom_symbol
.name
= ".scommon";
3064 score_elf_scom_symbol
.flags
= BSF_SECTION_SYM
;
3065 score_elf_scom_symbol
.section
= &score_elf_scom_section
;
3066 score_elf_scom_symbol_ptr
= &score_elf_scom_symbol
;
3068 asym
->section
= &score_elf_scom_section
;
3069 asym
->value
= elfsym
->internal_elf_sym
.st_size
;
3075 s3_bfd_score_elf_link_output_symbol_hook (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
3076 const char *name ATTRIBUTE_UNUSED
,
3077 Elf_Internal_Sym
*sym
,
3078 asection
*input_sec
,
3079 struct elf_link_hash_entry
*h ATTRIBUTE_UNUSED
)
3081 /* If we see a common symbol, which implies a relocatable link, then
3082 if a symbol was small common in an input file, mark it as small
3083 common in the output file. */
3084 if (sym
->st_shndx
== SHN_COMMON
&& strcmp (input_sec
->name
, ".scommon") == 0)
3085 sym
->st_shndx
= SHN_SCORE_SCOMMON
;
3091 s3_bfd_score_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
3095 if (strcmp (bfd_get_section_name (abfd
, sec
), ".scommon") == 0)
3097 *retval
= SHN_SCORE_SCOMMON
;
3104 /* Adjust a symbol defined by a dynamic object and referenced by a
3105 regular object. The current definition is in some section of the
3106 dynamic object, but we're not including those sections. We have to
3107 change the definition to something the rest of the link can understand. */
3109 s3_bfd_score_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
3110 struct elf_link_hash_entry
*h
)
3113 struct score_elf_link_hash_entry
*hscore
;
3116 dynobj
= elf_hash_table (info
)->dynobj
;
3118 /* Make sure we know what is going on here. */
3119 BFD_ASSERT (dynobj
!= NULL
3121 || h
->u
.weakdef
!= NULL
3122 || (h
->def_dynamic
&& h
->ref_regular
&& !h
->def_regular
)));
3124 /* If this symbol is defined in a dynamic object, we need to copy
3125 any R_SCORE_ABS32 or R_SCORE_REL32 relocs against it into the output
3127 hscore
= (struct score_elf_link_hash_entry
*)h
;
3128 if (!info
->relocatable
3129 && hscore
->possibly_dynamic_relocs
!= 0
3130 && (h
->root
.type
== bfd_link_hash_defweak
|| !h
->def_regular
))
3132 score_elf_allocate_dynamic_relocations (dynobj
, hscore
->possibly_dynamic_relocs
);
3133 if (hscore
->readonly_reloc
)
3134 /* We tell the dynamic linker that there are relocations
3135 against the text segment. */
3136 info
->flags
|= DF_TEXTREL
;
3139 /* For a function, create a stub, if allowed. */
3140 if (!hscore
->no_fn_stub
&& h
->needs_plt
)
3142 if (!elf_hash_table (info
)->dynamic_sections_created
)
3145 /* If this symbol is not defined in a regular file, then set
3146 the symbol to the stub location. This is required to make
3147 function pointers compare as equal between the normal
3148 executable and the shared library. */
3149 if (!h
->def_regular
)
3151 /* We need .stub section. */
3152 s
= bfd_get_section_by_name (dynobj
, SCORE_ELF_STUB_SECTION_NAME
);
3153 BFD_ASSERT (s
!= NULL
);
3155 h
->root
.u
.def
.section
= s
;
3156 h
->root
.u
.def
.value
= s
->size
;
3158 /* XXX Write this stub address somewhere. */
3159 h
->plt
.offset
= s
->size
;
3161 /* Make room for this stub code. */
3162 s
->size
+= SCORE_FUNCTION_STUB_SIZE
;
3164 /* The last half word of the stub will be filled with the index
3165 of this symbol in .dynsym section. */
3169 else if ((h
->type
== STT_FUNC
) && !h
->needs_plt
)
3171 /* This will set the entry for this symbol in the GOT to 0, and
3172 the dynamic linker will take care of this. */
3173 h
->root
.u
.def
.value
= 0;
3177 /* If this is a weak symbol, and there is a real definition, the
3178 processor independent code will have arranged for us to see the
3179 real definition first, and we can just use the same value. */
3180 if (h
->u
.weakdef
!= NULL
)
3182 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
3183 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
3184 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
3185 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
3189 /* This is a reference to a symbol defined by a dynamic object which
3190 is not a function. */
3194 /* This function is called after all the input files have been read,
3195 and the input sections have been assigned to output sections. */
3197 s3_bfd_score_elf_always_size_sections (bfd
*output_bfd
,
3198 struct bfd_link_info
*info
)
3202 struct score_got_info
*g
;
3204 bfd_size_type loadable_size
= 0;
3205 bfd_size_type local_gotno
;
3208 dynobj
= elf_hash_table (info
)->dynobj
;
3210 /* Relocatable links don't have it. */
3213 g
= score_elf_got_info (dynobj
, &s
);
3217 /* Calculate the total loadable size of the output. That will give us the
3218 maximum number of GOT_PAGE entries required. */
3219 for (sub
= info
->input_bfds
; sub
; sub
= sub
->link_next
)
3221 asection
*subsection
;
3223 for (subsection
= sub
->sections
;
3225 subsection
= subsection
->next
)
3227 if ((subsection
->flags
& SEC_ALLOC
) == 0)
3229 loadable_size
+= ((subsection
->size
+ 0xf)
3230 &~ (bfd_size_type
) 0xf);
3234 /* There has to be a global GOT entry for every symbol with
3235 a dynamic symbol table index of DT_SCORE_GOTSYM or
3236 higher. Therefore, it make sense to put those symbols
3237 that need GOT entries at the end of the symbol table. We
3239 if (! score_elf_sort_hash_table (info
, 1))
3242 if (g
->global_gotsym
!= NULL
)
3243 i
= elf_hash_table (info
)->dynsymcount
- g
->global_gotsym
->dynindx
;
3245 /* If there are no global symbols, or none requiring
3246 relocations, then GLOBAL_GOTSYM will be NULL. */
3249 /* In the worst case, we'll get one stub per dynamic symbol. */
3250 loadable_size
+= SCORE_FUNCTION_STUB_SIZE
* i
;
3252 /* Assume there are two loadable segments consisting of
3253 contiguous sections. Is 5 enough? */
3254 local_gotno
= (loadable_size
>> 16) + 5;
3256 g
->local_gotno
+= local_gotno
;
3257 s
->size
+= g
->local_gotno
* SCORE_ELF_GOT_SIZE (output_bfd
);
3259 g
->global_gotno
= i
;
3260 s
->size
+= i
* SCORE_ELF_GOT_SIZE (output_bfd
);
3262 score_elf_resolve_final_got_entries (g
);
3264 if (s
->size
> SCORE_ELF_GOT_MAX_SIZE (output_bfd
))
3266 /* Fixme. Error message or Warning message should be issued here. */
3272 /* Set the sizes of the dynamic sections. */
3274 s3_bfd_score_elf_size_dynamic_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
3278 bfd_boolean reltext
;
3280 dynobj
= elf_hash_table (info
)->dynobj
;
3281 BFD_ASSERT (dynobj
!= NULL
);
3283 if (elf_hash_table (info
)->dynamic_sections_created
)
3285 /* Set the contents of the .interp section to the interpreter. */
3288 s
= bfd_get_section_by_name (dynobj
, ".interp");
3289 BFD_ASSERT (s
!= NULL
);
3290 s
->size
= strlen (ELF_DYNAMIC_INTERPRETER
) + 1;
3291 s
->contents
= (bfd_byte
*) ELF_DYNAMIC_INTERPRETER
;
3295 /* The check_relocs and adjust_dynamic_symbol entry points have
3296 determined the sizes of the various dynamic sections. Allocate
3299 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
3303 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
3306 /* It's OK to base decisions on the section name, because none
3307 of the dynobj section names depend upon the input files. */
3308 name
= bfd_get_section_name (dynobj
, s
);
3310 if (CONST_STRNEQ (name
, ".rel"))
3314 /* We only strip the section if the output section name
3315 has the same name. Otherwise, there might be several
3316 input sections for this output section. FIXME: This
3317 code is probably not needed these days anyhow, since
3318 the linker now does not create empty output sections. */
3319 if (s
->output_section
!= NULL
3321 bfd_get_section_name (s
->output_section
->owner
,
3322 s
->output_section
)) == 0)
3323 s
->flags
|= SEC_EXCLUDE
;
3327 const char *outname
;
3330 /* If this relocation section applies to a read only
3331 section, then we probably need a DT_TEXTREL entry.
3332 If the relocation section is .rel.dyn, we always
3333 assert a DT_TEXTREL entry rather than testing whether
3334 there exists a relocation to a read only section or
3336 outname
= bfd_get_section_name (output_bfd
, s
->output_section
);
3337 target
= bfd_get_section_by_name (output_bfd
, outname
+ 4);
3339 && (target
->flags
& SEC_READONLY
) != 0
3340 && (target
->flags
& SEC_ALLOC
) != 0) || strcmp (outname
, ".rel.dyn") == 0)
3343 /* We use the reloc_count field as a counter if we need
3344 to copy relocs into the output file. */
3345 if (strcmp (name
, ".rel.dyn") != 0)
3349 else if (CONST_STRNEQ (name
, ".got"))
3351 /* s3_bfd_score_elf_always_size_sections() has already done
3352 most of the work, but some symbols may have been mapped
3353 to versions that we must now resolve in the got_entries
3356 else if (strcmp (name
, SCORE_ELF_STUB_SECTION_NAME
) == 0)
3358 /* IRIX rld assumes that the function stub isn't at the end
3359 of .text section. So put a dummy. XXX */
3360 s
->size
+= SCORE_FUNCTION_STUB_SIZE
;
3362 else if (! CONST_STRNEQ (name
, ".init"))
3364 /* It's not one of our sections, so don't allocate space. */
3368 /* Allocate memory for the section contents. */
3369 s
->contents
= bfd_zalloc (dynobj
, s
->size
);
3370 if (s
->contents
== NULL
&& s
->size
!= 0)
3372 bfd_set_error (bfd_error_no_memory
);
3377 if (elf_hash_table (info
)->dynamic_sections_created
)
3379 /* Add some entries to the .dynamic section. We fill in the
3380 values later, in s3_bfd_score_elf_finish_dynamic_sections, but we
3381 must add the entries now so that we get the correct size for
3382 the .dynamic section. The DT_DEBUG entry is filled in by the
3383 dynamic linker and used by the debugger. */
3385 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info
, DT_DEBUG
, 0))
3389 info
->flags
|= DF_TEXTREL
;
3391 if ((info
->flags
& DF_TEXTREL
) != 0)
3393 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info
, DT_TEXTREL
, 0))
3397 if (! SCORE_ELF_ADD_DYNAMIC_ENTRY (info
, DT_PLTGOT
, 0))
3400 if (score_elf_rel_dyn_section (dynobj
, FALSE
))
3402 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info
, DT_REL
, 0))
3405 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELSZ
, 0))
3408 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info
, DT_RELENT
, 0))
3412 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info
, DT_SCORE_BASE_ADDRESS
, 0))
3415 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info
, DT_SCORE_LOCAL_GOTNO
, 0))
3418 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info
, DT_SCORE_SYMTABNO
, 0))
3421 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info
, DT_SCORE_UNREFEXTNO
, 0))
3424 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info
, DT_SCORE_GOTSYM
, 0))
3427 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info
, DT_SCORE_HIPAGENO
, 0))
3435 s3_bfd_score_elf_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3437 struct elf_link_hash_entry
*h
;
3438 struct bfd_link_hash_entry
*bh
;
3442 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
3443 | SEC_LINKER_CREATED
| SEC_READONLY
);
3445 /* ABI requests the .dynamic section to be read only. */
3446 s
= bfd_get_section_by_name (abfd
, ".dynamic");
3449 if (!bfd_set_section_flags (abfd
, s
, flags
))
3453 /* We need to create .got section. */
3454 if (!score_elf_create_got_section (abfd
, info
, FALSE
))
3457 if (!score_elf_rel_dyn_section (elf_hash_table (info
)->dynobj
, TRUE
))
3460 /* Create .stub section. */
3461 if (bfd_get_section_by_name (abfd
, SCORE_ELF_STUB_SECTION_NAME
) == NULL
)
3463 s
= bfd_make_section_with_flags (abfd
, SCORE_ELF_STUB_SECTION_NAME
,
3466 || !bfd_set_section_alignment (abfd
, s
, 2))
3475 name
= "_DYNAMIC_LINK";
3477 if (!(_bfd_generic_link_add_one_symbol
3478 (info
, abfd
, name
, BSF_GLOBAL
, bfd_abs_section_ptr
,
3479 (bfd_vma
) 0, NULL
, FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
3482 h
= (struct elf_link_hash_entry
*)bh
;
3485 h
->type
= STT_SECTION
;
3487 if (!bfd_elf_link_record_dynamic_symbol (info
, h
))
3495 /* Finish up dynamic symbol handling. We set the contents of various
3496 dynamic sections here. */
3498 s3_bfd_score_elf_finish_dynamic_symbol (bfd
*output_bfd
,
3499 struct bfd_link_info
*info
,
3500 struct elf_link_hash_entry
*h
,
3501 Elf_Internal_Sym
*sym
)
3505 struct score_got_info
*g
;
3508 dynobj
= elf_hash_table (info
)->dynobj
;
3510 if (h
->plt
.offset
!= MINUS_ONE
)
3513 bfd_byte stub
[SCORE_FUNCTION_STUB_SIZE
];
3515 /* This symbol has a stub. Set it up. */
3516 BFD_ASSERT (h
->dynindx
!= -1);
3518 s
= bfd_get_section_by_name (dynobj
, SCORE_ELF_STUB_SECTION_NAME
);
3519 BFD_ASSERT (s
!= NULL
);
3521 /* FIXME: Can h->dynindex be more than 64K? */
3522 if (h
->dynindx
& 0xffff0000)
3525 /* Fill the stub. */
3526 score_bfd_put_32 (output_bfd
, STUB_LW
, stub
);
3527 score_bfd_put_32 (output_bfd
, STUB_MOVE
, stub
+ 4);
3528 score_bfd_put_32 (output_bfd
, STUB_LI16
| (h
->dynindx
<< 1), stub
+ 8);
3529 score_bfd_put_32 (output_bfd
, STUB_BRL
, stub
+ 12);
3531 BFD_ASSERT (h
->plt
.offset
<= s
->size
);
3532 memcpy (s
->contents
+ h
->plt
.offset
, stub
, SCORE_FUNCTION_STUB_SIZE
);
3534 /* Mark the symbol as undefined. plt.offset != -1 occurs
3535 only for the referenced symbol. */
3536 sym
->st_shndx
= SHN_UNDEF
;
3538 /* The run-time linker uses the st_value field of the symbol
3539 to reset the global offset table entry for this external
3540 to its stub address when unlinking a shared object. */
3541 sym
->st_value
= (s
->output_section
->vma
+ s
->output_offset
+ h
->plt
.offset
);
3544 BFD_ASSERT (h
->dynindx
!= -1 || h
->forced_local
);
3546 sgot
= score_elf_got_section (dynobj
, FALSE
);
3547 BFD_ASSERT (sgot
!= NULL
);
3548 BFD_ASSERT (score_elf_section_data (sgot
) != NULL
);
3549 g
= score_elf_section_data (sgot
)->u
.got_info
;
3550 BFD_ASSERT (g
!= NULL
);
3552 /* Run through the global symbol table, creating GOT entries for all
3553 the symbols that need them. */
3554 if (g
->global_gotsym
!= NULL
&& h
->dynindx
>= g
->global_gotsym
->dynindx
)
3559 value
= sym
->st_value
;
3560 offset
= score_elf_global_got_index (dynobj
, h
);
3561 score_bfd_put_32 (output_bfd
, value
, sgot
->contents
+ offset
);
3564 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3565 name
= h
->root
.root
.string
;
3566 if (strcmp (name
, "_DYNAMIC") == 0 || strcmp (name
, "_GLOBAL_OFFSET_TABLE_") == 0)
3567 sym
->st_shndx
= SHN_ABS
;
3568 else if (strcmp (name
, "_DYNAMIC_LINK") == 0)
3570 sym
->st_shndx
= SHN_ABS
;
3571 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
3574 else if (strcmp (name
, GP_DISP_LABEL
) == 0)
3576 sym
->st_shndx
= SHN_ABS
;
3577 sym
->st_info
= ELF_ST_INFO (STB_GLOBAL
, STT_SECTION
);
3578 sym
->st_value
= elf_gp (output_bfd
);
3584 /* Finish up the dynamic sections. */
3586 s3_bfd_score_elf_finish_dynamic_sections (bfd
*output_bfd
,
3587 struct bfd_link_info
*info
)
3593 struct score_got_info
*g
;
3595 dynobj
= elf_hash_table (info
)->dynobj
;
3597 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
3599 sgot
= score_elf_got_section (dynobj
, FALSE
);
3604 BFD_ASSERT (score_elf_section_data (sgot
) != NULL
);
3605 g
= score_elf_section_data (sgot
)->u
.got_info
;
3606 BFD_ASSERT (g
!= NULL
);
3609 if (elf_hash_table (info
)->dynamic_sections_created
)
3613 BFD_ASSERT (sdyn
!= NULL
);
3614 BFD_ASSERT (g
!= NULL
);
3616 for (b
= sdyn
->contents
;
3617 b
< sdyn
->contents
+ sdyn
->size
;
3618 b
+= SCORE_ELF_DYN_SIZE (dynobj
))
3620 Elf_Internal_Dyn dyn
;
3623 bfd_boolean swap_out_p
;
3625 /* Read in the current dynamic entry. */
3626 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_in
) (dynobj
, b
, &dyn
);
3628 /* Assume that we're going to modify it and write it out. */
3634 s
= score_elf_rel_dyn_section (dynobj
, FALSE
);
3635 BFD_ASSERT (s
!= NULL
);
3636 dyn
.d_un
.d_val
= SCORE_ELF_REL_SIZE (dynobj
);
3640 /* Rewrite DT_STRSZ. */
3641 dyn
.d_un
.d_val
= _bfd_elf_strtab_size (elf_hash_table (info
)->dynstr
);
3646 s
= bfd_get_section_by_name (output_bfd
, name
);
3647 BFD_ASSERT (s
!= NULL
);
3648 dyn
.d_un
.d_ptr
= s
->vma
;
3651 case DT_SCORE_BASE_ADDRESS
:
3652 s
= output_bfd
->sections
;
3653 BFD_ASSERT (s
!= NULL
);
3654 dyn
.d_un
.d_ptr
= s
->vma
& ~(bfd_vma
) 0xffff;
3657 case DT_SCORE_LOCAL_GOTNO
:
3658 dyn
.d_un
.d_val
= g
->local_gotno
;
3661 case DT_SCORE_UNREFEXTNO
:
3662 /* The index into the dynamic symbol table which is the
3663 entry of the first external symbol that is not
3664 referenced within the same object. */
3665 dyn
.d_un
.d_val
= bfd_count_sections (output_bfd
) + 1;
3668 case DT_SCORE_GOTSYM
:
3669 if (g
->global_gotsym
)
3671 dyn
.d_un
.d_val
= g
->global_gotsym
->dynindx
;
3674 /* In case if we don't have global got symbols we default
3675 to setting DT_SCORE_GOTSYM to the same value as
3676 DT_SCORE_SYMTABNO, so we just fall through. */
3678 case DT_SCORE_SYMTABNO
:
3680 elemsize
= SCORE_ELF_SYM_SIZE (output_bfd
);
3681 s
= bfd_get_section_by_name (output_bfd
, name
);
3682 BFD_ASSERT (s
!= NULL
);
3684 dyn
.d_un
.d_val
= s
->size
/ elemsize
;
3687 case DT_SCORE_HIPAGENO
:
3688 dyn
.d_un
.d_val
= g
->local_gotno
- SCORE_RESERVED_GOTNO
;
3697 (*get_elf_backend_data (dynobj
)->s
->swap_dyn_out
) (dynobj
, &dyn
, b
);
3701 /* The first entry of the global offset table will be filled at
3702 runtime. The second entry will be used by some runtime loaders.
3703 This isn't the case of IRIX rld. */
3704 if (sgot
!= NULL
&& sgot
->size
> 0)
3706 score_bfd_put_32 (output_bfd
, 0, sgot
->contents
);
3707 score_bfd_put_32 (output_bfd
, 0x80000000, sgot
->contents
+ SCORE_ELF_GOT_SIZE (output_bfd
));
3711 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
3712 = SCORE_ELF_GOT_SIZE (output_bfd
);
3715 /* We need to sort the entries of the dynamic relocation section. */
3716 s
= score_elf_rel_dyn_section (dynobj
, FALSE
);
3718 if (s
!= NULL
&& s
->size
> (bfd_vma
)2 * SCORE_ELF_REL_SIZE (output_bfd
))
3720 reldyn_sorting_bfd
= output_bfd
;
3721 qsort ((Elf32_External_Rel
*) s
->contents
+ 1, s
->reloc_count
- 1,
3722 sizeof (Elf32_External_Rel
), score_elf_sort_dynamic_relocs
);
3728 /* This function set up the ELF section header for a BFD section in preparation for writing
3729 it out. This is where the flags and type fields are set for unusual sections. */
3731 s3_bfd_score_elf_fake_sections (bfd
*abfd ATTRIBUTE_UNUSED
,
3732 Elf_Internal_Shdr
*hdr
,
3737 name
= bfd_get_section_name (abfd
, sec
);
3739 if (strcmp (name
, ".got") == 0
3740 || strcmp (name
, ".srdata") == 0
3741 || strcmp (name
, ".sdata") == 0
3742 || strcmp (name
, ".sbss") == 0)
3743 hdr
->sh_flags
|= SHF_SCORE_GPREL
;
3748 /* This function do additional processing on the ELF section header before writing
3749 it out. This is used to set the flags and type fields for some sections. */
3751 /* assign_file_positions_except_relocs() check section flag and if it is allocatable,
3752 warning message will be issued. backend_fake_section is called before
3753 assign_file_positions_except_relocs(); backend_section_processing after it. so, we
3754 modify section flag there, but not backend_fake_section. */
3756 s3_bfd_score_elf_section_processing (bfd
*abfd ATTRIBUTE_UNUSED
, Elf_Internal_Shdr
*hdr
)
3758 if (hdr
->bfd_section
!= NULL
)
3760 const char *name
= bfd_get_section_name (abfd
, hdr
->bfd_section
);
3762 if (strcmp (name
, ".sdata") == 0)
3764 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_SCORE_GPREL
;
3765 hdr
->sh_type
= SHT_PROGBITS
;
3767 else if (strcmp (name
, ".sbss") == 0)
3769 hdr
->sh_flags
|= SHF_ALLOC
| SHF_WRITE
| SHF_SCORE_GPREL
;
3770 hdr
->sh_type
= SHT_NOBITS
;
3772 else if (strcmp (name
, ".srdata") == 0)
3774 hdr
->sh_flags
|= SHF_ALLOC
| SHF_SCORE_GPREL
;
3775 hdr
->sh_type
= SHT_PROGBITS
;
3783 s3_bfd_score_elf_write_section (bfd
*output_bfd
, asection
*sec
, bfd_byte
*contents
)
3785 bfd_byte
*to
, *from
, *end
;
3788 if (strcmp (sec
->name
, ".pdr") != 0)
3791 if (score_elf_section_data (sec
)->u
.tdata
== NULL
)
3795 end
= contents
+ sec
->size
;
3796 for (from
= contents
, i
= 0; from
< end
; from
+= PDR_SIZE
, i
++)
3798 if ((score_elf_section_data (sec
)->u
.tdata
)[i
] == 1)
3802 memcpy (to
, from
, PDR_SIZE
);
3806 bfd_set_section_contents (output_bfd
, sec
->output_section
, contents
,
3807 (file_ptr
) sec
->output_offset
, sec
->size
);
3812 /* Copy data from a SCORE ELF indirect symbol to its direct symbol, hiding the old
3813 indirect symbol. Process additional relocation information. */
3815 s3_bfd_score_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
3816 struct elf_link_hash_entry
*dir
,
3817 struct elf_link_hash_entry
*ind
)
3819 struct score_elf_link_hash_entry
*dirscore
, *indscore
;
3821 _bfd_elf_link_hash_copy_indirect (info
, dir
, ind
);
3823 if (ind
->root
.type
!= bfd_link_hash_indirect
)
3826 dirscore
= (struct score_elf_link_hash_entry
*) dir
;
3827 indscore
= (struct score_elf_link_hash_entry
*) ind
;
3828 dirscore
->possibly_dynamic_relocs
+= indscore
->possibly_dynamic_relocs
;
3830 if (indscore
->readonly_reloc
)
3831 dirscore
->readonly_reloc
= TRUE
;
3833 if (indscore
->no_fn_stub
)
3834 dirscore
->no_fn_stub
= TRUE
;
3837 /* Remove information about discarded functions from other sections which mention them. */
3839 s3_bfd_score_elf_discard_info (bfd
*abfd
, struct elf_reloc_cookie
*cookie
,
3840 struct bfd_link_info
*info
)
3843 bfd_boolean ret
= FALSE
;
3844 unsigned char *tdata
;
3847 o
= bfd_get_section_by_name (abfd
, ".pdr");
3848 if ((!o
) || (o
->size
== 0) || (o
->size
% PDR_SIZE
!= 0)
3849 || (o
->output_section
!= NULL
&& bfd_is_abs_section (o
->output_section
)))
3852 tdata
= bfd_zmalloc (o
->size
/ PDR_SIZE
);
3856 cookie
->rels
= _bfd_elf_link_read_relocs (abfd
, o
, NULL
, NULL
, info
->keep_memory
);
3863 cookie
->rel
= cookie
->rels
;
3864 cookie
->relend
= cookie
->rels
+ o
->reloc_count
;
3866 for (i
= 0, skip
= 0; i
< o
->size
; i
++)
3868 if (bfd_elf_reloc_symbol_deleted_p (i
* PDR_SIZE
, cookie
))
3877 score_elf_section_data (o
)->u
.tdata
= tdata
;
3878 o
->size
-= skip
* PDR_SIZE
;
3884 if (!info
->keep_memory
)
3885 free (cookie
->rels
);
3890 /* Signal that discard_info() has removed the discarded relocations for this section. */
3892 s3_bfd_score_elf_ignore_discarded_relocs (asection
*sec
)
3894 if (strcmp (sec
->name
, ".pdr") == 0)
3899 /* Return the section that should be marked against GC for a given
3902 s3_bfd_score_elf_gc_mark_hook (asection
*sec
,
3903 struct bfd_link_info
*info
,
3904 Elf_Internal_Rela
*rel
,
3905 struct elf_link_hash_entry
*h
,
3906 Elf_Internal_Sym
*sym
)
3909 switch (ELF32_R_TYPE (rel
->r_info
))
3911 case R_SCORE_GNU_VTINHERIT
:
3912 case R_SCORE_GNU_VTENTRY
:
3916 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
3919 /* Support for core dump NOTE sections. */
3922 s3_bfd_score_elf_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
3925 unsigned int raw_size
;
3927 switch (note
->descsz
)
3932 case 148: /* Linux/Score 32-bit. */
3934 elf_tdata (abfd
)->core_signal
= score_bfd_get_16 (abfd
, note
->descdata
+ 12);
3937 elf_tdata (abfd
)->core_pid
= score_bfd_get_32 (abfd
, note
->descdata
+ 24);
3946 /* Make a ".reg/999" section. */
3947 return _bfd_elfcore_make_pseudosection (abfd
, ".reg", raw_size
, note
->descpos
+ offset
);
3951 s3_bfd_score_elf_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
3953 switch (note
->descsz
)
3958 case 124: /* Linux/Score elf_prpsinfo. */
3959 elf_tdata (abfd
)->core_program
= _bfd_elfcore_strndup (abfd
, note
->descdata
+ 28, 16);
3960 elf_tdata (abfd
)->core_command
= _bfd_elfcore_strndup (abfd
, note
->descdata
+ 44, 80);
3963 /* Note that for some reason, a spurious space is tacked
3964 onto the end of the args in some (at least one anyway)
3965 implementations, so strip it off if it exists. */
3968 char *command
= elf_tdata (abfd
)->core_command
;
3969 int n
= strlen (command
);
3971 if (0 < n
&& command
[n
- 1] == ' ')
3972 command
[n
- 1] = '\0';
3979 /* Score BFD functions. */
3980 static reloc_howto_type
*
3981 s3_elf32_score_reloc_type_lookup (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_reloc_code_real_type code
)
3985 for (i
= 0; i
< ARRAY_SIZE (elf32_score_reloc_map
); i
++)
3986 if (elf32_score_reloc_map
[i
].bfd_reloc_val
== code
)
3987 return &elf32_score_howto_table
[elf32_score_reloc_map
[i
].elf_reloc_val
];
3992 static reloc_howto_type
*
3993 elf32_score_reloc_name_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
3999 i
< (sizeof (elf32_score_howto_table
)
4000 / sizeof (elf32_score_howto_table
[0]));
4002 if (elf32_score_howto_table
[i
].name
!= NULL
4003 && strcasecmp (elf32_score_howto_table
[i
].name
, r_name
) == 0)
4004 return &elf32_score_howto_table
[i
];
4009 /* Create a score elf linker hash table. */
4011 static struct bfd_link_hash_table
*
4012 s3_elf32_score_link_hash_table_create (bfd
*abfd
)
4014 struct score_elf_link_hash_table
*ret
;
4015 bfd_size_type amt
= sizeof (struct score_elf_link_hash_table
);
4017 ret
= bfd_malloc (amt
);
4021 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
, score_elf_link_hash_newfunc
,
4022 sizeof (struct score_elf_link_hash_entry
)))
4028 return &ret
->root
.root
;
4032 s3_elf32_score_print_private_bfd_data (bfd
*abfd
, void * ptr
)
4034 FILE *file
= (FILE *) ptr
;
4036 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
4038 /* Print normal ELF private data. */
4039 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
4041 /* xgettext:c-format */
4042 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
4043 if (elf_elfheader (abfd
)->e_flags
& EF_SCORE_PIC
)
4045 fprintf (file
, _(" [pic]"));
4047 if (elf_elfheader (abfd
)->e_flags
& EF_SCORE_FIXDEP
)
4049 fprintf (file
, _(" [fix dep]"));
4057 s3_elf32_score_merge_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
4062 if (!_bfd_generic_verify_endian_match (ibfd
, obfd
))
4065 in_flags
= elf_elfheader (ibfd
)->e_flags
;
4066 out_flags
= elf_elfheader (obfd
)->e_flags
;
4068 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
4069 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
4072 in_flags
= elf_elfheader (ibfd
)->e_flags
;
4073 out_flags
= elf_elfheader (obfd
)->e_flags
;
4075 if (! elf_flags_init (obfd
))
4077 elf_flags_init (obfd
) = TRUE
;
4078 elf_elfheader (obfd
)->e_flags
= in_flags
;
4080 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
4081 && bfd_get_arch_info (obfd
)->the_default
)
4083 return bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
), bfd_get_mach (ibfd
));
4089 if (((in_flags
& EF_SCORE_PIC
) != 0) != ((out_flags
& EF_SCORE_PIC
) != 0))
4091 (*_bfd_error_handler
) (_("%B: warning: linking PIC files with non-PIC files"), ibfd
);
4094 /* FIXME: Maybe dependency fix compatibility should be checked here. */
4100 s3_elf32_score_new_section_hook (bfd
*abfd
, asection
*sec
)
4102 struct _score_elf_section_data
*sdata
;
4103 bfd_size_type amt
= sizeof (*sdata
);
4105 sdata
= bfd_zalloc (abfd
, amt
);
4108 sec
->used_by_bfd
= sdata
;
4110 return _bfd_elf_new_section_hook (abfd
, sec
);
4113 /*****************************************************************************/
4115 /* s3_s7: backend hooks. */
4117 _bfd_score_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
4119 Elf_Internal_Rela
*elf_reloc
)
4121 if (bfd_get_mach (abfd
) == bfd_mach_score3
)
4122 return s3_bfd_score_info_to_howto (abfd
, bfd_reloc
, elf_reloc
);
4124 return s7_bfd_score_info_to_howto (abfd
, bfd_reloc
, elf_reloc
);
4128 _bfd_score_elf_relocate_section (bfd
*output_bfd
,
4129 struct bfd_link_info
*info
,
4131 asection
*input_section
,
4133 Elf_Internal_Rela
*relocs
,
4134 Elf_Internal_Sym
*local_syms
,
4135 asection
**local_sections
)
4137 if (bfd_get_mach (output_bfd
) == bfd_mach_score3
)
4138 return s3_bfd_score_elf_relocate_section (output_bfd
,
4139 info
, input_bfd
, input_section
, contents
, relocs
,
4140 local_syms
, local_sections
);
4142 return s7_bfd_score_elf_relocate_section (output_bfd
,
4143 info
, input_bfd
, input_section
, contents
, relocs
,
4144 local_syms
, local_sections
);
4148 _bfd_score_elf_check_relocs (bfd
*abfd
,
4149 struct bfd_link_info
*info
,
4151 const Elf_Internal_Rela
*relocs
)
4153 if (bfd_get_mach (abfd
) == bfd_mach_score3
)
4154 return s3_bfd_score_elf_check_relocs (abfd
, info
, sec
, relocs
);
4156 return s7_bfd_score_elf_check_relocs (abfd
, info
, sec
, relocs
);
4160 _bfd_score_elf_add_symbol_hook (bfd
*abfd
,
4161 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
4162 Elf_Internal_Sym
*sym
,
4163 const char **namep ATTRIBUTE_UNUSED
,
4164 flagword
*flagsp ATTRIBUTE_UNUSED
,
4168 if (bfd_get_mach (abfd
) == bfd_mach_score3
)
4169 return s3_bfd_score_elf_add_symbol_hook (abfd
, info
, sym
, namep
, flagsp
,
4172 return s7_bfd_score_elf_add_symbol_hook (abfd
, info
, sym
, namep
, flagsp
,
4177 _bfd_score_elf_symbol_processing (bfd
*abfd
, asymbol
*asym
)
4179 if (bfd_get_mach (abfd
) == bfd_mach_score3
)
4180 return s3_bfd_score_elf_symbol_processing (abfd
, asym
);
4182 return s7_bfd_score_elf_symbol_processing (abfd
, asym
);
4186 _bfd_score_elf_link_output_symbol_hook (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
4187 const char *name ATTRIBUTE_UNUSED
,
4188 Elf_Internal_Sym
*sym
,
4189 asection
*input_sec
,
4190 struct elf_link_hash_entry
*h ATTRIBUTE_UNUSED
)
4192 /* If link a empty .o, then this filed is NULL. */
4193 if (info
->input_bfds
== NULL
)
4195 /* If we see a common symbol, which implies a relocatable link, then
4196 if a symbol was small common in an input file, mark it as small
4197 common in the output file. */
4198 if (sym
->st_shndx
== SHN_COMMON
&& strcmp (input_sec
->name
, ".scommon") == 0)
4199 sym
->st_shndx
= SHN_SCORE_SCOMMON
;
4203 if (bfd_get_mach (info
->input_bfds
) == bfd_mach_score3
)
4204 return s3_bfd_score_elf_link_output_symbol_hook (info
, name
, sym
, input_sec
, h
);
4206 return s7_bfd_score_elf_link_output_symbol_hook (info
, name
, sym
, input_sec
, h
);
4210 _bfd_score_elf_section_from_bfd_section (bfd
*abfd ATTRIBUTE_UNUSED
,
4214 if (bfd_get_mach (abfd
) == bfd_mach_score3
)
4215 return s3_bfd_score_elf_section_from_bfd_section (abfd
, sec
, retval
);
4217 return s7_bfd_score_elf_section_from_bfd_section (abfd
, sec
, retval
);
4221 _bfd_score_elf_adjust_dynamic_symbol (struct bfd_link_info
*info
,
4222 struct elf_link_hash_entry
*h
)
4224 if (bfd_get_mach (info
->input_bfds
) == bfd_mach_score3
)
4225 return s3_bfd_score_elf_adjust_dynamic_symbol (info
, h
);
4227 return s7_bfd_score_elf_adjust_dynamic_symbol (info
, h
);
4231 _bfd_score_elf_always_size_sections (bfd
*output_bfd
,
4232 struct bfd_link_info
*info
)
4234 if (bfd_get_mach (output_bfd
) == bfd_mach_score3
)
4235 return s3_bfd_score_elf_always_size_sections (output_bfd
, info
);
4237 return s7_bfd_score_elf_always_size_sections (output_bfd
, info
);
4241 _bfd_score_elf_size_dynamic_sections (bfd
*output_bfd
, struct bfd_link_info
*info
)
4243 if (bfd_get_mach (output_bfd
) == bfd_mach_score3
)
4244 return s3_bfd_score_elf_size_dynamic_sections (output_bfd
, info
);
4246 return s7_bfd_score_elf_size_dynamic_sections (output_bfd
, info
);
4250 _bfd_score_elf_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
4252 if (bfd_get_mach (abfd
) == bfd_mach_score3
)
4253 return s3_bfd_score_elf_create_dynamic_sections (abfd
, info
);
4255 return s7_bfd_score_elf_create_dynamic_sections (abfd
, info
);
4259 _bfd_score_elf_finish_dynamic_symbol (bfd
*output_bfd
,
4260 struct bfd_link_info
*info
,
4261 struct elf_link_hash_entry
*h
,
4262 Elf_Internal_Sym
*sym
)
4264 if (bfd_get_mach (output_bfd
) == bfd_mach_score3
)
4265 return s3_bfd_score_elf_finish_dynamic_symbol (output_bfd
, info
, h
, sym
);
4267 return s7_bfd_score_elf_finish_dynamic_symbol (output_bfd
, info
, h
, sym
);
4271 _bfd_score_elf_finish_dynamic_sections (bfd
*output_bfd
,
4272 struct bfd_link_info
*info
)
4274 if (bfd_get_mach (output_bfd
) == bfd_mach_score3
)
4275 return s3_bfd_score_elf_finish_dynamic_sections (output_bfd
, info
);
4277 return s7_bfd_score_elf_finish_dynamic_sections (output_bfd
, info
);
4281 _bfd_score_elf_fake_sections (bfd
*abfd ATTRIBUTE_UNUSED
,
4282 Elf_Internal_Shdr
*hdr
,
4285 if (bfd_get_mach (abfd
) == bfd_mach_score3
)
4286 return s3_bfd_score_elf_fake_sections (abfd
, hdr
, sec
);
4288 return s7_bfd_score_elf_fake_sections (abfd
, hdr
, sec
);
4292 _bfd_score_elf_section_processing (bfd
*abfd ATTRIBUTE_UNUSED
, Elf_Internal_Shdr
*hdr
)
4294 if (bfd_get_mach (abfd
) == bfd_mach_score3
)
4295 return s3_bfd_score_elf_section_processing (abfd
, hdr
);
4297 return s7_bfd_score_elf_section_processing (abfd
, hdr
);
4301 _bfd_score_elf_write_section (bfd
*output_bfd
,
4302 struct bfd_link_info
*link_info ATTRIBUTE_UNUSED
,
4303 asection
*sec
, bfd_byte
*contents
)
4305 if (bfd_get_mach (output_bfd
) == bfd_mach_score3
)
4306 return s3_bfd_score_elf_write_section (output_bfd
, sec
, contents
);
4308 return s7_bfd_score_elf_write_section (output_bfd
, sec
, contents
);
4312 _bfd_score_elf_copy_indirect_symbol (struct bfd_link_info
*info
,
4313 struct elf_link_hash_entry
*dir
,
4314 struct elf_link_hash_entry
*ind
)
4316 if (bfd_get_mach (info
->input_bfds
) == bfd_mach_score3
)
4317 return s3_bfd_score_elf_copy_indirect_symbol (info
, dir
, ind
);
4319 return s7_bfd_score_elf_copy_indirect_symbol (info
, dir
, ind
);
4323 _bfd_score_elf_hide_symbol (struct bfd_link_info
*info
,
4324 struct elf_link_hash_entry
*entry
,
4325 bfd_boolean force_local
)
4327 if (bfd_get_mach (info
->input_bfds
) == bfd_mach_score3
)
4328 return s3_bfd_score_elf_hide_symbol (info
, entry
, force_local
);
4330 return s7_bfd_score_elf_hide_symbol (info
, entry
, force_local
);
4334 _bfd_score_elf_discard_info (bfd
*abfd
, struct elf_reloc_cookie
*cookie
,
4335 struct bfd_link_info
*info
)
4337 if (bfd_get_mach (abfd
) == bfd_mach_score3
)
4338 return s3_bfd_score_elf_discard_info (abfd
, cookie
, info
);
4340 return s7_bfd_score_elf_discard_info (abfd
, cookie
, info
);
4344 _bfd_score_elf_ignore_discarded_relocs (asection
*sec
)
4346 if (bfd_get_mach (sec
->owner
) == bfd_mach_score3
)
4347 return s3_bfd_score_elf_ignore_discarded_relocs (sec
);
4349 return s7_bfd_score_elf_ignore_discarded_relocs (sec
);
4353 _bfd_score_elf_gc_mark_hook (asection
*sec
,
4354 struct bfd_link_info
*info
,
4355 Elf_Internal_Rela
*rel
,
4356 struct elf_link_hash_entry
*h
,
4357 Elf_Internal_Sym
*sym
)
4359 if (bfd_get_mach (info
->input_bfds
) == bfd_mach_score3
)
4360 return s3_bfd_score_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
4362 return s7_bfd_score_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
4366 _bfd_score_elf_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
4368 if (bfd_get_mach (abfd
) == bfd_mach_score3
)
4369 return s3_bfd_score_elf_grok_prstatus (abfd
, note
);
4371 return s7_bfd_score_elf_grok_prstatus (abfd
, note
);
4375 _bfd_score_elf_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
4377 if (bfd_get_mach (abfd
) == bfd_mach_score3
)
4378 return s3_bfd_score_elf_grok_psinfo (abfd
, note
);
4380 return s7_bfd_score_elf_grok_psinfo (abfd
, note
);
4383 static reloc_howto_type
*
4384 elf32_score_reloc_type_lookup (bfd
*abfd ATTRIBUTE_UNUSED
, bfd_reloc_code_real_type code
)
4387 gas will call elf32_score_reloc_type_lookup, and don't write elf file.
4388 So just using score3, but we don't know ld will call this or not.
4389 If so, this way can't work. */
4392 return s3_elf32_score_reloc_type_lookup (abfd
, code
);
4394 return s7_elf32_score_reloc_type_lookup (abfd
, code
);
4397 static struct bfd_link_hash_table
*
4398 elf32_score_link_hash_table_create (bfd
*abfd
)
4400 if (bfd_get_mach (abfd
) == bfd_mach_score3
)
4401 return s3_elf32_score_link_hash_table_create (abfd
);
4403 return s7_elf32_score_link_hash_table_create (abfd
);
4407 elf32_score_print_private_bfd_data (bfd
*abfd
, void * ptr
)
4409 if (bfd_get_mach (abfd
) == bfd_mach_score3
)
4410 return s3_elf32_score_print_private_bfd_data (abfd
, ptr
);
4412 return s7_elf32_score_print_private_bfd_data (abfd
, ptr
);
4416 elf32_score_merge_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
4418 if (bfd_get_mach (obfd
) == bfd_mach_score3
)
4419 return s3_elf32_score_merge_private_bfd_data (ibfd
, obfd
);
4421 return s7_elf32_score_merge_private_bfd_data (ibfd
, obfd
);
4425 elf32_score_new_section_hook (bfd
*abfd
, asection
*sec
)
4427 if (bfd_get_mach (abfd
) == bfd_mach_score3
)
4428 return s3_elf32_score_new_section_hook (abfd
, sec
);
4430 return s7_elf32_score_new_section_hook (abfd
, sec
);
4434 /* s3_s7: don't need to split. */
4436 /* Set the right machine number. */
4438 _bfd_score_elf_score_object_p (bfd
* abfd
)
4440 int e_set
= bfd_mach_score7
;
4442 if (elf_elfheader (abfd
)->e_machine
== EM_SCORE
)
4444 int e_mach
= elf_elfheader (abfd
)->e_flags
& EF_SCORE_MACH
& EF_OMIT_PIC_FIXDD
;
4447 /* Set default target is score7. */
4449 case E_SCORE_MACH_SCORE7
:
4450 e_set
= bfd_mach_score7
;
4453 case E_SCORE_MACH_SCORE3
:
4454 e_set
= bfd_mach_score3
;
4459 return bfd_default_set_arch_mach (abfd
, bfd_arch_score
, e_set
);
4463 _bfd_score_elf_common_definition (Elf_Internal_Sym
*sym
)
4465 return (sym
->st_shndx
== SHN_COMMON
|| sym
->st_shndx
== SHN_SCORE_SCOMMON
);
4468 /*****************************************************************************/
4472 #define TARGET_LITTLE_SYM bfd_elf32_littlescore_vec
4473 #define TARGET_LITTLE_NAME "elf32-littlescore"
4474 #define TARGET_BIG_SYM bfd_elf32_bigscore_vec
4475 #define TARGET_BIG_NAME "elf32-bigscore"
4476 #define ELF_ARCH bfd_arch_score
4477 #define ELF_MACHINE_CODE EM_SCORE
4478 #define ELF_MACHINE_ALT1 EM_SCORE_OLD
4479 #define ELF_MAXPAGESIZE 0x8000
4481 #define elf_info_to_howto 0
4482 #define elf_info_to_howto_rel _bfd_score_info_to_howto
4483 #define elf_backend_relocate_section _bfd_score_elf_relocate_section
4484 #define elf_backend_check_relocs _bfd_score_elf_check_relocs
4485 #define elf_backend_add_symbol_hook _bfd_score_elf_add_symbol_hook
4486 #define elf_backend_symbol_processing _bfd_score_elf_symbol_processing
4487 #define elf_backend_link_output_symbol_hook \
4488 _bfd_score_elf_link_output_symbol_hook
4489 #define elf_backend_section_from_bfd_section \
4490 _bfd_score_elf_section_from_bfd_section
4491 #define elf_backend_adjust_dynamic_symbol \
4492 _bfd_score_elf_adjust_dynamic_symbol
4493 #define elf_backend_always_size_sections \
4494 _bfd_score_elf_always_size_sections
4495 #define elf_backend_size_dynamic_sections \
4496 _bfd_score_elf_size_dynamic_sections
4497 #define elf_backend_omit_section_dynsym \
4498 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
4499 #define elf_backend_create_dynamic_sections \
4500 _bfd_score_elf_create_dynamic_sections
4501 #define elf_backend_finish_dynamic_symbol \
4502 _bfd_score_elf_finish_dynamic_symbol
4503 #define elf_backend_finish_dynamic_sections \
4504 _bfd_score_elf_finish_dynamic_sections
4505 #define elf_backend_fake_sections _bfd_score_elf_fake_sections
4506 #define elf_backend_section_processing _bfd_score_elf_section_processing
4507 #define elf_backend_write_section _bfd_score_elf_write_section
4508 #define elf_backend_copy_indirect_symbol _bfd_score_elf_copy_indirect_symbol
4509 #define elf_backend_hide_symbol _bfd_score_elf_hide_symbol
4510 #define elf_backend_discard_info _bfd_score_elf_discard_info
4511 #define elf_backend_ignore_discarded_relocs \
4512 _bfd_score_elf_ignore_discarded_relocs
4513 #define elf_backend_gc_mark_hook _bfd_score_elf_gc_mark_hook
4514 #define elf_backend_grok_prstatus _bfd_score_elf_grok_prstatus
4515 #define elf_backend_grok_psinfo _bfd_score_elf_grok_psinfo
4516 #define elf_backend_can_gc_sections 1
4517 #define elf_backend_want_plt_sym 0
4518 #define elf_backend_got_header_size (4 * SCORE_RESERVED_GOTNO)
4519 #define elf_backend_plt_header_size 0
4520 #define elf_backend_collect TRUE
4521 #define elf_backend_type_change_ok TRUE
4522 #define elf_backend_object_p _bfd_score_elf_score_object_p
4524 #define bfd_elf32_bfd_reloc_type_lookup elf32_score_reloc_type_lookup
4525 #define bfd_elf32_bfd_reloc_name_lookup \
4526 elf32_score_reloc_name_lookup
4527 #define bfd_elf32_bfd_link_hash_table_create elf32_score_link_hash_table_create
4528 #define bfd_elf32_bfd_print_private_bfd_data elf32_score_print_private_bfd_data
4529 #define bfd_elf32_bfd_merge_private_bfd_data elf32_score_merge_private_bfd_data
4530 #define bfd_elf32_new_section_hook elf32_score_new_section_hook
4532 #include "elf32-target.h"