* ld-elf/header.d: Allow arbitrary lines between "Program Header"
[binutils.git] / bfd / elf32-score.c
blob1246e26156d619dcbddb97d6c3cb59a58fb6d1eb
1 /* 32-bit ELF support for S+core.
2 Copyright 2006 Free Software Foundation, Inc.
3 Contributed by
4 Mei Ligang (ligang@sunnorth.com.cn)
5 Pei-Lin Tsai (pltsai@sunplus.com)
7 This file is part of BFD, the Binary File Descriptor library.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
23 #include "bfd.h"
24 #include "sysdep.h"
25 #include "libbfd.h"
26 #include "libiberty.h"
27 #include "elf-bfd.h"
28 #include "elf/score.h"
29 #include "elf/common.h"
30 #include "elf/internal.h"
31 #include "hashtab.h"
34 /* Score ELF linker hash table. */
36 struct score_elf_link_hash_table
38 /* The main hash table. */
39 struct elf_link_hash_table root;
42 /* The SCORE ELF linker needs additional information for each symbol in
43 the global hash table. */
45 struct score_elf_link_hash_entry
47 struct elf_link_hash_entry root;
49 /* Number of R_SCORE_ABS32, R_SCORE_REL32 relocs against this symbol. */
50 unsigned int possibly_dynamic_relocs;
52 /* If the R_SCORE_ABS32, R_SCORE_REL32 reloc is against a readonly section. */
53 bfd_boolean readonly_reloc;
55 /* We must not create a stub for a symbol that has relocations related to
56 taking the function's address, i.e. any but R_SCORE_CALL15 ones. */
57 bfd_boolean no_fn_stub;
59 /* Are we forced local? This will only be set if we have converted
60 the initial global GOT entry to a local GOT entry. */
61 bfd_boolean forced_local;
64 /* Traverse a score ELF linker hash table. */
65 #define score_elf_link_hash_traverse(table, func, info) \
66 (elf_link_hash_traverse \
67 (&(table)->root, \
68 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
69 (info)))
71 /* Get the SCORE elf linker hash table from a link_info structure. */
72 #define score_elf_hash_table(info) \
73 ((struct score_elf_link_hash_table *) ((info)->hash))
75 /* This structure is used to hold .got entries while estimating got sizes. */
76 struct score_got_entry
78 /* The input bfd in which the symbol is defined. */
79 bfd *abfd;
80 /* The index of the symbol, as stored in the relocation r_info, if
81 we have a local symbol; -1 otherwise. */
82 long symndx;
83 union
85 /* If abfd == NULL, an address that must be stored in the got. */
86 bfd_vma address;
87 /* If abfd != NULL && symndx != -1, the addend of the relocation
88 that should be added to the symbol value. */
89 bfd_vma addend;
90 /* If abfd != NULL && symndx == -1, the hash table entry
91 corresponding to a global symbol in the got (or, local, if
92 h->forced_local). */
93 struct score_elf_link_hash_entry *h;
94 } d;
96 /* The offset from the beginning of the .got section to the entry
97 corresponding to this symbol+addend. If it's a global symbol
98 whose offset is yet to be decided, it's going to be -1. */
99 long gotidx;
102 /* This structure is passed to score_elf_sort_hash_table_f when sorting
103 the dynamic symbols. */
105 struct score_elf_hash_sort_data
107 /* The symbol in the global GOT with the lowest dynamic symbol table index. */
108 struct elf_link_hash_entry *low;
109 /* The least dynamic symbol table index corresponding to a symbol with a GOT entry. */
110 long min_got_dynindx;
111 /* The greatest dynamic symbol table index corresponding to a symbol
112 with a GOT entry that is not referenced (e.g., a dynamic symbol
113 with dynamic relocations pointing to it from non-primary GOTs). */
114 long max_unref_got_dynindx;
115 /* The greatest dynamic symbol table index not corresponding to a
116 symbol without a GOT entry. */
117 long max_non_got_dynindx;
120 struct score_got_info
122 /* The global symbol in the GOT with the lowest index in the dynamic
123 symbol table. */
124 struct elf_link_hash_entry *global_gotsym;
125 /* The number of global .got entries. */
126 unsigned int global_gotno;
127 /* The number of local .got entries. */
128 unsigned int local_gotno;
129 /* The number of local .got entries we have used. */
130 unsigned int assigned_gotno;
131 /* A hash table holding members of the got. */
132 struct htab *got_entries;
133 /* In multi-got links, a pointer to the next got (err, rather, most
134 of the time, it points to the previous got). */
135 struct score_got_info *next;
138 /* A structure used to count GOT entries, for GOT entry or ELF symbol table traversal. */
139 struct _score_elf_section_data
141 struct bfd_elf_section_data elf;
142 union
144 struct score_got_info *got_info;
145 bfd_byte *tdata;
150 #define score_elf_section_data(sec) \
151 ((struct _score_elf_section_data *) elf_section_data (sec))
153 /* The size of a symbol-table entry. */
154 #define SCORE_ELF_SYM_SIZE(abfd) \
155 (get_elf_backend_data (abfd)->s->sizeof_sym)
157 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
158 from smaller values. Start with zero, widen, *then* decrement. */
159 #define MINUS_ONE (((bfd_vma)0) - 1)
160 #define MINUS_TWO (((bfd_vma)0) - 2)
162 #define PDR_SIZE 32
165 /* The number of local .got entries we reserve. */
166 #define SCORE_RESERVED_GOTNO (2)
167 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
169 /* The offset of $gp from the beginning of the .got section. */
170 #define ELF_SCORE_GP_OFFSET(abfd) (0x3ff0)
171 /* The maximum size of the GOT for it to be addressable using 15-bit offsets from $gp. */
172 #define SCORE_ELF_GOT_MAX_SIZE(abfd) (ELF_SCORE_GP_OFFSET(abfd) + 0x3fff)
174 #define SCORE_ELF_STUB_SECTION_NAME (".SCORE.stub")
175 #define SCORE_FUNCTION_STUB_SIZE (16)
177 #define STUB_LW 0xc3bcc010 /* lw r29, [r28, -0x3ff0] */
178 #define STUB_MOVE 0x8363bc56 /* mv r27, r3 */
179 #define STUB_LI16 0x87548000 /* ori r26, .dynsym_index */
180 #define STUB_BRL 0x801dbc09 /* brl r29 */
182 #define SCORE_ELF_GOT_SIZE(abfd) \
183 (get_elf_backend_data (abfd)->s->arch_size / 8)
185 #define SCORE_ELF_ADD_DYNAMIC_ENTRY(info, tag, val) \
186 (_bfd_elf_add_dynamic_entry (info, (bfd_vma) tag, (bfd_vma) val))
188 /* The size of an external dynamic table entry. */
189 #define SCORE_ELF_DYN_SIZE(abfd) \
190 (get_elf_backend_data (abfd)->s->sizeof_dyn)
192 /* The size of an external REL relocation. */
193 #define SCORE_ELF_REL_SIZE(abfd) \
194 (get_elf_backend_data (abfd)->s->sizeof_rel)
196 /* The default alignment for sections, as a power of two. */
197 #define SCORE_ELF_LOG_FILE_ALIGN(abfd)\
198 (get_elf_backend_data (abfd)->s->log_file_align)
200 #ifndef NUM_ELEM
201 #define NUM_ELEM(a) (sizeof (a) / (sizeof (a)[0]))
202 #endif
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;
218 static bfd_reloc_status_type
219 score_elf_hi16_reloc (bfd *abfd ATTRIBUTE_UNUSED,
220 arelent *reloc_entry,
221 asymbol *symbol ATTRIBUTE_UNUSED,
222 void * data,
223 asection *input_section ATTRIBUTE_UNUSED,
224 bfd *output_bfd ATTRIBUTE_UNUSED,
225 char **error_message ATTRIBUTE_UNUSED)
227 hi16_rel_addr = (bfd_byte *) data + reloc_entry->address;
228 return bfd_reloc_ok;
231 static bfd_reloc_status_type
232 score_elf_lo16_reloc (bfd *abfd,
233 arelent *reloc_entry,
234 asymbol *symbol ATTRIBUTE_UNUSED,
235 void * data,
236 asection *input_section,
237 bfd *output_bfd ATTRIBUTE_UNUSED,
238 char **error_message ATTRIBUTE_UNUSED)
240 bfd_vma addend = 0, offset = 0;
241 unsigned long val;
242 unsigned long hi16_offset, hi16_value, uvalue;
244 hi16_value = bfd_get_32 (abfd, hi16_rel_addr);
245 hi16_offset = ((((hi16_value >> 16) & 0x3) << 15) | (hi16_value & 0x7fff)) >> 1;
246 addend = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
247 offset = ((((addend >> 16) & 0x3) << 15) | (addend & 0x7fff)) >> 1;
248 val = reloc_entry->addend;
249 if (reloc_entry->address > input_section->size)
250 return bfd_reloc_outofrange;
251 uvalue = ((hi16_offset << 16) | (offset & 0xffff)) + val;
252 hi16_offset = (uvalue >> 16) << 1;
253 hi16_value = (hi16_value & ~0x37fff) | (hi16_offset & 0x7fff) | ((hi16_offset << 1) & 0x30000);
254 bfd_put_32 (abfd, hi16_value, hi16_rel_addr);
255 offset = (uvalue & 0xffff) << 1;
256 addend = (addend & ~0x37fff) | (offset & 0x7fff) | ((offset << 1) & 0x30000);
257 bfd_put_32 (abfd, addend, (bfd_byte *) data + reloc_entry->address);
258 return bfd_reloc_ok;
261 /* Set the GP value for OUTPUT_BFD. Returns FALSE if this is a
262 dangerous relocation. */
264 static bfd_boolean
265 score_elf_assign_gp (bfd *output_bfd, bfd_vma *pgp)
267 unsigned int count;
268 asymbol **sym;
269 unsigned int i;
271 /* If we've already figured out what GP will be, just return it. */
272 *pgp = _bfd_get_gp_value (output_bfd);
273 if (*pgp)
274 return TRUE;
276 count = bfd_get_symcount (output_bfd);
277 sym = bfd_get_outsymbols (output_bfd);
279 /* The linker script will have created a symbol named `_gp' with the
280 appropriate value. */
281 if (sym == NULL)
282 i = count;
283 else
285 for (i = 0; i < count; i++, sym++)
287 const char *name;
289 name = bfd_asymbol_name (*sym);
290 if (*name == '_' && strcmp (name, "_gp") == 0)
292 *pgp = bfd_asymbol_value (*sym);
293 _bfd_set_gp_value (output_bfd, *pgp);
294 break;
299 if (i >= count)
301 /* Only get the error once. */
302 *pgp = 4;
303 _bfd_set_gp_value (output_bfd, *pgp);
304 return FALSE;
307 return TRUE;
310 /* We have to figure out the gp value, so that we can adjust the
311 symbol value correctly. We look up the symbol _gp in the output
312 BFD. If we can't find it, we're stuck. We cache it in the ELF
313 target data. We don't need to adjust the symbol value for an
314 external symbol if we are producing relocatable output. */
316 static bfd_reloc_status_type
317 score_elf_final_gp (bfd *output_bfd,
318 asymbol *symbol,
319 bfd_boolean relocatable,
320 char **error_message,
321 bfd_vma *pgp)
323 if (bfd_is_und_section (symbol->section)
324 && ! relocatable)
326 *pgp = 0;
327 return bfd_reloc_undefined;
330 *pgp = _bfd_get_gp_value (output_bfd);
331 if (*pgp == 0
332 && (! relocatable
333 || (symbol->flags & BSF_SECTION_SYM) != 0))
335 if (relocatable)
337 /* Make up a value. */
338 *pgp = symbol->section->output_section->vma + 0x4000;
339 _bfd_set_gp_value (output_bfd, *pgp);
341 else if (!score_elf_assign_gp (output_bfd, pgp))
343 *error_message =
344 (char *) _("GP relative relocation when _gp not defined");
345 return bfd_reloc_dangerous;
349 return bfd_reloc_ok;
352 static bfd_reloc_status_type
353 score_elf_gprel15_with_gp (bfd *abfd,
354 asymbol *symbol,
355 arelent *reloc_entry,
356 asection *input_section,
357 bfd_boolean relocateable,
358 void * data,
359 bfd_vma gp ATTRIBUTE_UNUSED)
361 bfd_vma relocation;
362 unsigned long insn;
364 if (bfd_is_com_section (symbol->section))
365 relocation = 0;
366 else
367 relocation = symbol->value;
369 relocation += symbol->section->output_section->vma;
370 relocation += symbol->section->output_offset;
371 if (reloc_entry->address > input_section->size)
372 return bfd_reloc_outofrange;
374 insn = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
375 if (((reloc_entry->addend & 0xffffc000) != 0)
376 && ((reloc_entry->addend & 0xffffc000) != 0xffffc000))
377 return bfd_reloc_overflow;
379 insn = (insn & ~0x7fff) | (reloc_entry->addend & 0x7fff);
380 bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
381 if (relocateable)
382 reloc_entry->address += input_section->output_offset;
384 return bfd_reloc_ok;
387 static bfd_reloc_status_type
388 gprel32_with_gp (bfd *abfd, asymbol *symbol, arelent *reloc_entry,
389 asection *input_section, bfd_boolean relocatable,
390 void *data, bfd_vma gp)
392 bfd_vma relocation;
393 bfd_vma val;
395 if (bfd_is_com_section (symbol->section))
396 relocation = 0;
397 else
398 relocation = symbol->value;
400 relocation += symbol->section->output_section->vma;
401 relocation += symbol->section->output_offset;
403 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
404 return bfd_reloc_outofrange;
406 /* Set val to the offset into the section or symbol. */
407 val = reloc_entry->addend;
409 if (reloc_entry->howto->partial_inplace)
410 val += bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
412 /* Adjust val for the final section location and GP value. If we
413 are producing relocatable output, we don't want to do this for
414 an external symbol. */
415 if (! relocatable
416 || (symbol->flags & BSF_SECTION_SYM) != 0)
417 val += relocation - gp;
419 if (reloc_entry->howto->partial_inplace)
420 bfd_put_32 (abfd, val, (bfd_byte *) data + reloc_entry->address);
421 else
422 reloc_entry->addend = val;
424 if (relocatable)
425 reloc_entry->address += input_section->output_offset;
427 return bfd_reloc_ok;
430 static bfd_reloc_status_type
431 score_elf_gprel15_reloc (bfd *abfd,
432 arelent *reloc_entry,
433 asymbol *symbol,
434 void * data,
435 asection *input_section,
436 bfd *output_bfd,
437 char **error_message)
439 bfd_boolean relocateable;
440 bfd_reloc_status_type ret;
441 bfd_vma gp;
443 if (output_bfd != (bfd *) NULL
444 && (symbol->flags & BSF_SECTION_SYM) == 0 && reloc_entry->addend == 0)
446 reloc_entry->address += input_section->output_offset;
447 return bfd_reloc_ok;
449 if (output_bfd != (bfd *) NULL)
450 relocateable = TRUE;
451 else
453 relocateable = FALSE;
454 output_bfd = symbol->section->output_section->owner;
457 ret = score_elf_final_gp (output_bfd, symbol, relocateable, error_message, &gp);
458 if (ret != bfd_reloc_ok)
459 return ret;
461 return score_elf_gprel15_with_gp (abfd, symbol, reloc_entry,
462 input_section, relocateable, data, gp);
465 /* Do a R_SCORE_GPREL32 relocation. This is a 32 bit value which must
466 become the offset from the gp register. */
468 static bfd_reloc_status_type
469 score_elf_gprel32_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
470 void *data, asection *input_section, bfd *output_bfd,
471 char **error_message)
473 bfd_boolean relocatable;
474 bfd_reloc_status_type ret;
475 bfd_vma gp;
477 /* R_SCORE_GPREL32 relocations are defined for local symbols only. */
478 if (output_bfd != NULL
479 && (symbol->flags & BSF_SECTION_SYM) == 0
480 && (symbol->flags & BSF_LOCAL) != 0)
482 *error_message = (char *)
483 _("32bits gp relative relocation occurs for an external symbol");
484 return bfd_reloc_outofrange;
487 if (output_bfd != NULL)
488 relocatable = TRUE;
489 else
491 relocatable = FALSE;
492 output_bfd = symbol->section->output_section->owner;
495 ret = score_elf_final_gp (output_bfd, symbol, relocatable, error_message, &gp);
496 if (ret != bfd_reloc_ok)
497 return ret;
499 gp = 0; /* FIXME. */
500 return gprel32_with_gp (abfd, symbol, reloc_entry, input_section,
501 relocatable, data, gp);
504 /* A howto special_function for R_SCORE_GOT15 relocations. This is just
505 like any other 16-bit relocation when applied to global symbols, but is
506 treated in the same as R_SCORE_HI16 when applied to local symbols. */
508 static bfd_reloc_status_type
509 score_elf_got15_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
510 void *data, asection *input_section,
511 bfd *output_bfd, char **error_message)
513 if ((symbol->flags & (BSF_GLOBAL | BSF_WEAK)) != 0
514 || bfd_is_und_section (bfd_get_section (symbol))
515 || bfd_is_com_section (bfd_get_section (symbol)))
516 /* The relocation is against a global symbol. */
517 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
518 input_section, output_bfd,
519 error_message);
521 return score_elf_hi16_reloc (abfd, reloc_entry, symbol, data,
522 input_section, output_bfd, error_message);
525 static bfd_reloc_status_type
526 score_elf_got_lo16_reloc (bfd *abfd,
527 arelent *reloc_entry,
528 asymbol *symbol ATTRIBUTE_UNUSED,
529 void * data,
530 asection *input_section,
531 bfd *output_bfd ATTRIBUTE_UNUSED,
532 char **error_message ATTRIBUTE_UNUSED)
534 bfd_vma addend = 0, offset = 0;
535 signed long val;
536 signed long hi16_offset, hi16_value, uvalue;
538 hi16_value = bfd_get_32 (abfd, hi16_rel_addr);
539 hi16_offset = ((((hi16_value >> 16) & 0x3) << 15) | (hi16_value & 0x7fff)) >> 1;
540 addend = bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
541 offset = ((((addend >> 16) & 0x3) << 15) | (addend & 0x7fff)) >> 1;
542 val = reloc_entry->addend;
543 if (reloc_entry->address > input_section->size)
544 return bfd_reloc_outofrange;
545 uvalue = ((hi16_offset << 16) | (offset & 0xffff)) + val;
546 if ((uvalue > -0x8000) && (uvalue < 0x7fff))
547 hi16_offset = 0;
548 else
549 hi16_offset = (uvalue >> 16) & 0x7fff;
550 hi16_value = (hi16_value & ~0x37fff) | (hi16_offset & 0x7fff) | ((hi16_offset << 1) & 0x30000);
551 bfd_put_32 (abfd, hi16_value, hi16_rel_addr);
552 offset = (uvalue & 0xffff) << 1;
553 addend = (addend & ~0x37fff) | (offset & 0x7fff) | ((offset << 1) & 0x30000);
554 bfd_put_32 (abfd, addend, (bfd_byte *) data + reloc_entry->address);
555 return bfd_reloc_ok;
558 static reloc_howto_type elf32_score_howto_table[] =
560 /* No relocation. */
561 HOWTO (R_SCORE_NONE, /* type */
562 0, /* rightshift */
563 0, /* size (0 = byte, 1 = short, 2 = long) */
564 0, /* bitsize */
565 FALSE, /* pc_relative */
566 0, /* bitpos */
567 complain_overflow_dont,/* complain_on_overflow */
568 bfd_elf_generic_reloc, /* special_function */
569 "R_SCORE_NONE", /* name */
570 FALSE, /* partial_inplace */
571 0, /* src_mask */
572 0, /* dst_mask */
573 FALSE), /* pcrel_offset */
575 /* R_SCORE_HI16 */
576 HOWTO (R_SCORE_HI16, /* type */
577 0, /* rightshift */
578 2, /* size (0 = byte, 1 = short, 2 = long) */
579 16, /* bitsize */
580 FALSE, /* pc_relative */
581 1, /* bitpos */
582 complain_overflow_dont,/* complain_on_overflow */
583 score_elf_hi16_reloc, /* special_function */
584 "R_SCORE_HI16", /* name */
585 TRUE, /* partial_inplace */
586 0x37fff, /* src_mask */
587 0x37fff, /* dst_mask */
588 FALSE), /* pcrel_offset */
590 /* R_SCORE_LO16 */
591 HOWTO (R_SCORE_LO16, /* type */
592 0, /* rightshift */
593 2, /* size (0 = byte, 1 = short, 2 = long) */
594 16, /* bitsize */
595 FALSE, /* pc_relative */
596 1, /* bitpos */
597 complain_overflow_dont,/* complain_on_overflow */
598 score_elf_lo16_reloc, /* special_function */
599 "R_SCORE_LO16", /* name */
600 TRUE, /* partial_inplace */
601 0x37fff, /* src_mask */
602 0x37fff, /* dst_mask */
603 FALSE), /* pcrel_offset */
605 /* R_SCORE_DUMMY1 */
606 HOWTO (R_SCORE_DUMMY1, /* type */
607 0, /* rightshift */
608 2, /* size (0 = byte, 1 = short, 2 = long) */
609 16, /* bitsize */
610 FALSE, /* pc_relative */
611 1, /* bitpos */
612 complain_overflow_dont,/* complain_on_overflow */
613 bfd_elf_generic_reloc, /* special_function */
614 "R_SCORE_DUMMY1", /* name */
615 TRUE, /* partial_inplace */
616 0x0000ffff, /* src_mask */
617 0x0000ffff, /* dst_mask */
618 FALSE), /* pcrel_offset */
620 /*R_SCORE_24 */
621 HOWTO (R_SCORE_24, /* type */
622 1, /* rightshift */
623 2, /* size (0 = byte, 1 = short, 2 = long) */
624 24, /* bitsize */
625 FALSE, /* pc_relative */
626 1, /* bitpos */
627 complain_overflow_dont,/* complain_on_overflow */
628 bfd_elf_generic_reloc, /* special_function */
629 "R_SCORE_24", /* name */
630 FALSE, /* partial_inplace */
631 0x3ff7fff, /* src_mask */
632 0x3ff7fff, /* dst_mask */
633 FALSE), /* pcrel_offset */
635 /*R_SCORE_PC19 */
636 HOWTO (R_SCORE_PC19, /* type */
637 1, /* rightshift */
638 2, /* size (0 = byte, 1 = short, 2 = long) */
639 19, /* bitsize */
640 TRUE, /* pc_relative */
641 1, /* bitpos */
642 complain_overflow_dont,/* complain_on_overflow */
643 bfd_elf_generic_reloc, /* special_function */
644 "R_SCORE_PC19", /* name */
645 FALSE, /* partial_inplace */
646 0x3ff03fe, /* src_mask */
647 0x3ff03fe, /* dst_mask */
648 FALSE), /* pcrel_offset */
650 /*R_SCORE16_11 */
651 HOWTO (R_SCORE16_11, /* type */
652 1, /* rightshift */
653 1, /* size (0 = byte, 1 = short, 2 = long) */
654 11, /* bitsize */
655 FALSE, /* pc_relative */
656 1, /* bitpos */
657 complain_overflow_dont,/* complain_on_overflow */
658 bfd_elf_generic_reloc, /* special_function */
659 "R_SCORE16_11", /* name */
660 FALSE, /* partial_inplace */
661 0x000000ffe, /* src_mask */
662 0x000000ffe, /* dst_mask */
663 FALSE), /* pcrel_offset */
665 /* R_SCORE16_PC8 */
666 HOWTO (R_SCORE16_PC8, /* type */
667 1, /* rightshift */
668 1, /* size (0 = byte, 1 = short, 2 = long) */
669 8, /* bitsize */
670 TRUE, /* pc_relative */
671 0, /* bitpos */
672 complain_overflow_dont,/* complain_on_overflow */
673 bfd_elf_generic_reloc, /* special_function */
674 "R_SCORE16_PC8", /* name */
675 FALSE, /* partial_inplace */
676 0x000000ff, /* src_mask */
677 0x000000ff, /* dst_mask */
678 FALSE), /* pcrel_offset */
680 /* 32 bit absolute */
681 HOWTO (R_SCORE_ABS32, /* type 8 */
682 0, /* rightshift */
683 2, /* size (0 = byte, 1 = short, 2 = long) */
684 32, /* bitsize */
685 FALSE, /* pc_relative */
686 0, /* bitpos */
687 complain_overflow_bitfield, /* complain_on_overflow */
688 bfd_elf_generic_reloc, /* special_function */
689 "R_SCORE_ABS32", /* name */
690 FALSE, /* partial_inplace */
691 0xffffffff, /* src_mask */
692 0xffffffff, /* dst_mask */
693 FALSE), /* pcrel_offset */
695 /* 16 bit absolute */
696 HOWTO (R_SCORE_ABS16, /* type 11 */
697 0, /* rightshift */
698 1, /* size (0 = byte, 1 = short, 2 = long) */
699 16, /* bitsize */
700 FALSE, /* pc_relative */
701 0, /* bitpos */
702 complain_overflow_bitfield, /* complain_on_overflow */
703 bfd_elf_generic_reloc, /* special_function */
704 "R_SCORE_ABS16", /* name */
705 FALSE, /* partial_inplace */
706 0x0000ffff, /* src_mask */
707 0x0000ffff, /* dst_mask */
708 FALSE), /* pcrel_offset */
710 /* R_SCORE_DUMMY2 */
711 HOWTO (R_SCORE_DUMMY2, /* type */
712 0, /* rightshift */
713 2, /* size (0 = byte, 1 = short, 2 = long) */
714 16, /* bitsize */
715 FALSE, /* pc_relative */
716 0, /* bitpos */
717 complain_overflow_dont,/* complain_on_overflow */
718 bfd_elf_generic_reloc, /* special_function */
719 "R_SCORE_DUMMY2", /* name */
720 TRUE, /* partial_inplace */
721 0x00007fff, /* src_mask */
722 0x00007fff, /* dst_mask */
723 FALSE), /* pcrel_offset */
725 /* R_SCORE_GP15 */
726 HOWTO (R_SCORE_GP15, /* type */
727 0, /* rightshift */
728 2, /* size (0 = byte, 1 = short, 2 = long) */
729 16, /* bitsize */
730 FALSE, /* pc_relative */
731 0, /* bitpos */
732 complain_overflow_dont,/* complain_on_overflow */
733 score_elf_gprel15_reloc,/* special_function */
734 "R_SCORE_GP15", /* name */
735 TRUE, /* partial_inplace */
736 0x00007fff, /* src_mask */
737 0x00007fff, /* dst_mask */
738 FALSE), /* pcrel_offset */
740 /* GNU extension to record C++ vtable hierarchy. */
741 HOWTO (R_SCORE_GNU_VTINHERIT, /* type */
742 0, /* rightshift */
743 2, /* size (0 = byte, 1 = short, 2 = long) */
744 0, /* bitsize */
745 FALSE, /* pc_relative */
746 0, /* bitpos */
747 complain_overflow_dont,/* complain_on_overflow */
748 NULL, /* special_function */
749 "R_SCORE_GNU_VTINHERIT", /* name */
750 FALSE, /* partial_inplace */
751 0, /* src_mask */
752 0, /* dst_mask */
753 FALSE), /* pcrel_offset */
755 /* GNU extension to record C++ vtable member usage */
756 HOWTO (R_SCORE_GNU_VTENTRY, /* type */
757 0, /* rightshift */
758 2, /* size (0 = byte, 1 = short, 2 = long) */
759 0, /* bitsize */
760 FALSE, /* pc_relative */
761 0, /* bitpos */
762 complain_overflow_dont,/* complain_on_overflow */
763 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
764 "R_SCORE_GNU_VTENTRY", /* name */
765 FALSE, /* partial_inplace */
766 0, /* src_mask */
767 0, /* dst_mask */
768 FALSE), /* pcrel_offset */
770 /* Reference to global offset table. */
771 HOWTO (R_SCORE_GOT15, /* type */
772 0, /* rightshift */
773 2, /* size (0 = byte, 1 = short, 2 = long) */
774 16, /* bitsize */
775 FALSE, /* pc_relative */
776 0, /* bitpos */
777 complain_overflow_signed, /* complain_on_overflow */
778 score_elf_got15_reloc, /* special_function */
779 "R_SCORE_GOT15", /* name */
780 TRUE, /* partial_inplace */
781 0x00007fff, /* src_mask */
782 0x00007fff, /* dst_mask */
783 FALSE), /* pcrel_offset */
785 /* Low 16 bits of displacement in global offset table. */
786 HOWTO (R_SCORE_GOT_LO16, /* type */
787 0, /* rightshift */
788 2, /* size (0 = byte, 1 = short, 2 = long) */
789 16, /* bitsize */
790 FALSE, /* pc_relative */
791 1, /* bitpos */
792 complain_overflow_dont,/* complain_on_overflow */
793 score_elf_got_lo16_reloc, /* special_function */
794 "R_SCORE_GOT_LO16", /* name */
795 TRUE, /* partial_inplace */
796 0x37ffe, /* src_mask */
797 0x37ffe, /* dst_mask */
798 FALSE), /* pcrel_offset */
800 /* 15 bit call through global offset table. */
801 HOWTO (R_SCORE_CALL15, /* type */
802 0, /* rightshift */
803 2, /* size (0 = byte, 1 = short, 2 = long) */
804 16, /* bitsize */
805 FALSE, /* pc_relative */
806 0, /* bitpos */
807 complain_overflow_signed, /* complain_on_overflow */
808 bfd_elf_generic_reloc, /* special_function */
809 "R_SCORE_CALL15", /* name */
810 TRUE, /* partial_inplace */
811 0x0000ffff, /* src_mask */
812 0x0000ffff, /* dst_mask */
813 FALSE), /* pcrel_offset */
815 /* 32 bit GP relative reference. */
816 HOWTO (R_SCORE_GPREL32, /* type */
817 0, /* rightshift */
818 2, /* size (0 = byte, 1 = short, 2 = long) */
819 32, /* bitsize */
820 FALSE, /* pc_relative */
821 0, /* bitpos */
822 complain_overflow_dont,/* complain_on_overflow */
823 score_elf_gprel32_reloc, /* special_function */
824 "R_SCORE_GPREL32", /* name */
825 TRUE, /* partial_inplace */
826 0xffffffff, /* src_mask */
827 0xffffffff, /* dst_mask */
828 FALSE), /* pcrel_offset */
830 /* 32 bit symbol relative relocation. */
831 HOWTO (R_SCORE_REL32, /* type */
832 0, /* rightshift */
833 2, /* size (0 = byte, 1 = short, 2 = long) */
834 32, /* bitsize */
835 FALSE, /* pc_relative */
836 0, /* bitpos */
837 complain_overflow_dont,/* complain_on_overflow */
838 bfd_elf_generic_reloc, /* special_function */
839 "R_SCORE_REL32", /* name */
840 TRUE, /* partial_inplace */
841 0xffffffff, /* src_mask */
842 0xffffffff, /* dst_mask */
843 FALSE), /* pcrel_offset */
845 /* R_SCORE_DUMMY_HI16 */
846 HOWTO (R_SCORE_DUMMY_HI16, /* type */
847 0, /* rightshift */
848 2, /* size (0 = byte, 1 = short, 2 = long) */
849 16, /* bitsize */
850 FALSE, /* pc_relative */
851 1, /* bitpos */
852 complain_overflow_dont,/* complain_on_overflow */
853 score_elf_hi16_reloc, /* special_function */
854 "R_SCORE_DUMMY_HI16", /* name */
855 TRUE, /* partial_inplace */
856 0x37fff, /* src_mask */
857 0x37fff, /* dst_mask */
858 FALSE), /* pcrel_offset */
861 struct score_reloc_map
863 bfd_reloc_code_real_type bfd_reloc_val;
864 unsigned char elf_reloc_val;
867 static const struct score_reloc_map elf32_score_reloc_map[] =
869 {BFD_RELOC_NONE, R_SCORE_NONE},
870 {BFD_RELOC_HI16_S, R_SCORE_HI16},
871 {BFD_RELOC_LO16, R_SCORE_LO16},
872 {BFD_RELOC_SCORE_DUMMY1, R_SCORE_DUMMY1},
873 {BFD_RELOC_SCORE_JMP, R_SCORE_24},
874 {BFD_RELOC_SCORE_BRANCH, R_SCORE_PC19},
875 {BFD_RELOC_SCORE16_JMP, R_SCORE16_11},
876 {BFD_RELOC_SCORE16_BRANCH, R_SCORE16_PC8},
877 {BFD_RELOC_32, R_SCORE_ABS32},
878 {BFD_RELOC_16, R_SCORE_ABS16},
879 {BFD_RELOC_SCORE_DUMMY2, R_SCORE_DUMMY2},
880 {BFD_RELOC_SCORE_GPREL15, R_SCORE_GP15},
881 {BFD_RELOC_VTABLE_INHERIT, R_SCORE_GNU_VTINHERIT},
882 {BFD_RELOC_VTABLE_ENTRY, R_SCORE_GNU_VTENTRY},
883 {BFD_RELOC_SCORE_GOT15, R_SCORE_GOT15},
884 {BFD_RELOC_SCORE_GOT_LO16, R_SCORE_GOT_LO16},
885 {BFD_RELOC_SCORE_CALL15, R_SCORE_CALL15},
886 {BFD_RELOC_GPREL32, R_SCORE_GPREL32},
887 {BFD_RELOC_32_PCREL, R_SCORE_REL32},
888 {BFD_RELOC_SCORE_DUMMY_HI16, R_SCORE_DUMMY_HI16},
891 /* got_entries only match if they're identical, except for gotidx, so
892 use all fields to compute the hash, and compare the appropriate
893 union members. */
895 static hashval_t
896 score_elf_got_entry_hash (const void *entry_)
898 const struct score_got_entry *entry = (struct score_got_entry *)entry_;
900 return entry->symndx
901 + (!entry->abfd ? entry->d.address : entry->abfd->id);
904 static int
905 score_elf_got_entry_eq (const void *entry1, const void *entry2)
907 const struct score_got_entry *e1 = (struct score_got_entry *)entry1;
908 const struct score_got_entry *e2 = (struct score_got_entry *)entry2;
910 return e1->abfd == e2->abfd && e1->symndx == e2->symndx
911 && (! e1->abfd ? e1->d.address == e2->d.address
912 : e1->symndx >= 0 ? e1->d.addend == e2->d.addend
913 : e1->d.h == e2->d.h);
916 /* If H needs a GOT entry, assign it the highest available dynamic
917 index. Otherwise, assign it the lowest available dynamic
918 index. */
920 static bfd_boolean
921 score_elf_sort_hash_table_f (struct score_elf_link_hash_entry *h, void *data)
923 struct score_elf_hash_sort_data *hsd = data;
925 if (h->root.root.type == bfd_link_hash_warning)
926 h = (struct score_elf_link_hash_entry *) h->root.root.u.i.link;
928 /* Symbols without dynamic symbol table entries aren't interesting at all. */
929 if (h->root.dynindx == -1)
930 return TRUE;
932 /* Global symbols that need GOT entries that are not explicitly
933 referenced are marked with got offset 2. Those that are
934 referenced get a 1, and those that don't need GOT entries get
935 -1. */
936 if (h->root.got.offset == 2)
938 if (hsd->max_unref_got_dynindx == hsd->min_got_dynindx)
939 hsd->low = (struct elf_link_hash_entry *) h;
940 h->root.dynindx = hsd->max_unref_got_dynindx++;
942 else if (h->root.got.offset != 1)
943 h->root.dynindx = hsd->max_non_got_dynindx++;
944 else
946 h->root.dynindx = --hsd->min_got_dynindx;
947 hsd->low = (struct elf_link_hash_entry *) h;
950 return TRUE;
953 static asection *
954 score_elf_got_section (bfd *abfd, bfd_boolean maybe_excluded)
956 asection *sgot = bfd_get_section_by_name (abfd, ".got");
958 if (sgot == NULL || (! maybe_excluded && (sgot->flags & SEC_EXCLUDE) != 0))
959 return NULL;
960 return sgot;
963 /* Returns the GOT information associated with the link indicated by
964 INFO. If SGOTP is non-NULL, it is filled in with the GOT section. */
966 static struct score_got_info *
967 score_elf_got_info (bfd *abfd, asection **sgotp)
969 asection *sgot;
970 struct score_got_info *g;
972 sgot = score_elf_got_section (abfd, TRUE);
973 BFD_ASSERT (sgot != NULL);
974 BFD_ASSERT (elf_section_data (sgot) != NULL);
975 g = score_elf_section_data (sgot)->u.got_info;
976 BFD_ASSERT (g != NULL);
978 if (sgotp)
979 *sgotp = sgot;
980 return g;
983 /* Sort the dynamic symbol table so that symbols that need GOT entries
984 appear towards the end. This reduces the amount of GOT space
985 required. MAX_LOCAL is used to set the number of local symbols
986 known to be in the dynamic symbol table. During
987 _bfd_score_elf_size_dynamic_sections, this value is 1. Afterward, the
988 section symbols are added and the count is higher. */
990 static bfd_boolean
991 score_elf_sort_hash_table (struct bfd_link_info *info,
992 unsigned long max_local)
994 struct score_elf_hash_sort_data hsd;
995 struct score_got_info *g;
996 bfd *dynobj;
998 dynobj = elf_hash_table (info)->dynobj;
1000 g = score_elf_got_info (dynobj, NULL);
1002 hsd.low = NULL;
1003 hsd.max_unref_got_dynindx =
1004 hsd.min_got_dynindx = elf_hash_table (info)->dynsymcount
1005 /* In the multi-got case, assigned_gotno of the master got_info
1006 indicate the number of entries that aren't referenced in the
1007 primary GOT, but that must have entries because there are
1008 dynamic relocations that reference it. Since they aren't
1009 referenced, we move them to the end of the GOT, so that they
1010 don't prevent other entries that are referenced from getting
1011 too large offsets. */
1012 - (g->next ? g->assigned_gotno : 0);
1013 hsd.max_non_got_dynindx = max_local;
1014 score_elf_link_hash_traverse (((struct score_elf_link_hash_table *)
1015 elf_hash_table (info)),
1016 score_elf_sort_hash_table_f,
1017 &hsd);
1019 /* There should have been enough room in the symbol table to
1020 accommodate both the GOT and non-GOT symbols. */
1021 BFD_ASSERT (hsd.max_non_got_dynindx <= hsd.min_got_dynindx);
1022 BFD_ASSERT ((unsigned long)hsd.max_unref_got_dynindx
1023 <= elf_hash_table (info)->dynsymcount);
1025 /* Now we know which dynamic symbol has the lowest dynamic symbol
1026 table index in the GOT. */
1027 g->global_gotsym = hsd.low;
1029 return TRUE;
1032 /* Create an entry in an score ELF linker hash table. */
1034 static struct bfd_hash_entry *
1035 score_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
1036 struct bfd_hash_table *table,
1037 const char *string)
1039 struct score_elf_link_hash_entry *ret = (struct score_elf_link_hash_entry *)entry;
1041 /* Allocate the structure if it has not already been allocated by a subclass. */
1042 if (ret == NULL)
1043 ret = bfd_hash_allocate (table, sizeof (struct score_elf_link_hash_entry));
1044 if (ret == NULL)
1045 return (struct bfd_hash_entry *)ret;
1047 /* Call the allocation method of the superclass. */
1048 ret = ((struct score_elf_link_hash_entry *)
1049 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *)ret, table, string));
1051 if (ret != NULL)
1053 ret->possibly_dynamic_relocs = 0;
1054 ret->readonly_reloc = FALSE;
1055 ret->no_fn_stub = FALSE;
1056 ret->forced_local = FALSE;
1059 return (struct bfd_hash_entry *)ret;
1062 /* Returns the first relocation of type r_type found, beginning with
1063 RELOCATION. RELEND is one-past-the-end of the relocation table. */
1065 static const Elf_Internal_Rela *
1066 score_elf_next_relocation (bfd *abfd ATTRIBUTE_UNUSED, unsigned int r_type,
1067 const Elf_Internal_Rela *relocation,
1068 const Elf_Internal_Rela *relend)
1070 while (relocation < relend)
1072 if (ELF32_R_TYPE (relocation->r_info) == r_type)
1073 return relocation;
1075 ++relocation;
1078 /* We didn't find it. */
1079 bfd_set_error (bfd_error_bad_value);
1080 return NULL;
1083 /* This function is called via qsort() to sort the dynamic relocation
1084 entries by increasing r_symndx value. */
1086 static int
1087 score_elf_sort_dynamic_relocs (const void *arg1, const void *arg2)
1089 Elf_Internal_Rela int_reloc1;
1090 Elf_Internal_Rela int_reloc2;
1092 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd, arg1, &int_reloc1);
1093 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd, arg2, &int_reloc2);
1095 return (ELF32_R_SYM (int_reloc1.r_info) - ELF32_R_SYM (int_reloc2.r_info));
1098 /* Return whether a relocation is against a local symbol. */
1100 static bfd_boolean
1101 score_elf_local_relocation_p (bfd *input_bfd,
1102 const Elf_Internal_Rela *relocation,
1103 asection **local_sections,
1104 bfd_boolean check_forced)
1106 unsigned long r_symndx;
1107 Elf_Internal_Shdr *symtab_hdr;
1108 struct score_elf_link_hash_entry *h;
1109 size_t extsymoff;
1111 r_symndx = ELF32_R_SYM (relocation->r_info);
1112 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1113 extsymoff = (elf_bad_symtab (input_bfd)) ? 0 : symtab_hdr->sh_info;
1115 if (r_symndx < extsymoff)
1116 return TRUE;
1117 if (elf_bad_symtab (input_bfd) && local_sections[r_symndx] != NULL)
1118 return TRUE;
1120 if (check_forced)
1122 /* Look up the hash table to check whether the symbol was forced local. */
1123 h = (struct score_elf_link_hash_entry *)
1124 elf_sym_hashes (input_bfd) [r_symndx - extsymoff];
1125 /* Find the real hash-table entry for this symbol. */
1126 while (h->root.root.type == bfd_link_hash_indirect
1127 || h->root.root.type == bfd_link_hash_warning)
1128 h = (struct score_elf_link_hash_entry *) h->root.root.u.i.link;
1129 if (h->root.forced_local)
1130 return TRUE;
1133 return FALSE;
1136 /* Returns the dynamic relocation section for DYNOBJ. */
1138 static asection *
1139 score_elf_rel_dyn_section (bfd *dynobj, bfd_boolean create_p)
1141 static const char dname[] = ".rel.dyn";
1142 asection *sreloc;
1144 sreloc = bfd_get_section_by_name (dynobj, dname);
1145 if (sreloc == NULL && create_p)
1147 sreloc = bfd_make_section_with_flags (dynobj, dname,
1148 (SEC_ALLOC
1149 | SEC_LOAD
1150 | SEC_HAS_CONTENTS
1151 | SEC_IN_MEMORY
1152 | SEC_LINKER_CREATED
1153 | SEC_READONLY));
1154 if (sreloc == NULL
1155 || ! bfd_set_section_alignment (dynobj, sreloc,
1156 SCORE_ELF_LOG_FILE_ALIGN (dynobj)))
1157 return NULL;
1159 return sreloc;
1162 static void
1163 score_elf_allocate_dynamic_relocations (bfd *abfd, unsigned int n)
1165 asection *s;
1167 s = score_elf_rel_dyn_section (abfd, FALSE);
1168 BFD_ASSERT (s != NULL);
1170 if (s->size == 0)
1172 /* Make room for a null element. */
1173 s->size += SCORE_ELF_REL_SIZE (abfd);
1174 ++s->reloc_count;
1176 s->size += n * SCORE_ELF_REL_SIZE (abfd);
1179 /* Create a rel.dyn relocation for the dynamic linker to resolve. REL
1180 is the original relocation, which is now being transformed into a
1181 dynamic relocation. The ADDENDP is adjusted if necessary; the
1182 caller should store the result in place of the original addend. */
1184 static bfd_boolean
1185 score_elf_create_dynamic_relocation (bfd *output_bfd,
1186 struct bfd_link_info *info,
1187 const Elf_Internal_Rela *rel,
1188 struct score_elf_link_hash_entry *h,
1189 bfd_vma symbol,
1190 bfd_vma *addendp, asection *input_section)
1192 Elf_Internal_Rela outrel[3];
1193 asection *sreloc;
1194 bfd *dynobj;
1195 int r_type;
1196 long indx;
1197 bfd_boolean defined_p;
1199 r_type = ELF32_R_TYPE (rel->r_info);
1200 dynobj = elf_hash_table (info)->dynobj;
1201 sreloc = score_elf_rel_dyn_section (dynobj, FALSE);
1202 BFD_ASSERT (sreloc != NULL);
1203 BFD_ASSERT (sreloc->contents != NULL);
1204 BFD_ASSERT (sreloc->reloc_count * SCORE_ELF_REL_SIZE (output_bfd) < sreloc->size);
1206 outrel[0].r_offset =
1207 _bfd_elf_section_offset (output_bfd, info, input_section, rel[0].r_offset);
1208 outrel[1].r_offset =
1209 _bfd_elf_section_offset (output_bfd, info, input_section, rel[1].r_offset);
1210 outrel[2].r_offset =
1211 _bfd_elf_section_offset (output_bfd, info, input_section, rel[2].r_offset);
1213 if (outrel[0].r_offset == MINUS_ONE)
1214 /* The relocation field has been deleted. */
1215 return TRUE;
1217 if (outrel[0].r_offset == MINUS_TWO)
1219 /* The relocation field has been converted into a relative value of
1220 some sort. Functions like _bfd_elf_write_section_eh_frame expect
1221 the field to be fully relocated, so add in the symbol's value. */
1222 *addendp += symbol;
1223 return TRUE;
1226 /* We must now calculate the dynamic symbol table index to use
1227 in the relocation. */
1228 if (h != NULL
1229 && (! info->symbolic || !h->root.def_regular)
1230 /* h->root.dynindx may be -1 if this symbol was marked to
1231 become local. */
1232 && h->root.dynindx != -1)
1234 indx = h->root.dynindx;
1235 /* ??? glibc's ld.so just adds the final GOT entry to the
1236 relocation field. It therefore treats relocs against
1237 defined symbols in the same way as relocs against
1238 undefined symbols. */
1239 defined_p = FALSE;
1241 else
1243 indx = 0;
1244 defined_p = TRUE;
1247 /* If the relocation was previously an absolute relocation and
1248 this symbol will not be referred to by the relocation, we must
1249 adjust it by the value we give it in the dynamic symbol table.
1250 Otherwise leave the job up to the dynamic linker. */
1251 if (defined_p && r_type != R_SCORE_REL32)
1252 *addendp += symbol;
1254 /* The relocation is always an REL32 relocation because we don't
1255 know where the shared library will wind up at load-time. */
1256 outrel[0].r_info = ELF32_R_INFO ((unsigned long) indx, R_SCORE_REL32);
1258 /* For strict adherence to the ABI specification, we should
1259 generate a R_SCORE_64 relocation record by itself before the
1260 _REL32/_64 record as well, such that the addend is read in as
1261 a 64-bit value (REL32 is a 32-bit relocation, after all).
1262 However, since none of the existing ELF64 SCORE dynamic
1263 loaders seems to care, we don't waste space with these
1264 artificial relocations. If this turns out to not be true,
1265 score_elf_allocate_dynamic_relocations() should be tweaked so
1266 as to make room for a pair of dynamic relocations per
1267 invocation if ABI_64_P, and here we should generate an
1268 additional relocation record with R_SCORE_64 by itself for a
1269 NULL symbol before this relocation record. */
1270 outrel[1].r_info = ELF32_R_INFO (0, R_SCORE_NONE);
1271 outrel[2].r_info = ELF32_R_INFO (0, R_SCORE_NONE);
1273 /* Adjust the output offset of the relocation to reference the
1274 correct location in the output file. */
1275 outrel[0].r_offset += (input_section->output_section->vma
1276 + input_section->output_offset);
1277 outrel[1].r_offset += (input_section->output_section->vma
1278 + input_section->output_offset);
1279 outrel[2].r_offset += (input_section->output_section->vma
1280 + input_section->output_offset);
1282 /* Put the relocation back out. We have to use the special
1283 relocation outputter in the 64-bit case since the 64-bit
1284 relocation format is non-standard. */
1285 bfd_elf32_swap_reloc_out
1286 (output_bfd, &outrel[0],
1287 (sreloc->contents + sreloc->reloc_count * sizeof (Elf32_External_Rel)));
1289 /* We've now added another relocation. */
1290 ++sreloc->reloc_count;
1292 /* Make sure the output section is writable. The dynamic linker
1293 will be writing to it. */
1294 elf_section_data (input_section->output_section)->this_hdr.sh_flags |= SHF_WRITE;
1296 return TRUE;
1299 static bfd_boolean
1300 score_elf_create_got_section (bfd *abfd,
1301 struct bfd_link_info *info,
1302 bfd_boolean maybe_exclude)
1304 flagword flags;
1305 asection *s;
1306 struct elf_link_hash_entry *h;
1307 struct bfd_link_hash_entry *bh;
1308 struct score_got_info *g;
1309 bfd_size_type amt;
1311 /* This function may be called more than once. */
1312 s = score_elf_got_section (abfd, TRUE);
1313 if (s)
1315 if (! maybe_exclude)
1316 s->flags &= ~SEC_EXCLUDE;
1317 return TRUE;
1320 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
1322 if (maybe_exclude)
1323 flags |= SEC_EXCLUDE;
1325 /* We have to use an alignment of 2**4 here because this is hardcoded
1326 in the function stub generation and in the linker script. */
1327 s = bfd_make_section_with_flags (abfd, ".got", flags);
1328 if (s == NULL
1329 || ! bfd_set_section_alignment (abfd, s, 4))
1330 return FALSE;
1332 /* Define the symbol _GLOBAL_OFFSET_TABLE_. We don't do this in the
1333 linker script because we don't want to define the symbol if we
1334 are not creating a global offset table. */
1335 bh = NULL;
1336 if (! (_bfd_generic_link_add_one_symbol
1337 (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL, s,
1338 0, NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
1339 return FALSE;
1341 h = (struct elf_link_hash_entry *) bh;
1342 h->non_elf = 0;
1343 h->def_regular = 1;
1344 h->type = STT_OBJECT;
1346 if (info->shared && ! bfd_elf_link_record_dynamic_symbol (info, h))
1347 return FALSE;
1349 amt = sizeof (struct score_got_info);
1350 g = bfd_alloc (abfd, amt);
1351 if (g == NULL)
1352 return FALSE;
1354 g->global_gotsym = NULL;
1355 g->global_gotno = 0;
1357 g->local_gotno = SCORE_RESERVED_GOTNO;
1358 g->assigned_gotno = SCORE_RESERVED_GOTNO;
1359 g->next = NULL;
1361 g->got_entries = htab_try_create (1, score_elf_got_entry_hash,
1362 score_elf_got_entry_eq, NULL);
1363 if (g->got_entries == NULL)
1364 return FALSE;
1365 score_elf_section_data (s)->u.got_info = g;
1366 score_elf_section_data (s)->elf.this_hdr.sh_flags |= SHF_ALLOC | SHF_WRITE | SHF_SCORE_GPREL;
1368 return TRUE;
1371 /* Calculate the %high function. */
1373 static bfd_vma
1374 score_elf_high (bfd_vma value)
1376 return ((value + (bfd_vma) 0x8000) >> 16) & 0xffff;
1379 /* Create a local GOT entry for VALUE. Return the index of the entry,
1380 or -1 if it could not be created. */
1382 static struct score_got_entry *
1383 score_elf_create_local_got_entry (bfd *abfd,
1384 bfd *ibfd ATTRIBUTE_UNUSED,
1385 struct score_got_info *gg,
1386 asection *sgot, bfd_vma value,
1387 unsigned long r_symndx ATTRIBUTE_UNUSED,
1388 struct score_elf_link_hash_entry *h ATTRIBUTE_UNUSED,
1389 int r_type ATTRIBUTE_UNUSED)
1391 struct score_got_entry entry, **loc;
1392 struct score_got_info *g;
1394 entry.abfd = NULL;
1395 entry.symndx = -1;
1396 entry.d.address = value;
1398 g = gg;
1399 loc = (struct score_got_entry **) htab_find_slot (g->got_entries, &entry, INSERT);
1400 if (*loc)
1401 return *loc;
1403 entry.gotidx = SCORE_ELF_GOT_SIZE (abfd) * g->assigned_gotno++;
1405 *loc = bfd_alloc (abfd, sizeof entry);
1407 if (! *loc)
1408 return NULL;
1410 memcpy (*loc, &entry, sizeof entry);
1412 if (g->assigned_gotno >= g->local_gotno)
1414 (*loc)->gotidx = -1;
1415 /* We didn't allocate enough space in the GOT. */
1416 (*_bfd_error_handler)
1417 (_("not enough GOT space for local GOT entries"));
1418 bfd_set_error (bfd_error_bad_value);
1419 return NULL;
1422 bfd_put_32 (abfd, value, (sgot->contents + entry.gotidx));
1424 return *loc;
1427 /* Find a GOT entry whose higher-order 16 bits are the same as those
1428 for value. Return the index into the GOT for this entry. */
1430 static bfd_vma
1431 score_elf_got16_entry (bfd *abfd, bfd *ibfd, struct bfd_link_info *info,
1432 bfd_vma value, bfd_boolean external)
1434 asection *sgot;
1435 struct score_got_info *g;
1436 struct score_got_entry *entry;
1438 if (!external)
1440 /* Although the ABI says that it is "the high-order 16 bits" that we
1441 want, it is really the %high value. The complete value is
1442 calculated with a `addiu' of a LO16 relocation, just as with a
1443 HI16/LO16 pair. */
1444 value = score_elf_high (value) << 16;
1447 g = score_elf_got_info (elf_hash_table (info)->dynobj, &sgot);
1449 entry = score_elf_create_local_got_entry (abfd, ibfd, g, sgot, value, 0, NULL,
1450 R_SCORE_GOT15);
1451 if (entry)
1452 return entry->gotidx;
1453 else
1454 return MINUS_ONE;
1457 static void
1458 _bfd_score_elf_hide_symbol (struct bfd_link_info *info,
1459 struct elf_link_hash_entry *entry,
1460 bfd_boolean force_local)
1462 bfd *dynobj;
1463 asection *got;
1464 struct score_got_info *g;
1465 struct score_elf_link_hash_entry *h;
1467 h = (struct score_elf_link_hash_entry *) entry;
1468 if (h->forced_local)
1469 return;
1470 h->forced_local = TRUE;
1472 dynobj = elf_hash_table (info)->dynobj;
1473 if (dynobj != NULL && force_local)
1475 got = score_elf_got_section (dynobj, FALSE);
1476 if (got == NULL)
1477 return;
1478 g = score_elf_section_data (got)->u.got_info;
1480 if (g->next)
1482 struct score_got_entry e;
1483 struct score_got_info *gg = g;
1485 /* Since we're turning what used to be a global symbol into a
1486 local one, bump up the number of local entries of each GOT
1487 that had an entry for it. This will automatically decrease
1488 the number of global entries, since global_gotno is actually
1489 the upper limit of global entries. */
1490 e.abfd = dynobj;
1491 e.symndx = -1;
1492 e.d.h = h;
1494 for (g = g->next; g != gg; g = g->next)
1495 if (htab_find (g->got_entries, &e))
1497 BFD_ASSERT (g->global_gotno > 0);
1498 g->local_gotno++;
1499 g->global_gotno--;
1502 /* If this was a global symbol forced into the primary GOT, we
1503 no longer need an entry for it. We can't release the entry
1504 at this point, but we must at least stop counting it as one
1505 of the symbols that required a forced got entry. */
1506 if (h->root.got.offset == 2)
1508 BFD_ASSERT (gg->assigned_gotno > 0);
1509 gg->assigned_gotno--;
1512 else if (g->global_gotno == 0 && g->global_gotsym == NULL)
1513 /* If we haven't got through GOT allocation yet, just bump up the
1514 number of local entries, as this symbol won't be counted as
1515 global. */
1516 g->local_gotno++;
1517 else if (h->root.got.offset == 1)
1519 /* If we're past non-multi-GOT allocation and this symbol had
1520 been marked for a global got entry, give it a local entry
1521 instead. */
1522 BFD_ASSERT (g->global_gotno > 0);
1523 g->local_gotno++;
1524 g->global_gotno--;
1528 _bfd_elf_link_hash_hide_symbol (info, &h->root, force_local);
1531 /* If H is a symbol that needs a global GOT entry, but has a dynamic
1532 symbol table index lower than any we've seen to date, record it for
1533 posterity. */
1535 static bfd_boolean
1536 score_elf_record_global_got_symbol (struct elf_link_hash_entry *h,
1537 bfd *abfd,
1538 struct bfd_link_info *info,
1539 struct score_got_info *g)
1541 struct score_got_entry entry, **loc;
1543 /* A global symbol in the GOT must also be in the dynamic symbol table. */
1544 if (h->dynindx == -1)
1546 switch (ELF_ST_VISIBILITY (h->other))
1548 case STV_INTERNAL:
1549 case STV_HIDDEN:
1550 _bfd_score_elf_hide_symbol (info, h, TRUE);
1551 break;
1553 if (!bfd_elf_link_record_dynamic_symbol (info, h))
1554 return FALSE;
1557 entry.abfd = abfd;
1558 entry.symndx = -1;
1559 entry.d.h = (struct score_elf_link_hash_entry *)h;
1561 loc = (struct score_got_entry **)htab_find_slot (g->got_entries, &entry, INSERT);
1563 /* If we've already marked this entry as needing GOT space, we don't
1564 need to do it again. */
1565 if (*loc)
1566 return TRUE;
1568 *loc = bfd_alloc (abfd, sizeof entry);
1569 if (! *loc)
1570 return FALSE;
1572 entry.gotidx = -1;
1574 memcpy (*loc, &entry, sizeof (entry));
1576 if (h->got.offset != MINUS_ONE)
1577 return TRUE;
1579 /* By setting this to a value other than -1, we are indicating that
1580 there needs to be a GOT entry for H. Avoid using zero, as the
1581 generic ELF copy_indirect_symbol tests for <= 0. */
1582 h->got.offset = 1;
1584 return TRUE;
1587 /* Reserve space in G for a GOT entry containing the value of symbol
1588 SYMNDX in input bfd ABDF, plus ADDEND. */
1590 static bfd_boolean
1591 score_elf_record_local_got_symbol (bfd *abfd,
1592 long symndx,
1593 bfd_vma addend,
1594 struct score_got_info *g)
1596 struct score_got_entry entry, **loc;
1598 entry.abfd = abfd;
1599 entry.symndx = symndx;
1600 entry.d.addend = addend;
1601 loc = (struct score_got_entry **)htab_find_slot (g->got_entries, &entry, INSERT);
1603 if (*loc)
1604 return TRUE;
1606 entry.gotidx = g->local_gotno++;
1608 *loc = bfd_alloc (abfd, sizeof(entry));
1609 if (! *loc)
1610 return FALSE;
1612 memcpy (*loc, &entry, sizeof (entry));
1614 return TRUE;
1617 /* Returns the GOT offset at which the indicated address can be found.
1618 If there is not yet a GOT entry for this value, create one.
1619 Returns -1 if no satisfactory GOT offset can be found. */
1621 static bfd_vma
1622 score_elf_local_got_index (bfd *abfd, bfd *ibfd, struct bfd_link_info *info,
1623 bfd_vma value, unsigned long r_symndx,
1624 struct score_elf_link_hash_entry *h, int r_type)
1626 asection *sgot;
1627 struct score_got_info *g;
1628 struct score_got_entry *entry;
1630 g = score_elf_got_info (elf_hash_table (info)->dynobj, &sgot);
1632 entry = score_elf_create_local_got_entry (abfd, ibfd, g, sgot, value,
1633 r_symndx, h, r_type);
1634 if (!entry)
1635 return MINUS_ONE;
1637 else
1638 return entry->gotidx;
1641 /* Returns the GOT index for the global symbol indicated by H. */
1643 static bfd_vma
1644 score_elf_global_got_index (bfd *abfd, struct elf_link_hash_entry *h)
1646 bfd_vma index;
1647 asection *sgot;
1648 struct score_got_info *g;
1649 long global_got_dynindx = 0;
1651 g = score_elf_got_info (abfd, &sgot);
1652 if (g->global_gotsym != NULL)
1653 global_got_dynindx = g->global_gotsym->dynindx;
1655 /* Once we determine the global GOT entry with the lowest dynamic
1656 symbol table index, we must put all dynamic symbols with greater
1657 indices into the GOT. That makes it easy to calculate the GOT
1658 offset. */
1659 BFD_ASSERT (h->dynindx >= global_got_dynindx);
1660 index = ((h->dynindx - global_got_dynindx + g->local_gotno) * SCORE_ELF_GOT_SIZE (abfd));
1661 BFD_ASSERT (index < sgot->size);
1663 return index;
1666 /* Returns the offset for the entry at the INDEXth position in the GOT. */
1668 static bfd_vma
1669 score_elf_got_offset_from_index (bfd *dynobj, bfd *output_bfd,
1670 bfd *input_bfd ATTRIBUTE_UNUSED, bfd_vma index)
1672 asection *sgot;
1673 bfd_vma gp;
1674 struct score_got_info *g;
1676 g = score_elf_got_info (dynobj, &sgot);
1677 gp = _bfd_get_gp_value (output_bfd);
1679 return sgot->output_section->vma + sgot->output_offset + index - gp;
1682 /* Follow indirect and warning hash entries so that each got entry
1683 points to the final symbol definition. P must point to a pointer
1684 to the hash table we're traversing. Since this traversal may
1685 modify the hash table, we set this pointer to NULL to indicate
1686 we've made a potentially-destructive change to the hash table, so
1687 the traversal must be restarted. */
1688 static int
1689 score_elf_resolve_final_got_entry (void **entryp, void *p)
1691 struct score_got_entry *entry = (struct score_got_entry *)*entryp;
1692 htab_t got_entries = *(htab_t *)p;
1694 if (entry->abfd != NULL && entry->symndx == -1)
1696 struct score_elf_link_hash_entry *h = entry->d.h;
1698 while (h->root.root.type == bfd_link_hash_indirect
1699 || h->root.root.type == bfd_link_hash_warning)
1700 h = (struct score_elf_link_hash_entry *) h->root.root.u.i.link;
1702 if (entry->d.h == h)
1703 return 1;
1705 entry->d.h = h;
1707 /* If we can't find this entry with the new bfd hash, re-insert
1708 it, and get the traversal restarted. */
1709 if (! htab_find (got_entries, entry))
1711 htab_clear_slot (got_entries, entryp);
1712 entryp = htab_find_slot (got_entries, entry, INSERT);
1713 if (! *entryp)
1714 *entryp = entry;
1715 /* Abort the traversal, since the whole table may have
1716 moved, and leave it up to the parent to restart the
1717 process. */
1718 *(htab_t *)p = NULL;
1719 return 0;
1721 /* We might want to decrement the global_gotno count, but it's
1722 either too early or too late for that at this point. */
1725 return 1;
1728 /* Turn indirect got entries in a got_entries table into their final locations. */
1729 static void
1730 score_elf_resolve_final_got_entries (struct score_got_info *g)
1732 htab_t got_entries;
1736 got_entries = g->got_entries;
1738 htab_traverse (got_entries,
1739 score_elf_resolve_final_got_entry,
1740 &got_entries);
1742 while (got_entries == NULL);
1745 /* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS. for -r */
1747 static void
1748 score_elf_add_to_rel (bfd *abfd,
1749 bfd_byte *address,
1750 reloc_howto_type *howto,
1751 bfd_signed_vma increment)
1753 bfd_signed_vma addend;
1754 bfd_vma contents;
1755 unsigned long offset;
1756 unsigned long r_type = howto->type;
1757 unsigned long hi16_addend, hi16_offset, hi16_value, uvalue;
1759 contents = bfd_get_32 (abfd, address);
1760 /* Get the (signed) value from the instruction. */
1761 addend = contents & howto->src_mask;
1762 if (addend & ((howto->src_mask + 1) >> 1))
1764 bfd_signed_vma mask;
1766 mask = -1;
1767 mask &= ~howto->src_mask;
1768 addend |= mask;
1770 /* Add in the increment, (which is a byte value). */
1771 switch (r_type)
1773 case R_SCORE_PC19:
1774 offset =
1775 (((contents & howto->src_mask) & 0x3ff0000) >> 6) | ((contents & howto->src_mask) & 0x3ff);
1776 offset += increment;
1777 contents =
1778 (contents & ~howto->
1779 src_mask) | (((offset << 6) & howto->src_mask) & 0x3ff0000) | (offset & 0x3ff);
1780 bfd_put_32 (abfd, contents, address);
1781 break;
1782 case R_SCORE_HI16:
1783 break;
1784 case R_SCORE_LO16:
1785 hi16_addend = bfd_get_32 (abfd, address - 4);
1786 hi16_offset = ((((hi16_addend >> 16) & 0x3) << 15) | (hi16_addend & 0x7fff)) >> 1;
1787 offset = ((((contents >> 16) & 0x3) << 15) | (contents & 0x7fff)) >> 1;
1788 offset = (hi16_offset << 16) | (offset & 0xffff);
1789 uvalue = increment + offset;
1790 hi16_offset = (uvalue >> 16) << 1;
1791 hi16_value = (hi16_addend & (~(howto->dst_mask)))
1792 | (hi16_offset & 0x7fff) | ((hi16_offset << 1) & 0x30000);
1793 bfd_put_32 (abfd, hi16_value, address - 4);
1794 offset = (uvalue & 0xffff) << 1;
1795 contents = (contents & (~(howto->dst_mask))) | (offset & 0x7fff) | ((offset << 1) & 0x30000);
1796 bfd_put_32 (abfd, contents, address);
1797 break;
1798 case R_SCORE_24:
1799 offset =
1800 (((contents & howto->src_mask) >> 1) & 0x1ff8000) | ((contents & howto->src_mask) & 0x7fff);
1801 offset += increment;
1802 contents =
1803 (contents & ~howto->
1804 src_mask) | (((offset << 1) & howto->src_mask) & 0x3ff0000) | (offset & 0x7fff);
1805 bfd_put_32 (abfd, contents, address);
1806 break;
1807 case R_SCORE16_11:
1809 contents = bfd_get_16 (abfd, address);
1810 offset = contents & howto->src_mask;
1811 offset += increment;
1812 contents = (contents & ~howto->src_mask) | (offset & howto->src_mask);
1813 bfd_put_16 (abfd, contents, address);
1815 break;
1816 case R_SCORE16_PC8:
1818 contents = bfd_get_16 (abfd, address);
1819 offset = (contents & howto->src_mask) + ((increment >> 1) & 0xff);
1820 contents = (contents & (~howto->src_mask)) | (offset & howto->src_mask);
1821 bfd_put_16 (abfd, contents, address);
1823 break;
1824 default:
1825 addend += increment;
1826 contents = (contents & ~howto->dst_mask) | (addend & howto->dst_mask);
1827 bfd_put_32 (abfd, contents, address);
1828 break;
1832 /* Perform a relocation as part of a final link. */
1834 static bfd_reloc_status_type
1835 score_elf_final_link_relocate (reloc_howto_type *howto,
1836 bfd *input_bfd,
1837 bfd *output_bfd,
1838 asection *input_section,
1839 bfd_byte *contents,
1840 Elf_Internal_Rela *rel,
1841 Elf_Internal_Rela *relocs,
1842 bfd_vma symbol,
1843 struct bfd_link_info *info,
1844 const char *sym_name ATTRIBUTE_UNUSED,
1845 int sym_flags ATTRIBUTE_UNUSED,
1846 struct score_elf_link_hash_entry *h,
1847 asection **local_sections,
1848 bfd_boolean gp_disp_p)
1850 unsigned long r_type;
1851 unsigned long r_symndx;
1852 bfd_byte *hit_data = contents + rel->r_offset;
1853 bfd_vma addend;
1854 /* The final GP value to be used for the relocatable, executable, or
1855 shared object file being produced. */
1856 bfd_vma gp = MINUS_ONE;
1857 /* The place (section offset or address) of the storage unit being relocated. */
1858 bfd_vma rel_addr;
1859 /* The value of GP used to create the relocatable object. */
1860 bfd_vma gp0 = MINUS_ONE;
1861 /* The offset into the global offset table at which the address of the relocation entry
1862 symbol, adjusted by the addend, resides during execution. */
1863 bfd_vma g = MINUS_ONE;
1864 /* TRUE if the symbol referred to by this relocation is a local symbol. */
1865 bfd_boolean local_p;
1866 /* The eventual value we will relocate. */
1867 bfd_vma value = symbol;
1868 unsigned long hi16_addend, hi16_offset, hi16_value, uvalue, offset, abs_value = 0;
1870 if (elf_gp (output_bfd) == 0)
1872 struct bfd_link_hash_entry *bh;
1873 asection *o;
1875 bh = bfd_link_hash_lookup (info->hash, "_gp", 0, 0, 1);
1876 if (bh != (struct bfd_link_hash_entry *)NULL && bh->type == bfd_link_hash_defined)
1877 elf_gp (output_bfd) = (bh->u.def.value
1878 + bh->u.def.section->output_section->vma
1879 + bh->u.def.section->output_offset);
1880 else if (info->relocatable)
1882 bfd_vma lo = -1;
1884 /* Find the GP-relative section with the lowest offset. */
1885 for (o = output_bfd->sections; o != (asection *) NULL; o = o->next)
1886 if (o->vma < lo)
1887 lo = o->vma;
1888 /* And calculate GP relative to that. */
1889 elf_gp (output_bfd) = lo + ELF_SCORE_GP_OFFSET (input_bfd);
1891 else
1893 /* If the relocate_section function needs to do a reloc
1894 involving the GP value, it should make a reloc_dangerous
1895 callback to warn that GP is not defined. */
1899 /* Parse the relocation. */
1900 r_symndx = ELF32_R_SYM (rel->r_info);
1901 r_type = ELF32_R_TYPE (rel->r_info);
1902 rel_addr = (input_section->output_section->vma + input_section->output_offset + rel->r_offset);
1903 local_p = score_elf_local_relocation_p (input_bfd, rel, local_sections, TRUE);
1905 if (r_type == R_SCORE_GOT15)
1907 const Elf_Internal_Rela *relend;
1908 const Elf_Internal_Rela *lo16_rel;
1909 const struct elf_backend_data *bed;
1910 bfd_vma lo_value = 0;
1912 bed = get_elf_backend_data (output_bfd);
1913 relend = relocs + input_section->reloc_count * bed->s->int_rels_per_ext_rel;
1914 lo16_rel = score_elf_next_relocation (input_bfd, R_SCORE_GOT_LO16, rel, relend);
1915 if ((local_p) && (lo16_rel != NULL))
1917 bfd_vma tmp = 0;
1918 tmp = bfd_get_32 (input_bfd, contents + lo16_rel->r_offset);
1919 lo_value = (((tmp >> 16) & 0x3) << 14) | ((tmp & 0x7fff) >> 1);
1921 addend = lo_value;
1923 else
1925 addend = (bfd_get_32 (input_bfd, hit_data) >> howto->bitpos) & howto->src_mask;
1928 /* If we haven't already determined the GOT offset, or the GP value,
1929 and we're going to need it, get it now. */
1930 switch (r_type)
1932 case R_SCORE_CALL15:
1933 case R_SCORE_GOT15:
1934 if (!local_p)
1936 g = score_elf_global_got_index (elf_hash_table (info)->dynobj,
1937 (struct elf_link_hash_entry *) h);
1938 if ((! elf_hash_table(info)->dynamic_sections_created
1939 || (info->shared
1940 && (info->symbolic || h->root.dynindx == -1)
1941 && h->root.def_regular)))
1943 /* This is a static link or a -Bsymbolic link. The
1944 symbol is defined locally, or was forced to be local.
1945 We must initialize this entry in the GOT. */
1946 bfd *tmpbfd = elf_hash_table (info)->dynobj;
1947 asection *sgot = score_elf_got_section (tmpbfd, FALSE);
1948 bfd_put_32 (tmpbfd, value, sgot->contents + g);
1951 else if (r_type == R_SCORE_GOT15 || r_type == R_SCORE_CALL15)
1953 /* There's no need to create a local GOT entry here; the
1954 calculation for a local GOT15 entry does not involve G. */
1957 else
1959 g = score_elf_local_got_index (output_bfd, input_bfd, info,
1960 symbol + addend, r_symndx, h, r_type);
1961 if (g == MINUS_ONE)
1962 return bfd_reloc_outofrange;
1965 /* Convert GOT indices to actual offsets. */
1966 g = score_elf_got_offset_from_index (elf_hash_table (info)->dynobj,
1967 output_bfd, input_bfd, g);
1968 break;
1970 case R_SCORE_HI16:
1971 case R_SCORE_LO16:
1972 case R_SCORE_GPREL32:
1973 gp0 = _bfd_get_gp_value (input_bfd);
1974 gp = _bfd_get_gp_value (output_bfd);
1975 break;
1977 case R_SCORE_GP15:
1978 gp = _bfd_get_gp_value (output_bfd);
1980 default:
1981 break;
1984 switch (r_type)
1986 case R_SCORE_NONE:
1987 return bfd_reloc_ok;
1989 case R_SCORE_ABS32:
1990 case R_SCORE_REL32:
1991 if ((info->shared
1992 || (elf_hash_table (info)->dynamic_sections_created
1993 && h != NULL
1994 && h->root.def_dynamic
1995 && !h->root.def_regular))
1996 && r_symndx != 0
1997 && (input_section->flags & SEC_ALLOC) != 0)
1999 /* If we're creating a shared library, or this relocation is against a symbol
2000 in a shared library, then we can't know where the symbol will end up.
2001 So, we create a relocation record in the output, and leave the job up
2002 to the dynamic linker. */
2003 value = addend;
2004 if (!score_elf_create_dynamic_relocation (output_bfd, info, rel, h,
2005 symbol, &value,
2006 input_section))
2007 return bfd_reloc_undefined;
2009 else if (r_symndx == 0)
2010 /* r_symndx will be zero only for relocs against symbols
2011 from removed linkonce sections, or sections discarded by
2012 a linker script. */
2013 value = 0;
2014 else
2016 if (r_type != R_SCORE_REL32)
2017 value = symbol + addend;
2018 else
2019 value = addend;
2021 value &= howto->dst_mask;
2022 bfd_put_32 (input_bfd, value, hit_data);
2023 return bfd_reloc_ok;
2025 case R_SCORE_ABS16:
2026 value += addend;
2027 if ((long)value > 0x7fff || (long)value < -0x8000)
2028 return bfd_reloc_overflow;
2029 bfd_put_16 (input_bfd, value, hit_data);
2030 return bfd_reloc_ok;
2032 case R_SCORE_24:
2033 addend = bfd_get_32 (input_bfd, hit_data);
2034 offset = (((addend & howto->src_mask) >> 1) & 0x1ff8000) | ((addend & howto->src_mask) & 0x7fff);
2035 if ((offset & 0x1000000) != 0)
2036 offset |= 0xfe000000;
2037 value += offset;
2038 addend = (addend & ~howto->src_mask)
2039 | (((value << 1) & howto->src_mask) & 0x3ff0000) | (value & 0x7fff);
2040 bfd_put_32 (input_bfd, addend, hit_data);
2041 return bfd_reloc_ok;
2043 case R_SCORE_PC19:
2044 addend = bfd_get_32 (input_bfd, hit_data);
2045 offset = (((addend & howto->src_mask) & 0x3ff0000) >> 6) | ((addend & howto->src_mask) & 0x3ff);
2046 if ((offset & 0x80000) != 0)
2047 offset |= 0xfff00000;
2048 abs_value = value = value - rel_addr + offset;
2049 /* exceed 20 bit : overflow. */
2050 if ((abs_value & 0x80000000) == 0x80000000)
2051 abs_value = 0xffffffff - value + 1;
2052 if ((abs_value & 0xfff80000) != 0)
2053 return bfd_reloc_overflow;
2054 addend = (addend & ~howto->src_mask)
2055 | (((value << 6) & howto->src_mask) & 0x3ff0000) | (value & 0x3ff);
2056 bfd_put_32 (input_bfd, addend, hit_data);
2057 return bfd_reloc_ok;
2059 case R_SCORE16_11:
2060 addend = bfd_get_16 (input_bfd, hit_data);
2061 offset = addend & howto->src_mask;
2062 if ((offset & 0x800) != 0) /* Offset is negative. */
2063 offset |= 0xfffff000;
2064 value += offset;
2065 addend = (addend & ~howto->src_mask) | (value & howto->src_mask);
2066 bfd_put_16 (input_bfd, addend, hit_data);
2067 return bfd_reloc_ok;
2069 case R_SCORE16_PC8:
2070 addend = bfd_get_16 (input_bfd, hit_data);
2071 offset = (addend & howto->src_mask) << 1;
2072 if ((offset & 0x100) != 0) /* Offset is negative. */
2073 offset |= 0xfffffe00;
2074 abs_value = value = value - rel_addr + offset;
2075 /* Sign bit + exceed 9 bit. */
2076 if (((value & 0xffffff00) != 0) && ((value & 0xffffff00) != 0xffffff00))
2077 return bfd_reloc_overflow;
2078 value >>= 1;
2079 addend = (addend & ~howto->src_mask) | (value & howto->src_mask);
2080 bfd_put_16 (input_bfd, addend, hit_data);
2081 return bfd_reloc_ok;
2083 case R_SCORE_HI16:
2084 return bfd_reloc_ok;
2086 case R_SCORE_LO16:
2087 hi16_addend = bfd_get_32 (input_bfd, hit_data - 4);
2088 hi16_offset = ((((hi16_addend >> 16) & 0x3) << 15) | (hi16_addend & 0x7fff)) >> 1;
2089 addend = bfd_get_32 (input_bfd, hit_data);
2090 offset = ((((addend >> 16) & 0x3) << 15) | (addend & 0x7fff)) >> 1;
2091 offset = (hi16_offset << 16) | (offset & 0xffff);
2093 if (!gp_disp_p)
2094 uvalue = value + offset;
2095 else
2096 uvalue = offset + gp - rel_addr + 4;
2098 hi16_offset = (uvalue >> 16) << 1;
2099 hi16_value = (hi16_addend & (~(howto->dst_mask)))
2100 | (hi16_offset & 0x7fff) | ((hi16_offset << 1) & 0x30000);
2101 bfd_put_32 (input_bfd, hi16_value, hit_data - 4);
2102 offset = (uvalue & 0xffff) << 1;
2103 value = (addend & (~(howto->dst_mask))) | (offset & 0x7fff) | ((offset << 1) & 0x30000);
2104 bfd_put_32 (input_bfd, value, hit_data);
2105 return bfd_reloc_ok;
2107 case R_SCORE_GP15:
2108 addend = bfd_get_32 (input_bfd, hit_data);
2109 offset = addend & 0x7fff;
2110 if ((offset & 0x4000) == 0x4000)
2111 offset |= 0xffffc000;
2112 value = value + offset - gp;
2113 if (((value & 0xffffc000) != 0) && ((value & 0xffffc000) != 0xffffc000))
2114 return bfd_reloc_overflow;
2115 value = (addend & ~howto->src_mask) | (value & howto->src_mask);
2116 bfd_put_32 (input_bfd, value, hit_data);
2117 return bfd_reloc_ok;
2119 case R_SCORE_GOT15:
2120 case R_SCORE_CALL15:
2121 if (local_p)
2123 bfd_boolean forced;
2125 /* The special case is when the symbol is forced to be local. We need the
2126 full address in the GOT since no R_SCORE_GOT_LO16 relocation follows. */
2127 forced = ! score_elf_local_relocation_p (input_bfd, rel,
2128 local_sections, FALSE);
2129 value = score_elf_got16_entry (output_bfd, input_bfd, info,
2130 symbol + addend, forced);
2131 if (value == MINUS_ONE)
2132 return bfd_reloc_outofrange;
2133 value = score_elf_got_offset_from_index (elf_hash_table (info)->dynobj,
2134 output_bfd, input_bfd, value);
2136 else
2138 value = g;
2141 if ((long) value > 0x3fff || (long) value < -0x4000)
2142 return bfd_reloc_overflow;
2144 addend = bfd_get_32 (input_bfd, hit_data);
2145 value = (addend & ~howto->dst_mask) | (value & howto->dst_mask);
2146 bfd_put_32 (input_bfd, value, hit_data);
2147 return bfd_reloc_ok;
2149 case R_SCORE_GPREL32:
2150 value = (addend + symbol - gp);
2151 value &= howto->dst_mask;
2152 bfd_put_32 (input_bfd, value, hit_data);
2153 return bfd_reloc_ok;
2155 case R_SCORE_GOT_LO16:
2156 addend = bfd_get_32 (input_bfd, hit_data);
2157 value = (((addend >> 16) & 0x3) << 14) | ((addend & 0x7fff) >> 1);
2158 value += symbol;
2159 value = (addend & (~(howto->dst_mask))) | ((value & 0x3fff) << 1)
2160 | (((value >> 14) & 0x3) << 16);
2162 bfd_put_32 (input_bfd, value, hit_data);
2163 return bfd_reloc_ok;
2165 case R_SCORE_DUMMY_HI16:
2166 return bfd_reloc_ok;
2168 case R_SCORE_GNU_VTINHERIT:
2169 case R_SCORE_GNU_VTENTRY:
2170 /* We don't do anything with these at present. */
2171 return bfd_reloc_continue;
2173 default:
2174 return bfd_reloc_notsupported;
2178 /* Score backend functions. */
2180 static void
2181 _bfd_score_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
2182 arelent *bfd_reloc,
2183 Elf_Internal_Rela *elf_reloc)
2185 unsigned int r_type;
2187 r_type = ELF32_R_TYPE (elf_reloc->r_info);
2188 if (r_type >= NUM_ELEM (elf32_score_howto_table))
2189 bfd_reloc->howto = NULL;
2190 else
2191 bfd_reloc->howto = &elf32_score_howto_table[r_type];
2194 /* Relocate an score ELF section. */
2196 static bfd_boolean
2197 _bfd_score_elf_relocate_section (bfd *output_bfd,
2198 struct bfd_link_info *info,
2199 bfd *input_bfd,
2200 asection *input_section,
2201 bfd_byte *contents,
2202 Elf_Internal_Rela *relocs,
2203 Elf_Internal_Sym *local_syms,
2204 asection **local_sections)
2206 Elf_Internal_Shdr *symtab_hdr;
2207 struct elf_link_hash_entry **sym_hashes;
2208 Elf_Internal_Rela *rel;
2209 Elf_Internal_Rela *relend;
2210 const char *name;
2211 unsigned long offset;
2212 unsigned long hi16_addend, hi16_offset, hi16_value, uvalue;
2213 size_t extsymoff;
2214 bfd_boolean gp_disp_p = FALSE;
2216 #ifndef USE_REL
2217 if (info->relocatable)
2218 return TRUE;
2219 #endif
2221 /* Sort dynsym. */
2222 if (elf_hash_table (info)->dynamic_sections_created)
2224 bfd_size_type dynsecsymcount = 0;
2225 if (info->shared)
2227 asection * p;
2228 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
2230 for (p = output_bfd->sections; p ; p = p->next)
2231 if ((p->flags & SEC_EXCLUDE) == 0
2232 && (p->flags & SEC_ALLOC) != 0
2233 && !(*bed->elf_backend_omit_section_dynsym) (output_bfd, info, p))
2234 ++ dynsecsymcount;
2237 if (!score_elf_sort_hash_table (info, dynsecsymcount + 1))
2238 return FALSE;
2241 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2242 extsymoff = (elf_bad_symtab (input_bfd)) ? 0 : symtab_hdr->sh_info;
2243 sym_hashes = elf_sym_hashes (input_bfd);
2244 rel = relocs;
2245 relend = relocs + input_section->reloc_count;
2246 for (; rel < relend; rel++)
2248 int r_type;
2249 reloc_howto_type *howto;
2250 unsigned long r_symndx;
2251 Elf_Internal_Sym *sym;
2252 asection *sec;
2253 struct score_elf_link_hash_entry *h;
2254 bfd_vma relocation = 0;
2255 bfd_reloc_status_type r;
2256 arelent bfd_reloc;
2258 r_symndx = ELF32_R_SYM (rel->r_info);
2259 r_type = ELF32_R_TYPE (rel->r_info);
2261 _bfd_score_info_to_howto (input_bfd, &bfd_reloc, (Elf_Internal_Rela *) rel);
2262 howto = bfd_reloc.howto;
2264 if (info->relocatable)
2266 /* This is a relocatable link. We don't have to change
2267 anything, unless the reloc is against a section symbol,
2268 in which case we have to adjust according to where the
2269 section symbol winds up in the output section. */
2270 if (r_symndx < symtab_hdr->sh_info)
2272 sym = local_syms + r_symndx;
2273 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2275 sec = local_sections[r_symndx];
2276 score_elf_add_to_rel (input_bfd, contents + rel->r_offset,
2277 howto, (bfd_signed_vma) (sec->output_offset + sym->st_value));
2280 continue;
2283 /* This is a final link. */
2284 h = NULL;
2285 sym = NULL;
2286 sec = NULL;
2288 if (r_symndx < extsymoff)
2290 sym = local_syms + r_symndx;
2291 sec = local_sections[r_symndx];
2292 relocation = (sec->output_section->vma
2293 + sec->output_offset
2294 + sym->st_value);
2295 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
2297 if ((sec->flags & SEC_MERGE)
2298 && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2300 asection *msec;
2301 bfd_vma addend, value;
2303 switch (r_type)
2305 case R_SCORE_HI16:
2306 break;
2307 case R_SCORE_LO16:
2308 hi16_addend = bfd_get_32 (input_bfd, contents + rel->r_offset - 4);
2309 hi16_offset = ((((hi16_addend >> 16) & 0x3) << 15) | (hi16_addend & 0x7fff)) >> 1;
2310 value = bfd_get_32 (input_bfd, contents + rel->r_offset);
2311 offset = ((((value >> 16) & 0x3) << 15) | (value & 0x7fff)) >> 1;
2312 addend = (hi16_offset << 16) | (offset & 0xffff);
2313 msec = sec;
2314 addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend);
2315 addend -= relocation;
2316 addend += msec->output_section->vma + msec->output_offset;
2317 uvalue = addend;
2318 hi16_offset = (uvalue >> 16) << 1;
2319 hi16_value = (hi16_addend & (~(howto->dst_mask)))
2320 | (hi16_offset & 0x7fff) | ((hi16_offset << 1) & 0x30000);
2321 bfd_put_32 (input_bfd, hi16_value, contents + rel->r_offset - 4);
2322 offset = (uvalue & 0xffff) << 1;
2323 value = (value & (~(howto->dst_mask)))
2324 | (offset & 0x7fff) | ((offset << 1) & 0x30000);
2325 bfd_put_32 (input_bfd, value, contents + rel->r_offset);
2326 break;
2327 case R_SCORE_GOT_LO16:
2328 value = bfd_get_32 (input_bfd, contents + rel->r_offset);
2329 addend = (((value >> 16) & 0x3) << 14) | ((value & 0x7fff) >> 1);
2330 msec = sec;
2331 addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend) - relocation;
2332 addend += msec->output_section->vma + msec->output_offset;
2333 value = (value & (~(howto->dst_mask))) | ((addend & 0x3fff) << 1)
2334 | (((addend >> 14) & 0x3) << 16);
2336 bfd_put_32 (input_bfd, value, contents + rel->r_offset);
2337 break;
2338 default:
2339 value = bfd_get_32 (input_bfd, contents + rel->r_offset);
2340 /* Get the (signed) value from the instruction. */
2341 addend = value & howto->src_mask;
2342 if (addend & ((howto->src_mask + 1) >> 1))
2344 bfd_signed_vma mask;
2346 mask = -1;
2347 mask &= ~howto->src_mask;
2348 addend |= mask;
2350 msec = sec;
2351 addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend) - relocation;
2352 addend += msec->output_section->vma + msec->output_offset;
2353 value = (value & ~howto->dst_mask) | (addend & howto->dst_mask);
2354 bfd_put_32 (input_bfd, value, contents + rel->r_offset);
2355 break;
2359 else
2361 /* For global symbols we look up the symbol in the hash-table. */
2362 h = ((struct score_elf_link_hash_entry *)
2363 elf_sym_hashes (input_bfd) [r_symndx - extsymoff]);
2364 /* Find the real hash-table entry for this symbol. */
2365 while (h->root.root.type == bfd_link_hash_indirect
2366 || h->root.root.type == bfd_link_hash_warning)
2367 h = (struct score_elf_link_hash_entry *) h->root.root.u.i.link;
2369 /* Record the name of this symbol, for our caller. */
2370 name = h->root.root.root.string;
2372 /* See if this is the special GP_DISP_LABEL symbol. Note that such a
2373 symbol must always be a global symbol. */
2374 if (strcmp (name, GP_DISP_LABEL) == 0)
2376 /* Relocations against GP_DISP_LABEL are permitted only with
2377 R_SCORE_HI16 and R_SCORE_LO16 relocations. */
2378 if (r_type != R_SCORE_HI16 && r_type != R_SCORE_LO16)
2379 return bfd_reloc_notsupported;
2381 gp_disp_p = TRUE;
2384 /* If this symbol is defined, calculate its address. Note that
2385 GP_DISP_LABEL is a magic symbol, always implicitly defined by the
2386 linker, so it's inappropriate to check to see whether or not
2387 its defined. */
2388 else if ((h->root.root.type == bfd_link_hash_defined
2389 || h->root.root.type == bfd_link_hash_defweak)
2390 && h->root.root.u.def.section)
2392 sec = h->root.root.u.def.section;
2393 if (sec->output_section)
2394 relocation = (h->root.root.u.def.value
2395 + sec->output_section->vma
2396 + sec->output_offset);
2397 else
2399 relocation = h->root.root.u.def.value;
2402 else if (h->root.root.type == bfd_link_hash_undefweak)
2403 /* We allow relocations against undefined weak symbols, giving
2404 it the value zero, so that you can undefined weak functions
2405 and check to see if they exist by looking at their addresses. */
2406 relocation = 0;
2407 else if (info->unresolved_syms_in_objects == RM_IGNORE
2408 && ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
2409 relocation = 0;
2410 else if (strcmp (name, "_DYNAMIC_LINK") == 0)
2412 /* If this is a dynamic link, we should have created a _DYNAMIC_LINK symbol
2413 in _bfd_score_elf_create_dynamic_sections. Otherwise, we should define
2414 the symbol with a value of 0. */
2415 BFD_ASSERT (! info->shared);
2416 BFD_ASSERT (bfd_get_section_by_name (output_bfd, ".dynamic") == NULL);
2417 relocation = 0;
2419 else
2421 if (! ((*info->callbacks->undefined_symbol)
2422 (info, h->root.root.root.string, input_bfd,
2423 input_section, rel->r_offset,
2424 (info->unresolved_syms_in_objects == RM_GENERATE_ERROR)
2425 || ELF_ST_VISIBILITY (h->root.other))))
2426 return bfd_reloc_undefined;
2427 relocation = 0;
2431 r = score_elf_final_link_relocate (howto, input_bfd, output_bfd,
2432 input_section, contents, rel, relocs,
2433 relocation, info, name,
2434 (h ? ELF_ST_TYPE ((unsigned int)h->root.root.type) :
2435 ELF_ST_TYPE ((unsigned int)sym->st_info)), h, local_sections,
2436 gp_disp_p);
2438 if (r != bfd_reloc_ok)
2440 const char *msg = (const char *)0;
2442 switch (r)
2444 case bfd_reloc_overflow:
2445 /* If the overflowing reloc was to an undefined symbol,
2446 we have already printed one error message and there
2447 is no point complaining again. */
2448 if (((!h) || (h->root.root.type != bfd_link_hash_undefined))
2449 && (!((*info->callbacks->reloc_overflow)
2450 (info, NULL, name, howto->name, (bfd_vma) 0,
2451 input_bfd, input_section, rel->r_offset))))
2452 return FALSE;
2453 break;
2454 case bfd_reloc_undefined:
2455 if (!((*info->callbacks->undefined_symbol)
2456 (info, name, input_bfd, input_section, rel->r_offset, TRUE)))
2457 return FALSE;
2458 break;
2460 case bfd_reloc_outofrange:
2461 msg = _("internal error: out of range error");
2462 goto common_error;
2464 case bfd_reloc_notsupported:
2465 msg = _("internal error: unsupported relocation error");
2466 goto common_error;
2468 case bfd_reloc_dangerous:
2469 msg = _("internal error: dangerous error");
2470 goto common_error;
2472 default:
2473 msg = _("internal error: unknown error");
2474 /* fall through */
2476 common_error:
2477 if (!((*info->callbacks->warning)
2478 (info, msg, name, input_bfd, input_section, rel->r_offset)))
2479 return FALSE;
2480 break;
2485 return TRUE;
2488 /* Look through the relocs for a section during the first phase, and
2489 allocate space in the global offset table. */
2491 static bfd_boolean
2492 _bfd_score_elf_check_relocs (bfd *abfd,
2493 struct bfd_link_info *info,
2494 asection *sec,
2495 const Elf_Internal_Rela *relocs)
2497 const char *name;
2498 bfd *dynobj;
2499 Elf_Internal_Shdr *symtab_hdr;
2500 struct elf_link_hash_entry **sym_hashes;
2501 struct score_got_info *g;
2502 size_t extsymoff;
2503 const Elf_Internal_Rela *rel;
2504 const Elf_Internal_Rela *rel_end;
2505 asection *sgot;
2506 asection *sreloc;
2507 const struct elf_backend_data *bed;
2509 if (info->relocatable)
2510 return TRUE;
2512 dynobj = elf_hash_table (info)->dynobj;
2513 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2514 sym_hashes = elf_sym_hashes (abfd);
2515 extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info;
2517 name = bfd_get_section_name (abfd, sec);
2519 if (dynobj == NULL)
2521 sgot = NULL;
2522 g = NULL;
2524 else
2526 sgot = score_elf_got_section (dynobj, FALSE);
2527 if (sgot == NULL)
2528 g = NULL;
2529 else
2531 BFD_ASSERT (score_elf_section_data (sgot) != NULL);
2532 g = score_elf_section_data (sgot)->u.got_info;
2533 BFD_ASSERT (g != NULL);
2537 sreloc = NULL;
2538 bed = get_elf_backend_data (abfd);
2539 rel_end = relocs + sec->reloc_count * bed->s->int_rels_per_ext_rel;
2540 for (rel = relocs; rel < rel_end; ++rel)
2542 unsigned long r_symndx;
2543 unsigned int r_type;
2544 struct elf_link_hash_entry *h;
2546 r_symndx = ELF32_R_SYM (rel->r_info);
2547 r_type = ELF32_R_TYPE (rel->r_info);
2549 if (r_symndx < extsymoff)
2551 h = NULL;
2553 else if (r_symndx >= extsymoff + NUM_SHDR_ENTRIES (symtab_hdr))
2555 (*_bfd_error_handler) (_("%s: Malformed reloc detected for section %s"), abfd, name);
2556 bfd_set_error (bfd_error_bad_value);
2557 return FALSE;
2559 else
2561 h = sym_hashes[r_symndx - extsymoff];
2563 /* This may be an indirect symbol created because of a version. */
2564 if (h != NULL)
2566 while (h->root.type == bfd_link_hash_indirect)
2567 h = (struct elf_link_hash_entry *)h->root.u.i.link;
2571 /* Some relocs require a global offset table. */
2572 if (dynobj == NULL || sgot == NULL)
2574 switch (r_type)
2576 case R_SCORE_GOT15:
2577 case R_SCORE_CALL15:
2578 if (dynobj == NULL)
2579 elf_hash_table (info)->dynobj = dynobj = abfd;
2580 if (!score_elf_create_got_section (dynobj, info, FALSE))
2581 return FALSE;
2582 g = score_elf_got_info (dynobj, &sgot);
2583 break;
2584 case R_SCORE_ABS32:
2585 case R_SCORE_REL32:
2586 if (dynobj == NULL && (info->shared || h != NULL) && (sec->flags & SEC_ALLOC) != 0)
2587 elf_hash_table (info)->dynobj = dynobj = abfd;
2588 break;
2589 default:
2590 break;
2594 if (!h && (r_type == R_SCORE_GOT_LO16))
2596 if (! score_elf_record_local_got_symbol (abfd, r_symndx, rel->r_addend, g))
2597 return FALSE;
2600 switch (r_type)
2602 case R_SCORE_CALL15:
2603 if (h == NULL)
2605 (*_bfd_error_handler)
2606 (_("%B: CALL15 reloc at 0x%lx not against global symbol"),
2607 abfd, (unsigned long) rel->r_offset);
2608 bfd_set_error (bfd_error_bad_value);
2609 return FALSE;
2611 else
2613 /* This symbol requires a global offset table entry. */
2614 if (! score_elf_record_global_got_symbol (h, abfd, info, g))
2615 return FALSE;
2617 /* We need a stub, not a plt entry for the undefined function. But we record
2618 it as if it needs plt. See _bfd_elf_adjust_dynamic_symbol. */
2619 h->needs_plt = 1;
2620 h->type = STT_FUNC;
2622 break;
2623 case R_SCORE_GOT15:
2624 if (h && ! score_elf_record_global_got_symbol (h, abfd, info, g))
2625 return FALSE;
2626 break;
2627 case R_SCORE_ABS32:
2628 case R_SCORE_REL32:
2629 if ((info->shared || h != NULL) && (sec->flags & SEC_ALLOC) != 0)
2631 if (sreloc == NULL)
2633 sreloc = score_elf_rel_dyn_section (dynobj, TRUE);
2634 if (sreloc == NULL)
2635 return FALSE;
2637 #define SCORE_READONLY_SECTION (SEC_ALLOC | SEC_LOAD | SEC_READONLY)
2638 if (info->shared)
2640 /* When creating a shared object, we must copy these reloc types into
2641 the output file as R_SCORE_REL32 relocs. We make room for this reloc
2642 in the .rel.dyn reloc section. */
2643 score_elf_allocate_dynamic_relocations (dynobj, 1);
2644 if ((sec->flags & SCORE_READONLY_SECTION)
2645 == SCORE_READONLY_SECTION)
2646 /* We tell the dynamic linker that there are
2647 relocations against the text segment. */
2648 info->flags |= DF_TEXTREL;
2650 else
2652 struct score_elf_link_hash_entry *hscore;
2654 /* We only need to copy this reloc if the symbol is
2655 defined in a dynamic object. */
2656 hscore = (struct score_elf_link_hash_entry *)h;
2657 ++hscore->possibly_dynamic_relocs;
2658 if ((sec->flags & SCORE_READONLY_SECTION)
2659 == SCORE_READONLY_SECTION)
2660 /* We need it to tell the dynamic linker if there
2661 are relocations against the text segment. */
2662 hscore->readonly_reloc = TRUE;
2665 /* Even though we don't directly need a GOT entry for this symbol,
2666 a symbol must have a dynamic symbol table index greater that
2667 DT_SCORE_GOTSYM if there are dynamic relocations against it. */
2668 if (h != NULL)
2670 if (dynobj == NULL)
2671 elf_hash_table (info)->dynobj = dynobj = abfd;
2672 if (! score_elf_create_got_section (dynobj, info, TRUE))
2673 return FALSE;
2674 g = score_elf_got_info (dynobj, &sgot);
2675 if (! score_elf_record_global_got_symbol (h, abfd, info, g))
2676 return FALSE;
2679 break;
2681 /* This relocation describes the C++ object vtable hierarchy.
2682 Reconstruct it for later use during GC. */
2683 case R_SCORE_GNU_VTINHERIT:
2684 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2685 return FALSE;
2686 break;
2688 /* This relocation describes which C++ vtable entries are actually
2689 used. Record for later use during GC. */
2690 case R_SCORE_GNU_VTENTRY:
2691 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
2692 return FALSE;
2693 break;
2694 default:
2695 break;
2698 /* We must not create a stub for a symbol that has relocations
2699 related to taking the function's address. */
2700 switch (r_type)
2702 default:
2703 if (h != NULL)
2705 struct score_elf_link_hash_entry *sh;
2707 sh = (struct score_elf_link_hash_entry *) h;
2708 sh->no_fn_stub = TRUE;
2710 break;
2711 case R_SCORE_CALL15:
2712 break;
2716 return TRUE;
2719 static bfd_boolean
2720 _bfd_score_elf_add_symbol_hook (bfd *abfd,
2721 struct bfd_link_info *info ATTRIBUTE_UNUSED,
2722 Elf_Internal_Sym *sym,
2723 const char **namep ATTRIBUTE_UNUSED,
2724 flagword *flagsp ATTRIBUTE_UNUSED,
2725 asection **secp,
2726 bfd_vma *valp)
2728 switch (sym->st_shndx)
2730 case SHN_COMMON:
2731 if (sym->st_size > elf_gp_size (abfd))
2732 break;
2733 /* Fall through. */
2734 case SHN_SCORE_SCOMMON:
2735 *secp = bfd_make_section_old_way (abfd, ".scommon");
2736 (*secp)->flags |= SEC_IS_COMMON;
2737 *valp = sym->st_size;
2738 break;
2741 return TRUE;
2744 static void
2745 _bfd_score_elf_symbol_processing (bfd *abfd, asymbol *asym)
2747 elf_symbol_type *elfsym;
2749 elfsym = (elf_symbol_type *) asym;
2750 switch (elfsym->internal_elf_sym.st_shndx)
2752 case SHN_COMMON:
2753 if (asym->value > elf_gp_size (abfd))
2754 break;
2755 /* Fall through. */
2756 case SHN_SCORE_SCOMMON:
2757 if (score_elf_scom_section.name == NULL)
2759 /* Initialize the small common section. */
2760 score_elf_scom_section.name = ".scommon";
2761 score_elf_scom_section.flags = SEC_IS_COMMON;
2762 score_elf_scom_section.output_section = &score_elf_scom_section;
2763 score_elf_scom_section.symbol = &score_elf_scom_symbol;
2764 score_elf_scom_section.symbol_ptr_ptr = &score_elf_scom_symbol_ptr;
2765 score_elf_scom_symbol.name = ".scommon";
2766 score_elf_scom_symbol.flags = BSF_SECTION_SYM;
2767 score_elf_scom_symbol.section = &score_elf_scom_section;
2768 score_elf_scom_symbol_ptr = &score_elf_scom_symbol;
2770 asym->section = &score_elf_scom_section;
2771 asym->value = elfsym->internal_elf_sym.st_size;
2772 break;
2776 static bfd_boolean
2777 _bfd_score_elf_link_output_symbol_hook (struct bfd_link_info *info ATTRIBUTE_UNUSED,
2778 const char *name ATTRIBUTE_UNUSED,
2779 Elf_Internal_Sym *sym,
2780 asection *input_sec,
2781 struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
2783 /* If we see a common symbol, which implies a relocatable link, then
2784 if a symbol was small common in an input file, mark it as small
2785 common in the output file. */
2786 if (sym->st_shndx == SHN_COMMON && strcmp (input_sec->name, ".scommon") == 0)
2787 sym->st_shndx = SHN_SCORE_SCOMMON;
2789 return TRUE;
2792 static bfd_boolean
2793 _bfd_score_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
2794 asection *sec,
2795 int *retval)
2797 if (strcmp (bfd_get_section_name (abfd, sec), ".scommon") == 0)
2799 *retval = SHN_SCORE_SCOMMON;
2800 return TRUE;
2803 return FALSE;
2806 /* Adjust a symbol defined by a dynamic object and referenced by a
2807 regular object. The current definition is in some section of the
2808 dynamic object, but we're not including those sections. We have to
2809 change the definition to something the rest of the link can understand. */
2811 static bfd_boolean
2812 _bfd_score_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
2813 struct elf_link_hash_entry *h)
2815 bfd *dynobj;
2816 struct score_elf_link_hash_entry *hscore;
2817 asection *s;
2819 dynobj = elf_hash_table (info)->dynobj;
2821 /* Make sure we know what is going on here. */
2822 BFD_ASSERT (dynobj != NULL
2823 && (h->needs_plt
2824 || h->u.weakdef != NULL
2825 || (h->def_dynamic && h->ref_regular && !h->def_regular)));
2827 /* If this symbol is defined in a dynamic object, we need to copy
2828 any R_SCORE_ABS32 or R_SCORE_REL32 relocs against it into the output
2829 file. */
2830 hscore = (struct score_elf_link_hash_entry *)h;
2831 if (!info->relocatable
2832 && hscore->possibly_dynamic_relocs != 0
2833 && (h->root.type == bfd_link_hash_defweak || !h->def_regular))
2835 score_elf_allocate_dynamic_relocations (dynobj, hscore->possibly_dynamic_relocs);
2836 if (hscore->readonly_reloc)
2837 /* We tell the dynamic linker that there are relocations
2838 against the text segment. */
2839 info->flags |= DF_TEXTREL;
2842 /* For a function, create a stub, if allowed. */
2843 if (!hscore->no_fn_stub && h->needs_plt)
2845 if (!elf_hash_table (info)->dynamic_sections_created)
2846 return TRUE;
2848 /* If this symbol is not defined in a regular file, then set
2849 the symbol to the stub location. This is required to make
2850 function pointers compare as equal between the normal
2851 executable and the shared library. */
2852 if (!h->def_regular)
2854 /* We need .stub section. */
2855 s = bfd_get_section_by_name (dynobj, SCORE_ELF_STUB_SECTION_NAME);
2856 BFD_ASSERT (s != NULL);
2858 h->root.u.def.section = s;
2859 h->root.u.def.value = s->size;
2861 /* XXX Write this stub address somewhere. */
2862 h->plt.offset = s->size;
2864 /* Make room for this stub code. */
2865 s->size += SCORE_FUNCTION_STUB_SIZE;
2867 /* The last half word of the stub will be filled with the index
2868 of this symbol in .dynsym section. */
2869 return TRUE;
2872 else if ((h->type == STT_FUNC) && !h->needs_plt)
2874 /* This will set the entry for this symbol in the GOT to 0, and
2875 the dynamic linker will take care of this. */
2876 h->root.u.def.value = 0;
2877 return TRUE;
2880 /* If this is a weak symbol, and there is a real definition, the
2881 processor independent code will have arranged for us to see the
2882 real definition first, and we can just use the same value. */
2883 if (h->u.weakdef != NULL)
2885 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2886 || h->u.weakdef->root.type == bfd_link_hash_defweak);
2887 h->root.u.def.section = h->u.weakdef->root.u.def.section;
2888 h->root.u.def.value = h->u.weakdef->root.u.def.value;
2889 return TRUE;
2892 /* This is a reference to a symbol defined by a dynamic object which
2893 is not a function. */
2894 return TRUE;
2897 /* This function is called after all the input files have been read,
2898 and the input sections have been assigned to output sections. */
2900 static bfd_boolean
2901 _bfd_score_elf_always_size_sections (bfd *output_bfd,
2902 struct bfd_link_info *info)
2904 bfd *dynobj;
2905 asection *s;
2906 struct score_got_info *g;
2907 int i;
2908 bfd_size_type loadable_size = 0;
2909 bfd_size_type local_gotno;
2910 bfd *sub;
2912 dynobj = elf_hash_table (info)->dynobj;
2913 if (dynobj == NULL)
2914 /* Relocatable links don't have it. */
2915 return TRUE;
2917 g = score_elf_got_info (dynobj, &s);
2918 if (s == NULL)
2919 return TRUE;
2921 /* Calculate the total loadable size of the output. That will give us the
2922 maximum number of GOT_PAGE entries required. */
2923 for (sub = info->input_bfds; sub; sub = sub->link_next)
2925 asection *subsection;
2927 for (subsection = sub->sections;
2928 subsection;
2929 subsection = subsection->next)
2931 if ((subsection->flags & SEC_ALLOC) == 0)
2932 continue;
2933 loadable_size += ((subsection->size + 0xf)
2934 &~ (bfd_size_type) 0xf);
2938 /* There has to be a global GOT entry for every symbol with
2939 a dynamic symbol table index of DT_SCORE_GOTSYM or
2940 higher. Therefore, it make sense to put those symbols
2941 that need GOT entries at the end of the symbol table. We
2942 do that here. */
2943 if (! score_elf_sort_hash_table (info, 1))
2944 return FALSE;
2946 if (g->global_gotsym != NULL)
2947 i = elf_hash_table (info)->dynsymcount - g->global_gotsym->dynindx;
2948 else
2949 /* If there are no global symbols, or none requiring
2950 relocations, then GLOBAL_GOTSYM will be NULL. */
2951 i = 0;
2953 /* In the worst case, we'll get one stub per dynamic symbol. */
2954 loadable_size += SCORE_FUNCTION_STUB_SIZE * i;
2956 /* Assume there are two loadable segments consisting of
2957 contiguous sections. Is 5 enough? */
2958 local_gotno = (loadable_size >> 16) + 5;
2960 g->local_gotno += local_gotno;
2961 s->size += g->local_gotno * SCORE_ELF_GOT_SIZE (output_bfd);
2963 g->global_gotno = i;
2964 s->size += i * SCORE_ELF_GOT_SIZE (output_bfd);
2966 score_elf_resolve_final_got_entries (g);
2968 if (s->size > SCORE_ELF_GOT_MAX_SIZE (output_bfd))
2970 /* Fixme. Error message or Warning message should be issued here. */
2973 return TRUE;
2976 /* Set the sizes of the dynamic sections. */
2978 static bfd_boolean
2979 _bfd_score_elf_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
2981 bfd *dynobj;
2982 asection *s;
2983 bfd_boolean reltext;
2985 dynobj = elf_hash_table (info)->dynobj;
2986 BFD_ASSERT (dynobj != NULL);
2988 if (elf_hash_table (info)->dynamic_sections_created)
2990 /* Set the contents of the .interp section to the interpreter. */
2991 if (!info->shared)
2993 s = bfd_get_section_by_name (dynobj, ".interp");
2994 BFD_ASSERT (s != NULL);
2995 s->size = strlen (ELF_DYNAMIC_INTERPRETER) + 1;
2996 s->contents = (bfd_byte *) ELF_DYNAMIC_INTERPRETER;
3000 /* The check_relocs and adjust_dynamic_symbol entry points have
3001 determined the sizes of the various dynamic sections. Allocate
3002 memory for them. */
3003 reltext = FALSE;
3004 for (s = dynobj->sections; s != NULL; s = s->next)
3006 const char *name;
3008 if ((s->flags & SEC_LINKER_CREATED) == 0)
3009 continue;
3011 /* It's OK to base decisions on the section name, because none
3012 of the dynobj section names depend upon the input files. */
3013 name = bfd_get_section_name (dynobj, s);
3015 if (CONST_STRNEQ (name, ".rel"))
3017 if (s->size == 0)
3019 /* We only strip the section if the output section name
3020 has the same name. Otherwise, there might be several
3021 input sections for this output section. FIXME: This
3022 code is probably not needed these days anyhow, since
3023 the linker now does not create empty output sections. */
3024 if (s->output_section != NULL
3025 && strcmp (name,
3026 bfd_get_section_name (s->output_section->owner,
3027 s->output_section)) == 0)
3028 s->flags |= SEC_EXCLUDE;
3030 else
3032 const char *outname;
3033 asection *target;
3035 /* If this relocation section applies to a read only
3036 section, then we probably need a DT_TEXTREL entry.
3037 If the relocation section is .rel.dyn, we always
3038 assert a DT_TEXTREL entry rather than testing whether
3039 there exists a relocation to a read only section or
3040 not. */
3041 outname = bfd_get_section_name (output_bfd, s->output_section);
3042 target = bfd_get_section_by_name (output_bfd, outname + 4);
3043 if ((target != NULL
3044 && (target->flags & SEC_READONLY) != 0
3045 && (target->flags & SEC_ALLOC) != 0) || strcmp (outname, ".rel.dyn") == 0)
3046 reltext = TRUE;
3048 /* We use the reloc_count field as a counter if we need
3049 to copy relocs into the output file. */
3050 if (strcmp (name, ".rel.dyn") != 0)
3051 s->reloc_count = 0;
3054 else if (CONST_STRNEQ (name, ".got"))
3056 /* _bfd_score_elf_always_size_sections() has already done
3057 most of the work, but some symbols may have been mapped
3058 to versions that we must now resolve in the got_entries
3059 hash tables. */
3061 else if (strcmp (name, SCORE_ELF_STUB_SECTION_NAME) == 0)
3063 /* IRIX rld assumes that the function stub isn't at the end
3064 of .text section. So put a dummy. XXX */
3065 s->size += SCORE_FUNCTION_STUB_SIZE;
3067 else if (! CONST_STRNEQ (name, ".init"))
3069 /* It's not one of our sections, so don't allocate space. */
3070 continue;
3073 /* Allocate memory for the section contents. */
3074 s->contents = bfd_zalloc (dynobj, s->size);
3075 if (s->contents == NULL && s->size != 0)
3077 bfd_set_error (bfd_error_no_memory);
3078 return FALSE;
3082 if (elf_hash_table (info)->dynamic_sections_created)
3084 /* Add some entries to the .dynamic section. We fill in the
3085 values later, in _bfd_score_elf_finish_dynamic_sections, but we
3086 must add the entries now so that we get the correct size for
3087 the .dynamic section. The DT_DEBUG entry is filled in by the
3088 dynamic linker and used by the debugger. */
3090 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_DEBUG, 0))
3091 return FALSE;
3093 if (reltext)
3094 info->flags |= DF_TEXTREL;
3096 if ((info->flags & DF_TEXTREL) != 0)
3098 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_TEXTREL, 0))
3099 return FALSE;
3102 if (! SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTGOT, 0))
3103 return FALSE;
3105 if (score_elf_rel_dyn_section (dynobj, FALSE))
3107 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_REL, 0))
3108 return FALSE;
3110 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELSZ, 0))
3111 return FALSE;
3113 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELENT, 0))
3114 return FALSE;
3117 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_SCORE_BASE_ADDRESS, 0))
3118 return FALSE;
3120 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_SCORE_LOCAL_GOTNO, 0))
3121 return FALSE;
3123 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_SCORE_SYMTABNO, 0))
3124 return FALSE;
3126 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_SCORE_UNREFEXTNO, 0))
3127 return FALSE;
3129 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_SCORE_GOTSYM, 0))
3130 return FALSE;
3132 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_SCORE_HIPAGENO, 0))
3133 return FALSE;
3136 return TRUE;
3139 static bfd_boolean
3140 _bfd_score_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
3142 struct elf_link_hash_entry *h;
3143 struct bfd_link_hash_entry *bh;
3144 flagword flags;
3145 asection *s;
3147 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
3148 | SEC_LINKER_CREATED | SEC_READONLY);
3150 /* ABI requests the .dynamic section to be read only. */
3151 s = bfd_get_section_by_name (abfd, ".dynamic");
3152 if (s != NULL)
3154 if (!bfd_set_section_flags (abfd, s, flags))
3155 return FALSE;
3158 /* We need to create .got section. */
3159 if (!score_elf_create_got_section (abfd, info, FALSE))
3160 return FALSE;
3162 if (!score_elf_rel_dyn_section (elf_hash_table (info)->dynobj, TRUE))
3163 return FALSE;
3165 /* Create .stub section. */
3166 if (bfd_get_section_by_name (abfd, SCORE_ELF_STUB_SECTION_NAME) == NULL)
3168 s = bfd_make_section_with_flags (abfd, SCORE_ELF_STUB_SECTION_NAME,
3169 flags | SEC_CODE);
3170 if (s == NULL
3171 || !bfd_set_section_alignment (abfd, s, 2))
3173 return FALSE;
3176 if (!info->shared)
3178 const char *name;
3180 name = "_DYNAMIC_LINK";
3181 bh = NULL;
3182 if (!(_bfd_generic_link_add_one_symbol
3183 (info, abfd, name, BSF_GLOBAL, bfd_abs_section_ptr,
3184 (bfd_vma) 0, (const char *)NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
3185 return FALSE;
3187 h = (struct elf_link_hash_entry *)bh;
3188 h->non_elf = 0;
3189 h->def_regular = 1;
3190 h->type = STT_SECTION;
3192 if (!bfd_elf_link_record_dynamic_symbol (info, h))
3193 return FALSE;
3196 return TRUE;
3200 /* Finish up dynamic symbol handling. We set the contents of various
3201 dynamic sections here. */
3203 static bfd_boolean
3204 _bfd_score_elf_finish_dynamic_symbol (bfd *output_bfd,
3205 struct bfd_link_info *info,
3206 struct elf_link_hash_entry *h,
3207 Elf_Internal_Sym *sym)
3209 bfd *dynobj;
3210 asection *sgot;
3211 struct score_got_info *g;
3212 const char *name;
3214 dynobj = elf_hash_table (info)->dynobj;
3216 if (h->plt.offset != MINUS_ONE)
3218 asection *s;
3219 bfd_byte stub[SCORE_FUNCTION_STUB_SIZE];
3221 /* This symbol has a stub. Set it up. */
3222 BFD_ASSERT (h->dynindx != -1);
3224 s = bfd_get_section_by_name (dynobj, SCORE_ELF_STUB_SECTION_NAME);
3225 BFD_ASSERT (s != NULL);
3227 /* FIXME: Can h->dynindex be more than 64K? */
3228 if (h->dynindx & 0xffff0000)
3229 return FALSE;
3231 /* Fill the stub. */
3232 bfd_put_32 (output_bfd, STUB_LW, stub);
3233 bfd_put_32 (output_bfd, STUB_MOVE, stub + 4);
3234 bfd_put_32 (output_bfd, STUB_LI16 | (h->dynindx << 1), stub + 8);
3235 bfd_put_32 (output_bfd, STUB_BRL, stub + 12);
3237 BFD_ASSERT (h->plt.offset <= s->size);
3238 memcpy (s->contents + h->plt.offset, stub, SCORE_FUNCTION_STUB_SIZE);
3240 /* Mark the symbol as undefined. plt.offset != -1 occurs
3241 only for the referenced symbol. */
3242 sym->st_shndx = SHN_UNDEF;
3244 /* The run-time linker uses the st_value field of the symbol
3245 to reset the global offset table entry for this external
3246 to its stub address when unlinking a shared object. */
3247 sym->st_value = (s->output_section->vma + s->output_offset + h->plt.offset);
3250 BFD_ASSERT (h->dynindx != -1 || h->forced_local);
3252 sgot = score_elf_got_section (dynobj, FALSE);
3253 BFD_ASSERT (sgot != NULL);
3254 BFD_ASSERT (score_elf_section_data (sgot) != NULL);
3255 g = score_elf_section_data (sgot)->u.got_info;
3256 BFD_ASSERT (g != NULL);
3258 /* Run through the global symbol table, creating GOT entries for all
3259 the symbols that need them. */
3260 if (g->global_gotsym != NULL && h->dynindx >= g->global_gotsym->dynindx)
3262 bfd_vma offset;
3263 bfd_vma value;
3265 value = sym->st_value;
3266 offset = score_elf_global_got_index (dynobj, h);
3267 bfd_put_32 (output_bfd, value, sgot->contents + offset);
3270 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3271 name = h->root.root.string;
3272 if (strcmp (name, "_DYNAMIC") == 0 || strcmp (name, "_GLOBAL_OFFSET_TABLE_") == 0)
3273 sym->st_shndx = SHN_ABS;
3274 else if (strcmp (name, "_DYNAMIC_LINK") == 0)
3276 sym->st_shndx = SHN_ABS;
3277 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
3278 sym->st_value = 1;
3280 else if (strcmp (name, GP_DISP_LABEL) == 0)
3282 sym->st_shndx = SHN_ABS;
3283 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
3284 sym->st_value = elf_gp (output_bfd);
3287 return TRUE;
3290 /* Finish up the dynamic sections. */
3292 static bfd_boolean
3293 _bfd_score_elf_finish_dynamic_sections (bfd *output_bfd,
3294 struct bfd_link_info *info)
3296 bfd *dynobj;
3297 asection *sdyn;
3298 asection *sgot;
3299 asection *s;
3300 struct score_got_info *g;
3302 dynobj = elf_hash_table (info)->dynobj;
3304 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3306 sgot = score_elf_got_section (dynobj, FALSE);
3307 if (sgot == NULL)
3308 g = NULL;
3309 else
3311 BFD_ASSERT (score_elf_section_data (sgot) != NULL);
3312 g = score_elf_section_data (sgot)->u.got_info;
3313 BFD_ASSERT (g != NULL);
3316 if (elf_hash_table (info)->dynamic_sections_created)
3318 bfd_byte *b;
3320 BFD_ASSERT (sdyn != NULL);
3321 BFD_ASSERT (g != NULL);
3323 for (b = sdyn->contents;
3324 b < sdyn->contents + sdyn->size;
3325 b += SCORE_ELF_DYN_SIZE (dynobj))
3327 Elf_Internal_Dyn dyn;
3328 const char *name;
3329 size_t elemsize;
3330 bfd_boolean swap_out_p;
3332 /* Read in the current dynamic entry. */
3333 (*get_elf_backend_data (dynobj)->s->swap_dyn_in) (dynobj, b, &dyn);
3335 /* Assume that we're going to modify it and write it out. */
3336 swap_out_p = TRUE;
3338 switch (dyn.d_tag)
3340 case DT_RELENT:
3341 s = score_elf_rel_dyn_section (dynobj, FALSE);
3342 BFD_ASSERT (s != NULL);
3343 dyn.d_un.d_val = SCORE_ELF_REL_SIZE (dynobj);
3344 break;
3346 case DT_STRSZ:
3347 /* Rewrite DT_STRSZ. */
3348 dyn.d_un.d_val = _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
3349 break;
3351 case DT_PLTGOT:
3352 name = ".got";
3353 s = bfd_get_section_by_name (output_bfd, name);
3354 BFD_ASSERT (s != NULL);
3355 dyn.d_un.d_ptr = s->vma;
3356 break;
3358 case DT_SCORE_BASE_ADDRESS:
3359 s = output_bfd->sections;
3360 BFD_ASSERT (s != NULL);
3361 dyn.d_un.d_ptr = s->vma & ~(bfd_vma) 0xffff;
3362 break;
3364 case DT_SCORE_LOCAL_GOTNO:
3365 dyn.d_un.d_val = g->local_gotno;
3366 break;
3368 case DT_SCORE_UNREFEXTNO:
3369 /* The index into the dynamic symbol table which is the
3370 entry of the first external symbol that is not
3371 referenced within the same object. */
3372 dyn.d_un.d_val = bfd_count_sections (output_bfd) + 1;
3373 break;
3375 case DT_SCORE_GOTSYM:
3376 if (g->global_gotsym)
3378 dyn.d_un.d_val = g->global_gotsym->dynindx;
3379 break;
3381 /* In case if we don't have global got symbols we default
3382 to setting DT_SCORE_GOTSYM to the same value as
3383 DT_SCORE_SYMTABNO, so we just fall through. */
3385 case DT_SCORE_SYMTABNO:
3386 name = ".dynsym";
3387 elemsize = SCORE_ELF_SYM_SIZE (output_bfd);
3388 s = bfd_get_section_by_name (output_bfd, name);
3389 BFD_ASSERT (s != NULL);
3391 dyn.d_un.d_val = s->size / elemsize;
3392 break;
3394 case DT_SCORE_HIPAGENO:
3395 dyn.d_un.d_val = g->local_gotno - SCORE_RESERVED_GOTNO;
3396 break;
3398 default:
3399 swap_out_p = FALSE;
3400 break;
3403 if (swap_out_p)
3404 (*get_elf_backend_data (dynobj)->s->swap_dyn_out) (dynobj, &dyn, b);
3408 /* The first entry of the global offset table will be filled at
3409 runtime. The second entry will be used by some runtime loaders.
3410 This isn't the case of IRIX rld. */
3411 if (sgot != NULL && sgot->size > 0)
3413 bfd_put_32 (output_bfd, 0, sgot->contents);
3414 bfd_put_32 (output_bfd, 0x80000000, sgot->contents + SCORE_ELF_GOT_SIZE (output_bfd));
3417 if (sgot != NULL)
3418 elf_section_data (sgot->output_section)->this_hdr.sh_entsize
3419 = SCORE_ELF_GOT_SIZE (output_bfd);
3422 /* We need to sort the entries of the dynamic relocation section. */
3423 s = score_elf_rel_dyn_section (dynobj, FALSE);
3425 if (s != NULL && s->size > (bfd_vma)2 * SCORE_ELF_REL_SIZE (output_bfd))
3427 reldyn_sorting_bfd = output_bfd;
3428 qsort ((Elf32_External_Rel *) s->contents + 1, s->reloc_count - 1,
3429 sizeof (Elf32_External_Rel), score_elf_sort_dynamic_relocs);
3432 return TRUE;
3435 /* This function set up the ELF section header for a BFD section in preparation for writing
3436 it out. This is where the flags and type fields are set for unusual sections. */
3438 static bfd_boolean
3439 _bfd_score_elf_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
3440 Elf_Internal_Shdr *hdr,
3441 asection *sec)
3443 const char *name;
3445 name = bfd_get_section_name (abfd, sec);
3447 if (strcmp (name, ".got") == 0
3448 || strcmp (name, ".srdata") == 0
3449 || strcmp (name, ".sdata") == 0
3450 || strcmp (name, ".sbss") == 0)
3451 hdr->sh_flags |= SHF_SCORE_GPREL;
3453 return TRUE;
3456 /* This function do additional processing on the ELF section header before writing
3457 it out. This is used to set the flags and type fields for some sections. */
3459 /* assign_file_positions_except_relocs() check section flag and if it is allocatable,
3460 warning message will be issued. backend_fake_section is called before
3461 assign_file_positions_except_relocs(); backend_section_processing after it. so, we
3462 modify section flag there, but not backend_fake_section. */
3464 static bfd_boolean
3465 _bfd_score_elf_section_processing (bfd *abfd ATTRIBUTE_UNUSED, Elf_Internal_Shdr *hdr)
3467 if (hdr->bfd_section != NULL)
3469 const char *name = bfd_get_section_name (abfd, hdr->bfd_section);
3471 if (strcmp (name, ".sdata") == 0)
3473 hdr->sh_flags |= SHF_ALLOC | SHF_WRITE | SHF_SCORE_GPREL;
3474 hdr->sh_type = SHT_PROGBITS;
3476 else if (strcmp (name, ".sbss") == 0)
3478 hdr->sh_flags |= SHF_ALLOC | SHF_WRITE | SHF_SCORE_GPREL;
3479 hdr->sh_type = SHT_NOBITS;
3481 else if (strcmp (name, ".srdata") == 0)
3483 hdr->sh_flags |= SHF_ALLOC | SHF_SCORE_GPREL;
3484 hdr->sh_type = SHT_PROGBITS;
3488 return TRUE;
3491 static bfd_boolean
3492 _bfd_score_elf_write_section (bfd *output_bfd, asection *sec, bfd_byte *contents)
3494 bfd_byte *to, *from, *end;
3495 int i;
3497 if (strcmp (sec->name, ".pdr") != 0)
3498 return FALSE;
3500 if (score_elf_section_data (sec)->u.tdata == NULL)
3501 return FALSE;
3503 to = contents;
3504 end = contents + sec->size;
3505 for (from = contents, i = 0; from < end; from += PDR_SIZE, i++)
3507 if ((score_elf_section_data (sec)->u.tdata)[i] == 1)
3508 continue;
3510 if (to != from)
3511 memcpy (to, from, PDR_SIZE);
3513 to += PDR_SIZE;
3515 bfd_set_section_contents (output_bfd, sec->output_section, contents,
3516 (file_ptr) sec->output_offset, sec->size);
3518 return TRUE;
3521 /* Copy data from a SCORE ELF indirect symbol to its direct symbol, hiding the old
3522 indirect symbol. Process additional relocation information. */
3524 static void
3525 _bfd_score_elf_copy_indirect_symbol (struct bfd_link_info *info,
3526 struct elf_link_hash_entry *dir,
3527 struct elf_link_hash_entry *ind)
3529 struct score_elf_link_hash_entry *dirscore, *indscore;
3531 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
3533 if (ind->root.type != bfd_link_hash_indirect)
3534 return;
3536 dirscore = (struct score_elf_link_hash_entry *) dir;
3537 indscore = (struct score_elf_link_hash_entry *) ind;
3538 dirscore->possibly_dynamic_relocs += indscore->possibly_dynamic_relocs;
3540 if (indscore->readonly_reloc)
3541 dirscore->readonly_reloc = TRUE;
3543 if (indscore->no_fn_stub)
3544 dirscore->no_fn_stub = TRUE;
3547 /* Remove information about discarded functions from other sections which mention them. */
3549 static bfd_boolean
3550 _bfd_score_elf_discard_info (bfd *abfd, struct elf_reloc_cookie *cookie,
3551 struct bfd_link_info *info)
3553 asection *o;
3554 bfd_boolean ret = FALSE;
3555 unsigned char *tdata;
3556 size_t i, skip;
3558 o = bfd_get_section_by_name (abfd, ".pdr");
3559 if ((!o) || (o->size == 0) || (o->size % PDR_SIZE != 0)
3560 || (o->output_section != NULL && bfd_is_abs_section (o->output_section)))
3561 return FALSE;
3563 tdata = bfd_zmalloc (o->size / PDR_SIZE);
3564 if (!tdata)
3565 return FALSE;
3567 cookie->rels = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL, info->keep_memory);
3568 if (!cookie->rels)
3570 free (tdata);
3571 return FALSE;
3574 cookie->rel = cookie->rels;
3575 cookie->relend = cookie->rels + o->reloc_count;
3577 for (i = 0, skip = 0; i < o->size; i++)
3579 if (bfd_elf_reloc_symbol_deleted_p (i * PDR_SIZE, cookie))
3581 tdata[i] = 1;
3582 skip++;
3586 if (skip != 0)
3588 score_elf_section_data (o)->u.tdata = tdata;
3589 o->size -= skip * PDR_SIZE;
3590 ret = TRUE;
3592 else
3593 free (tdata);
3595 if (!info->keep_memory)
3596 free (cookie->rels);
3598 return ret;
3601 /* Signal that discard_info() has removed the discarded relocations for this section. */
3603 static bfd_boolean
3604 _bfd_score_elf_ignore_discarded_relocs (asection *sec)
3606 if (strcmp (sec->name, ".pdr") == 0)
3607 return TRUE;
3608 return FALSE;
3611 /* Return the section that should be marked against GC for a given
3612 relocation. */
3614 static asection *
3615 _bfd_score_elf_gc_mark_hook (asection *sec,
3616 struct bfd_link_info *info,
3617 Elf_Internal_Rela *rel,
3618 struct elf_link_hash_entry *h,
3619 Elf_Internal_Sym *sym)
3621 if (h != NULL)
3622 switch (ELF32_R_TYPE (rel->r_info))
3624 case R_SCORE_GNU_VTINHERIT:
3625 case R_SCORE_GNU_VTENTRY:
3626 return NULL;
3629 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
3632 /* Support for core dump NOTE sections. */
3634 static bfd_boolean
3635 _bfd_score_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
3637 int offset;
3638 unsigned int raw_size;
3640 switch (note->descsz)
3642 default:
3643 return FALSE;
3645 case 148: /* Linux/Score 32-bit. */
3646 /* pr_cursig */
3647 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
3649 /* pr_pid */
3650 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
3652 /* pr_reg */
3653 offset = 72;
3654 raw_size = 72;
3656 break;
3659 /* Make a ".reg/999" section. */
3660 return _bfd_elfcore_make_pseudosection (abfd, ".reg", raw_size, note->descpos + offset);
3663 static bfd_boolean
3664 _bfd_score_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
3666 switch (note->descsz)
3668 default:
3669 return FALSE;
3671 case 124: /* Linux/Score elf_prpsinfo. */
3672 elf_tdata (abfd)->core_program = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
3673 elf_tdata (abfd)->core_command = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
3676 /* Note that for some reason, a spurious space is tacked
3677 onto the end of the args in some (at least one anyway)
3678 implementations, so strip it off if it exists. */
3681 char *command = elf_tdata (abfd)->core_command;
3682 int n = strlen (command);
3684 if (0 < n && command[n - 1] == ' ')
3685 command[n - 1] = '\0';
3688 return TRUE;
3692 /* Score BFD functions. */
3694 static reloc_howto_type *
3695 elf32_score_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED, bfd_reloc_code_real_type code)
3697 unsigned int i;
3699 for (i = 0; i < NUM_ELEM (elf32_score_reloc_map); i++)
3700 if (elf32_score_reloc_map[i].bfd_reloc_val == code)
3701 return &elf32_score_howto_table[elf32_score_reloc_map[i].elf_reloc_val];
3703 return NULL;
3706 /* Create a score elf linker hash table. */
3708 static struct bfd_link_hash_table *
3709 elf32_score_link_hash_table_create (bfd *abfd)
3711 struct score_elf_link_hash_table *ret;
3712 bfd_size_type amt = sizeof (struct score_elf_link_hash_table);
3714 ret = bfd_malloc (amt);
3715 if (ret == NULL)
3716 return NULL;
3718 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd, score_elf_link_hash_newfunc,
3719 sizeof (struct score_elf_link_hash_entry)))
3721 free (ret);
3722 return NULL;
3725 return &ret->root.root;
3728 static bfd_boolean
3729 elf32_score_print_private_bfd_data (bfd *abfd, void * ptr)
3731 FILE *file = (FILE *) ptr;
3733 BFD_ASSERT (abfd != NULL && ptr != NULL);
3735 /* Print normal ELF private data. */
3736 _bfd_elf_print_private_bfd_data (abfd, ptr);
3738 /* xgettext:c-format */
3739 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
3740 if (elf_elfheader (abfd)->e_flags & EF_SCORE_PIC)
3742 fprintf (file, _(" [pic]"));
3744 if (elf_elfheader (abfd)->e_flags & EF_SCORE_FIXDEP)
3746 fprintf (file, _(" [fix dep]"));
3748 fputc ('\n', file);
3750 return TRUE;
3753 static bfd_boolean
3754 elf32_score_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
3756 flagword in_flags;
3757 flagword out_flags;
3759 if (!_bfd_generic_verify_endian_match (ibfd, obfd))
3760 return FALSE;
3762 in_flags = elf_elfheader (ibfd)->e_flags;
3763 out_flags = elf_elfheader (obfd)->e_flags;
3765 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3766 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3767 return TRUE;
3769 in_flags = elf_elfheader (ibfd)->e_flags;
3770 out_flags = elf_elfheader (obfd)->e_flags;
3772 if (! elf_flags_init (obfd))
3774 elf_flags_init (obfd) = TRUE;
3775 elf_elfheader (obfd)->e_flags = in_flags;
3777 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
3778 && bfd_get_arch_info (obfd)->the_default)
3780 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
3783 return TRUE;
3786 if (((in_flags & EF_SCORE_PIC) != 0) != ((out_flags & EF_SCORE_PIC) != 0))
3788 (*_bfd_error_handler) (_("%B: warning: linking PIC files with non-PIC files"), ibfd);
3791 /* FIXME: Maybe dependency fix compatibility should be checked here. */
3793 return TRUE;
3796 static bfd_boolean
3797 elf32_score_new_section_hook (bfd *abfd, asection *sec)
3799 struct _score_elf_section_data *sdata;
3800 bfd_size_type amt = sizeof (*sdata);
3802 sdata = bfd_zalloc (abfd, amt);
3803 if (sdata == NULL)
3804 return FALSE;
3805 sec->used_by_bfd = sdata;
3807 return _bfd_elf_new_section_hook (abfd, sec);
3811 #define USE_REL 1
3812 #define TARGET_LITTLE_SYM bfd_elf32_littlescore_vec
3813 #define TARGET_LITTLE_NAME "elf32-littlescore"
3814 #define TARGET_BIG_SYM bfd_elf32_bigscore_vec
3815 #define TARGET_BIG_NAME "elf32-bigscore"
3816 #define ELF_ARCH bfd_arch_score
3817 #define ELF_MACHINE_CODE EM_SCORE
3818 #define ELF_MAXPAGESIZE 0x8000
3820 #define elf_info_to_howto 0
3821 #define elf_info_to_howto_rel _bfd_score_info_to_howto
3822 #define elf_backend_relocate_section _bfd_score_elf_relocate_section
3823 #define elf_backend_check_relocs _bfd_score_elf_check_relocs
3824 #define elf_backend_add_symbol_hook _bfd_score_elf_add_symbol_hook
3825 #define elf_backend_symbol_processing _bfd_score_elf_symbol_processing
3826 #define elf_backend_link_output_symbol_hook \
3827 _bfd_score_elf_link_output_symbol_hook
3828 #define elf_backend_section_from_bfd_section \
3829 _bfd_score_elf_section_from_bfd_section
3830 #define elf_backend_adjust_dynamic_symbol \
3831 _bfd_score_elf_adjust_dynamic_symbol
3832 #define elf_backend_always_size_sections \
3833 _bfd_score_elf_always_size_sections
3834 #define elf_backend_size_dynamic_sections \
3835 _bfd_score_elf_size_dynamic_sections
3836 #define elf_backend_omit_section_dynsym \
3837 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
3838 #define elf_backend_create_dynamic_sections \
3839 _bfd_score_elf_create_dynamic_sections
3840 #define elf_backend_finish_dynamic_symbol \
3841 _bfd_score_elf_finish_dynamic_symbol
3842 #define elf_backend_finish_dynamic_sections \
3843 _bfd_score_elf_finish_dynamic_sections
3844 #define elf_backend_fake_sections _bfd_score_elf_fake_sections
3845 #define elf_backend_section_processing _bfd_score_elf_section_processing
3846 #define elf_backend_write_section _bfd_score_elf_write_section
3847 #define elf_backend_copy_indirect_symbol _bfd_score_elf_copy_indirect_symbol
3848 #define elf_backend_hide_symbol _bfd_score_elf_hide_symbol
3849 #define elf_backend_discard_info _bfd_score_elf_discard_info
3850 #define elf_backend_ignore_discarded_relocs \
3851 _bfd_score_elf_ignore_discarded_relocs
3852 #define elf_backend_gc_mark_hook _bfd_score_elf_gc_mark_hook
3853 #define elf_backend_grok_prstatus _bfd_score_elf_grok_prstatus
3854 #define elf_backend_grok_psinfo _bfd_score_elf_grok_psinfo
3855 #define elf_backend_can_gc_sections 1
3856 #define elf_backend_want_plt_sym 0
3857 #define elf_backend_got_header_size (4 * SCORE_RESERVED_GOTNO)
3858 #define elf_backend_plt_header_size 0
3859 #define elf_backend_collect TRUE
3860 #define elf_backend_type_change_ok TRUE
3862 #define bfd_elf32_bfd_reloc_type_lookup elf32_score_reloc_type_lookup
3863 #define bfd_elf32_bfd_link_hash_table_create elf32_score_link_hash_table_create
3864 #define bfd_elf32_bfd_print_private_bfd_data elf32_score_print_private_bfd_data
3865 #define bfd_elf32_bfd_merge_private_bfd_data elf32_score_merge_private_bfd_data
3866 #define bfd_elf32_new_section_hook elf32_score_new_section_hook
3868 #include "elf32-target.h"