Update libiberty with latest sources from gcc mainline
[deliverable/binutils-gdb.git] / bfd / elf32-score.c
CommitLineData
1c0d3aa6 1/* 32-bit ELF support for S+core.
250d07de 2 Copyright (C) 2006-2021 Free Software Foundation, Inc.
1c0d3aa6 3 Contributed by
c3b7224a 4 Brain.lin (brain.lin@sunplusct.com)
1c0d3aa6
NC
5 Mei Ligang (ligang@sunnorth.com.cn)
6 Pei-Lin Tsai (pltsai@sunplus.com)
7
8 This file is part of BFD, the Binary File Descriptor library.
9
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
cd123cb7 12 the Free Software Foundation; either version 3 of the License, or
1c0d3aa6
NC
13 (at your option) any later version.
14
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
cd123cb7
NC
22 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
23 MA 02110-1301, USA. */
1c0d3aa6 24
1c0d3aa6 25#include "sysdep.h"
3db64b00 26#include "bfd.h"
1c0d3aa6
NC
27#include "libbfd.h"
28#include "libiberty.h"
29#include "elf-bfd.h"
30#include "elf/score.h"
31#include "elf/common.h"
32#include "elf/internal.h"
33#include "hashtab.h"
c3b7224a 34#include "elf32-score.h"
1c0d3aa6
NC
35
36
c3b7224a
NC
37int score3 = 0;
38int score7 = 1;
1c0d3aa6 39
1c0d3aa6
NC
40/* The SCORE ELF linker needs additional information for each symbol in
41 the global hash table. */
1c0d3aa6
NC
42struct score_elf_link_hash_entry
43{
44 struct elf_link_hash_entry root;
45
46 /* Number of R_SCORE_ABS32, R_SCORE_REL32 relocs against this symbol. */
47 unsigned int possibly_dynamic_relocs;
48
49 /* If the R_SCORE_ABS32, R_SCORE_REL32 reloc is against a readonly section. */
50 bfd_boolean readonly_reloc;
51
52 /* We must not create a stub for a symbol that has relocations related to
53 taking the function's address, i.e. any but R_SCORE_CALL15 ones. */
54 bfd_boolean no_fn_stub;
55
56 /* Are we forced local? This will only be set if we have converted
57 the initial global GOT entry to a local GOT entry. */
58 bfd_boolean forced_local;
59};
60
61/* Traverse a score ELF linker hash table. */
62#define score_elf_link_hash_traverse(table, func, info) \
63 (elf_link_hash_traverse \
4dfe6ac6 64 ((table), \
1c0d3aa6
NC
65 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
66 (info)))
67
1c0d3aa6
NC
68/* This structure is used to hold .got entries while estimating got sizes. */
69struct score_got_entry
70{
71 /* The input bfd in which the symbol is defined. */
72 bfd *abfd;
73 /* The index of the symbol, as stored in the relocation r_info, if
74 we have a local symbol; -1 otherwise. */
75 long symndx;
76 union
77 {
78 /* If abfd == NULL, an address that must be stored in the got. */
79 bfd_vma address;
80 /* If abfd != NULL && symndx != -1, the addend of the relocation
81 that should be added to the symbol value. */
82 bfd_vma addend;
83 /* If abfd != NULL && symndx == -1, the hash table entry
84 corresponding to a global symbol in the got (or, local, if
85 h->forced_local). */
86 struct score_elf_link_hash_entry *h;
87 } d;
88
89 /* The offset from the beginning of the .got section to the entry
90 corresponding to this symbol+addend. If it's a global symbol
91 whose offset is yet to be decided, it's going to be -1. */
92 long gotidx;
93};
94
95/* This structure is passed to score_elf_sort_hash_table_f when sorting
96 the dynamic symbols. */
97
98struct score_elf_hash_sort_data
99{
100 /* The symbol in the global GOT with the lowest dynamic symbol table index. */
101 struct elf_link_hash_entry *low;
102 /* The least dynamic symbol table index corresponding to a symbol with a GOT entry. */
103 long min_got_dynindx;
104 /* The greatest dynamic symbol table index corresponding to a symbol
105 with a GOT entry that is not referenced (e.g., a dynamic symbol
106 with dynamic relocations pointing to it from non-primary GOTs). */
107 long max_unref_got_dynindx;
108 /* The greatest dynamic symbol table index not corresponding to a
109 symbol without a GOT entry. */
110 long max_non_got_dynindx;
111};
112
113struct score_got_info
114{
115 /* The global symbol in the GOT with the lowest index in the dynamic
116 symbol table. */
117 struct elf_link_hash_entry *global_gotsym;
118 /* The number of global .got entries. */
119 unsigned int global_gotno;
120 /* The number of local .got entries. */
121 unsigned int local_gotno;
122 /* The number of local .got entries we have used. */
123 unsigned int assigned_gotno;
124 /* A hash table holding members of the got. */
125 struct htab *got_entries;
126 /* In multi-got links, a pointer to the next got (err, rather, most
127 of the time, it points to the previous got). */
128 struct score_got_info *next;
129};
130
131/* A structure used to count GOT entries, for GOT entry or ELF symbol table traversal. */
132struct _score_elf_section_data
133{
134 struct bfd_elf_section_data elf;
135 union
136 {
137 struct score_got_info *got_info;
138 bfd_byte *tdata;
139 }
140 u;
141};
142
143#define score_elf_section_data(sec) \
144 ((struct _score_elf_section_data *) elf_section_data (sec))
145
146/* The size of a symbol-table entry. */
147#define SCORE_ELF_SYM_SIZE(abfd) \
148 (get_elf_backend_data (abfd)->s->sizeof_sym)
149
150/* In case we're on a 32-bit machine, construct a 64-bit "-1" value
151 from smaller values. Start with zero, widen, *then* decrement. */
152#define MINUS_ONE (((bfd_vma)0) - 1)
153#define MINUS_TWO (((bfd_vma)0) - 2)
154
155#define PDR_SIZE 32
156
157
158/* The number of local .got entries we reserve. */
159#define SCORE_RESERVED_GOTNO (2)
160#define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1"
161
162/* The offset of $gp from the beginning of the .got section. */
163#define ELF_SCORE_GP_OFFSET(abfd) (0x3ff0)
164/* The maximum size of the GOT for it to be addressable using 15-bit offsets from $gp. */
165#define SCORE_ELF_GOT_MAX_SIZE(abfd) (ELF_SCORE_GP_OFFSET(abfd) + 0x3fff)
166
167#define SCORE_ELF_STUB_SECTION_NAME (".SCORE.stub")
168#define SCORE_FUNCTION_STUB_SIZE (16)
169
c3b7224a 170#define STUB_LW 0xc3bcc010 /* lw r29, [r28, -0x3ff0] */
1c0d3aa6
NC
171#define STUB_MOVE 0x8363bc56 /* mv r27, r3 */
172#define STUB_LI16 0x87548000 /* ori r26, .dynsym_index */
173#define STUB_BRL 0x801dbc09 /* brl r29 */
174
175#define SCORE_ELF_GOT_SIZE(abfd) \
176 (get_elf_backend_data (abfd)->s->arch_size / 8)
177
178#define SCORE_ELF_ADD_DYNAMIC_ENTRY(info, tag, val) \
07d6d2b8 179 (_bfd_elf_add_dynamic_entry (info, (bfd_vma) tag, (bfd_vma) val))
1c0d3aa6
NC
180
181/* The size of an external dynamic table entry. */
182#define SCORE_ELF_DYN_SIZE(abfd) \
183 (get_elf_backend_data (abfd)->s->sizeof_dyn)
184
185/* The size of an external REL relocation. */
186#define SCORE_ELF_REL_SIZE(abfd) \
187 (get_elf_backend_data (abfd)->s->sizeof_rel)
188
189/* The default alignment for sections, as a power of two. */
190#define SCORE_ELF_LOG_FILE_ALIGN(abfd)\
191 (get_elf_backend_data (abfd)->s->log_file_align)
192
1c0d3aa6
NC
193static bfd_byte *hi16_rel_addr;
194
195/* This will be used when we sort the dynamic relocation records. */
196static bfd *reldyn_sorting_bfd;
197
198/* SCORE ELF uses two common sections. One is the usual one, and the
199 other is for small objects. All the small objects are kept
200 together, and then referenced via the gp pointer, which yields
201 faster assembler code. This is what we use for the small common
202 section. This approach is copied from ecoff.c. */
203static asection score_elf_scom_section;
7f3a18cf
AM
204static const asymbol score_elf_scom_symbol =
205 GLOBAL_SYM_INIT (".scommon", &score_elf_scom_section);
206static asection score_elf_scom_section =
207 BFD_FAKE_SECTION (score_elf_scom_section, &score_elf_scom_symbol,
208 ".scommon", 0, SEC_IS_COMMON | SEC_SMALL_DATA);
1c0d3aa6 209
c3b7224a
NC
210static bfd_vma
211score_bfd_get_16 (bfd *abfd, const void *data)
212{
213 return bfd_get_16 (abfd, data);
214}
215
216static bfd_vma
217score3_bfd_getl32 (const void *p)
218{
219 const bfd_byte *addr = p;
220 unsigned long v;
221
222 v = (unsigned long) addr[2];
223 v |= (unsigned long) addr[3] << 8;
224 v |= (unsigned long) addr[0] << 16;
225 v |= (unsigned long) addr[1] << 24;
226 return v;
227}
228
229static bfd_vma
230score3_bfd_getl48 (const void *p)
231{
232 const bfd_byte *addr = p;
ce9116fd
AM
233 bfd_uint64_t v;
234
235 v = (bfd_uint64_t) addr[4];
236 v |= (bfd_uint64_t) addr[5] << 8;
237 v |= (bfd_uint64_t) addr[2] << 16;
238 v |= (bfd_uint64_t) addr[3] << 24;
239 v |= (bfd_uint64_t) addr[0] << 32;
240 v |= (bfd_uint64_t) addr[1] << 40;
c3b7224a
NC
241 return v;
242}
243
244static bfd_vma
245score_bfd_get_32 (bfd *abfd, const void *data)
246{
247 if (/* score3 && */ abfd->xvec->byteorder == BFD_ENDIAN_LITTLE)
248 return score3_bfd_getl32 (data);
249 else
250 return bfd_get_32 (abfd, data);
251}
252
253static bfd_vma
254score_bfd_get_48 (bfd *abfd, const void *p)
255{
256 if (/* score3 && */ abfd->xvec->byteorder == BFD_ENDIAN_LITTLE)
257 return score3_bfd_getl48 (p);
258 else
259 return bfd_get_bits (p, 48, 1);
260}
261
262static void
263score_bfd_put_16 (bfd *abfd, bfd_vma addr, void *data)
264{
265 return bfd_put_16 (abfd, addr, data);
266}
267
268static void
269score3_bfd_putl32 (bfd_vma data, void *p)
270{
271 bfd_byte *addr = p;
272 addr[0] = (data >> 16) & 0xff;
273 addr[1] = (data >> 24) & 0xff;
274 addr[2] = data & 0xff;
275 addr[3] = (data >> 8) & 0xff;
276}
277
278static void
279score3_bfd_putl48 (bfd_vma data, void *p)
280{
281 bfd_byte *addr = p;
282 addr[0] = (data >> 32) & 0xff;
283 addr[1] = (data >> 40) & 0xff;
284 addr[2] = (data >> 16) & 0xff;
285 addr[3] = (data >> 24) & 0xff;
286 addr[4] = data & 0xff;
287 addr[5] = (data >> 8) & 0xff;
288}
289
290static void
291score_bfd_put_32 (bfd *abfd, bfd_vma addr, void *data)
292{
293 if (/* score3 && */ abfd->xvec->byteorder == BFD_ENDIAN_LITTLE)
294 return score3_bfd_putl32 (addr, data);
295 else
296 return bfd_put_32 (abfd, addr, data);
297}
298
299static void
300score_bfd_put_48 (bfd *abfd, bfd_vma val, void *p)
301{
302 if (/* score3 && */ abfd->xvec->byteorder == BFD_ENDIAN_LITTLE)
303 return score3_bfd_putl48 (val, p);
304 else
305 return bfd_put_bits (val, p, 48, 1);
306}
307
1c0d3aa6
NC
308static bfd_reloc_status_type
309score_elf_hi16_reloc (bfd *abfd ATTRIBUTE_UNUSED,
07d6d2b8
AM
310 arelent *reloc_entry,
311 asymbol *symbol ATTRIBUTE_UNUSED,
312 void * data,
313 asection *input_section ATTRIBUTE_UNUSED,
314 bfd *output_bfd ATTRIBUTE_UNUSED,
315 char **error_message ATTRIBUTE_UNUSED)
1c0d3aa6
NC
316{
317 hi16_rel_addr = (bfd_byte *) data + reloc_entry->address;
318 return bfd_reloc_ok;
319}
320
321static bfd_reloc_status_type
322score_elf_lo16_reloc (bfd *abfd,
07d6d2b8
AM
323 arelent *reloc_entry,
324 asymbol *symbol ATTRIBUTE_UNUSED,
325 void * data,
326 asection *input_section,
327 bfd *output_bfd ATTRIBUTE_UNUSED,
328 char **error_message ATTRIBUTE_UNUSED)
1c0d3aa6
NC
329{
330 bfd_vma addend = 0, offset = 0;
331 unsigned long val;
332 unsigned long hi16_offset, hi16_value, uvalue;
333
c3b7224a 334 hi16_value = score_bfd_get_32 (abfd, hi16_rel_addr);
1c0d3aa6 335 hi16_offset = ((((hi16_value >> 16) & 0x3) << 15) | (hi16_value & 0x7fff)) >> 1;
c3b7224a 336 addend = score_bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
1c0d3aa6
NC
337 offset = ((((addend >> 16) & 0x3) << 15) | (addend & 0x7fff)) >> 1;
338 val = reloc_entry->addend;
339 if (reloc_entry->address > input_section->size)
340 return bfd_reloc_outofrange;
341 uvalue = ((hi16_offset << 16) | (offset & 0xffff)) + val;
342 hi16_offset = (uvalue >> 16) << 1;
343 hi16_value = (hi16_value & ~0x37fff) | (hi16_offset & 0x7fff) | ((hi16_offset << 1) & 0x30000);
c3b7224a 344 score_bfd_put_32 (abfd, hi16_value, hi16_rel_addr);
1c0d3aa6
NC
345 offset = (uvalue & 0xffff) << 1;
346 addend = (addend & ~0x37fff) | (offset & 0x7fff) | ((offset << 1) & 0x30000);
c3b7224a 347 score_bfd_put_32 (abfd, addend, (bfd_byte *) data + reloc_entry->address);
1c0d3aa6
NC
348 return bfd_reloc_ok;
349}
350
351/* Set the GP value for OUTPUT_BFD. Returns FALSE if this is a
352 dangerous relocation. */
353
354static bfd_boolean
355score_elf_assign_gp (bfd *output_bfd, bfd_vma *pgp)
356{
357 unsigned int count;
358 asymbol **sym;
359 unsigned int i;
360
361 /* If we've already figured out what GP will be, just return it. */
362 *pgp = _bfd_get_gp_value (output_bfd);
363 if (*pgp)
364 return TRUE;
365
366 count = bfd_get_symcount (output_bfd);
367 sym = bfd_get_outsymbols (output_bfd);
368
369 /* The linker script will have created a symbol named `_gp' with the
370 appropriate value. */
371 if (sym == NULL)
372 i = count;
373 else
374 {
375 for (i = 0; i < count; i++, sym++)
07d6d2b8
AM
376 {
377 const char *name;
378
379 name = bfd_asymbol_name (*sym);
380 if (*name == '_' && strcmp (name, "_gp") == 0)
381 {
382 *pgp = bfd_asymbol_value (*sym);
383 _bfd_set_gp_value (output_bfd, *pgp);
384 break;
385 }
386 }
1c0d3aa6
NC
387 }
388
389 if (i >= count)
390 {
391 /* Only get the error once. */
392 *pgp = 4;
393 _bfd_set_gp_value (output_bfd, *pgp);
394 return FALSE;
395 }
396
397 return TRUE;
398}
399
400/* We have to figure out the gp value, so that we can adjust the
401 symbol value correctly. We look up the symbol _gp in the output
402 BFD. If we can't find it, we're stuck. We cache it in the ELF
403 target data. We don't need to adjust the symbol value for an
404 external symbol if we are producing relocatable output. */
1c0d3aa6
NC
405static bfd_reloc_status_type
406score_elf_final_gp (bfd *output_bfd,
07d6d2b8
AM
407 asymbol *symbol,
408 bfd_boolean relocatable,
409 char **error_message,
410 bfd_vma *pgp)
1c0d3aa6
NC
411{
412 if (bfd_is_und_section (symbol->section)
413 && ! relocatable)
414 {
415 *pgp = 0;
416 return bfd_reloc_undefined;
417 }
418
419 *pgp = _bfd_get_gp_value (output_bfd);
420 if (*pgp == 0
421 && (! relocatable
07d6d2b8 422 || (symbol->flags & BSF_SECTION_SYM) != 0))
1c0d3aa6
NC
423 {
424 if (relocatable)
07d6d2b8
AM
425 {
426 /* Make up a value. */
427 *pgp = symbol->section->output_section->vma + 0x4000;
428 _bfd_set_gp_value (output_bfd, *pgp);
429 }
1c0d3aa6 430 else if (!score_elf_assign_gp (output_bfd, pgp))
07d6d2b8
AM
431 {
432 *error_message =
433 (char *) _("GP relative relocation when _gp not defined");
434 return bfd_reloc_dangerous;
435 }
1c0d3aa6
NC
436 }
437
438 return bfd_reloc_ok;
439}
440
441static bfd_reloc_status_type
442score_elf_gprel15_with_gp (bfd *abfd,
07d6d2b8
AM
443 asymbol *symbol,
444 arelent *reloc_entry,
445 asection *input_section,
446 bfd_boolean relocateable,
447 void * data,
448 bfd_vma gp ATTRIBUTE_UNUSED)
1c0d3aa6
NC
449{
450 bfd_vma relocation;
451 unsigned long insn;
452
453 if (bfd_is_com_section (symbol->section))
454 relocation = 0;
455 else
456 relocation = symbol->value;
457
458 relocation += symbol->section->output_section->vma;
459 relocation += symbol->section->output_offset;
460 if (reloc_entry->address > input_section->size)
461 return bfd_reloc_outofrange;
462
c3b7224a 463 insn = score_bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
1c0d3aa6
NC
464 if (((reloc_entry->addend & 0xffffc000) != 0)
465 && ((reloc_entry->addend & 0xffffc000) != 0xffffc000))
466 return bfd_reloc_overflow;
467
468 insn = (insn & ~0x7fff) | (reloc_entry->addend & 0x7fff);
c3b7224a 469 score_bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address);
1c0d3aa6
NC
470 if (relocateable)
471 reloc_entry->address += input_section->output_offset;
472
473 return bfd_reloc_ok;
474}
475
476static bfd_reloc_status_type
477gprel32_with_gp (bfd *abfd, asymbol *symbol, arelent *reloc_entry,
07d6d2b8
AM
478 asection *input_section, bfd_boolean relocatable,
479 void *data, bfd_vma gp)
1c0d3aa6
NC
480{
481 bfd_vma relocation;
482 bfd_vma val;
483
484 if (bfd_is_com_section (symbol->section))
485 relocation = 0;
486 else
487 relocation = symbol->value;
488
489 relocation += symbol->section->output_section->vma;
490 relocation += symbol->section->output_offset;
491
492 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
493 return bfd_reloc_outofrange;
494
495 /* Set val to the offset into the section or symbol. */
496 val = reloc_entry->addend;
497
498 if (reloc_entry->howto->partial_inplace)
c3b7224a 499 val += score_bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
1c0d3aa6
NC
500
501 /* Adjust val for the final section location and GP value. If we
502 are producing relocatable output, we don't want to do this for
503 an external symbol. */
504 if (! relocatable
505 || (symbol->flags & BSF_SECTION_SYM) != 0)
506 val += relocation - gp;
507
508 if (reloc_entry->howto->partial_inplace)
c3b7224a 509 score_bfd_put_32 (abfd, val, (bfd_byte *) data + reloc_entry->address);
1c0d3aa6
NC
510 else
511 reloc_entry->addend = val;
512
513 if (relocatable)
514 reloc_entry->address += input_section->output_offset;
515
516 return bfd_reloc_ok;
517}
518
519static bfd_reloc_status_type
520score_elf_gprel15_reloc (bfd *abfd,
07d6d2b8
AM
521 arelent *reloc_entry,
522 asymbol *symbol,
523 void * data,
524 asection *input_section,
525 bfd *output_bfd,
526 char **error_message)
1c0d3aa6
NC
527{
528 bfd_boolean relocateable;
529 bfd_reloc_status_type ret;
530 bfd_vma gp;
531
c3b7224a 532 if (output_bfd != NULL
1c0d3aa6
NC
533 && (symbol->flags & BSF_SECTION_SYM) == 0 && reloc_entry->addend == 0)
534 {
535 reloc_entry->address += input_section->output_offset;
536 return bfd_reloc_ok;
537 }
c3b7224a 538 if (output_bfd != NULL)
1c0d3aa6
NC
539 relocateable = TRUE;
540 else
541 {
542 relocateable = FALSE;
543 output_bfd = symbol->section->output_section->owner;
544 }
545
546 ret = score_elf_final_gp (output_bfd, symbol, relocateable, error_message, &gp);
547 if (ret != bfd_reloc_ok)
548 return ret;
549
550 return score_elf_gprel15_with_gp (abfd, symbol, reloc_entry,
07d6d2b8 551 input_section, relocateable, data, gp);
1c0d3aa6
NC
552}
553
554/* Do a R_SCORE_GPREL32 relocation. This is a 32 bit value which must
555 become the offset from the gp register. */
556
557static bfd_reloc_status_type
558score_elf_gprel32_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
07d6d2b8
AM
559 void *data, asection *input_section, bfd *output_bfd,
560 char **error_message)
1c0d3aa6
NC
561{
562 bfd_boolean relocatable;
563 bfd_reloc_status_type ret;
564 bfd_vma gp;
565
566 /* R_SCORE_GPREL32 relocations are defined for local symbols only. */
567 if (output_bfd != NULL
568 && (symbol->flags & BSF_SECTION_SYM) == 0
569 && (symbol->flags & BSF_LOCAL) != 0)
570 {
571 *error_message = (char *)
07d6d2b8 572 _("32bits gp relative relocation occurs for an external symbol");
1c0d3aa6
NC
573 return bfd_reloc_outofrange;
574 }
575
576 if (output_bfd != NULL)
577 relocatable = TRUE;
578 else
579 {
580 relocatable = FALSE;
581 output_bfd = symbol->section->output_section->owner;
582 }
583
584 ret = score_elf_final_gp (output_bfd, symbol, relocatable, error_message, &gp);
585 if (ret != bfd_reloc_ok)
586 return ret;
587
c3b7224a 588 gp = 0;
1c0d3aa6 589 return gprel32_with_gp (abfd, symbol, reloc_entry, input_section,
07d6d2b8 590 relocatable, data, gp);
1c0d3aa6
NC
591}
592
593/* A howto special_function for R_SCORE_GOT15 relocations. This is just
594 like any other 16-bit relocation when applied to global symbols, but is
595 treated in the same as R_SCORE_HI16 when applied to local symbols. */
1c0d3aa6
NC
596static bfd_reloc_status_type
597score_elf_got15_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
07d6d2b8
AM
598 void *data, asection *input_section,
599 bfd *output_bfd, char **error_message)
1c0d3aa6
NC
600{
601 if ((symbol->flags & (BSF_GLOBAL | BSF_WEAK)) != 0
e6f7f6d1
AM
602 || bfd_is_und_section (bfd_asymbol_section (symbol))
603 || bfd_is_com_section (bfd_asymbol_section (symbol)))
1c0d3aa6
NC
604 /* The relocation is against a global symbol. */
605 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
07d6d2b8
AM
606 input_section, output_bfd,
607 error_message);
1c0d3aa6
NC
608
609 return score_elf_hi16_reloc (abfd, reloc_entry, symbol, data,
07d6d2b8 610 input_section, output_bfd, error_message);
1c0d3aa6
NC
611}
612
613static bfd_reloc_status_type
614score_elf_got_lo16_reloc (bfd *abfd,
07d6d2b8
AM
615 arelent *reloc_entry,
616 asymbol *symbol ATTRIBUTE_UNUSED,
617 void * data,
618 asection *input_section,
619 bfd *output_bfd ATTRIBUTE_UNUSED,
620 char **error_message ATTRIBUTE_UNUSED)
1c0d3aa6
NC
621{
622 bfd_vma addend = 0, offset = 0;
0150d082
ML
623 signed long val;
624 signed long hi16_offset, hi16_value, uvalue;
1c0d3aa6 625
c3b7224a 626 hi16_value = score_bfd_get_32 (abfd, hi16_rel_addr);
1c0d3aa6 627 hi16_offset = ((((hi16_value >> 16) & 0x3) << 15) | (hi16_value & 0x7fff)) >> 1;
c3b7224a 628 addend = score_bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address);
1c0d3aa6
NC
629 offset = ((((addend >> 16) & 0x3) << 15) | (addend & 0x7fff)) >> 1;
630 val = reloc_entry->addend;
631 if (reloc_entry->address > input_section->size)
632 return bfd_reloc_outofrange;
633 uvalue = ((hi16_offset << 16) | (offset & 0xffff)) + val;
0150d082
ML
634 if ((uvalue > -0x8000) && (uvalue < 0x7fff))
635 hi16_offset = 0;
636 else
637 hi16_offset = (uvalue >> 16) & 0x7fff;
1c0d3aa6 638 hi16_value = (hi16_value & ~0x37fff) | (hi16_offset & 0x7fff) | ((hi16_offset << 1) & 0x30000);
c3b7224a 639 score_bfd_put_32 (abfd, hi16_value, hi16_rel_addr);
1c0d3aa6
NC
640 offset = (uvalue & 0xffff) << 1;
641 addend = (addend & ~0x37fff) | (offset & 0x7fff) | ((offset << 1) & 0x30000);
c3b7224a 642 score_bfd_put_32 (abfd, addend, (bfd_byte *) data + reloc_entry->address);
1c0d3aa6
NC
643 return bfd_reloc_ok;
644}
645
646static reloc_howto_type elf32_score_howto_table[] =
647{
648 /* No relocation. */
07d6d2b8
AM
649 HOWTO (R_SCORE_NONE, /* type */
650 0, /* rightshift */
651 3, /* size (0 = byte, 1 = short, 2 = long) */
652 0, /* bitsize */
653 FALSE, /* pc_relative */
654 0, /* bitpos */
655 complain_overflow_dont,/* complain_on_overflow */
656 bfd_elf_generic_reloc, /* special_function */
657 "R_SCORE_NONE", /* name */
658 FALSE, /* partial_inplace */
659 0, /* src_mask */
660 0, /* dst_mask */
661 FALSE), /* pcrel_offset */
1c0d3aa6
NC
662
663 /* R_SCORE_HI16 */
07d6d2b8
AM
664 HOWTO (R_SCORE_HI16, /* type */
665 0, /* rightshift */
666 2, /* size (0 = byte, 1 = short, 2 = long) */
667 16, /* bitsize */
668 FALSE, /* pc_relative */
669 1, /* bitpos */
670 complain_overflow_dont,/* complain_on_overflow */
671 score_elf_hi16_reloc, /* special_function */
672 "R_SCORE_HI16", /* name */
673 TRUE, /* partial_inplace */
674 0x37fff, /* src_mask */
675 0x37fff, /* dst_mask */
676 FALSE), /* pcrel_offset */
1c0d3aa6
NC
677
678 /* R_SCORE_LO16 */
07d6d2b8
AM
679 HOWTO (R_SCORE_LO16, /* type */
680 0, /* rightshift */
681 2, /* size (0 = byte, 1 = short, 2 = long) */
682 16, /* bitsize */
683 FALSE, /* pc_relative */
684 1, /* bitpos */
685 complain_overflow_dont,/* complain_on_overflow */
686 score_elf_lo16_reloc, /* special_function */
687 "R_SCORE_LO16", /* name */
688 TRUE, /* partial_inplace */
689 0x37fff, /* src_mask */
690 0x37fff, /* dst_mask */
691 FALSE), /* pcrel_offset */
1c0d3aa6 692
c3b7224a 693 /* R_SCORE_BCMP */
07d6d2b8
AM
694 HOWTO (R_SCORE_BCMP, /* type */
695 1, /* rightshift */
696 2, /* size (0 = byte, 1 = short, 2 = long) */
697 16, /* bitsize */
698 TRUE, /* pc_relative */
699 1, /* bitpos */
700 complain_overflow_dont,/* complain_on_overflow */
701 bfd_elf_generic_reloc, /* special_function */
702 "R_SCORE_BCMP", /* name */
703 FALSE, /* partial_inplace */
704 0x03e00381, /* src_mask */
705 0x03e00381, /* dst_mask */
706 FALSE), /* pcrel_offset */
1c0d3aa6
NC
707
708 /*R_SCORE_24 */
07d6d2b8
AM
709 HOWTO (R_SCORE_24, /* type */
710 1, /* rightshift */
711 2, /* size (0 = byte, 1 = short, 2 = long) */
712 24, /* bitsize */
713 FALSE, /* pc_relative */
714 1, /* bitpos */
715 complain_overflow_dont,/* complain_on_overflow */
716 bfd_elf_generic_reloc, /* special_function */
717 "R_SCORE_24", /* name */
718 FALSE, /* partial_inplace */
719 0x3ff7fff, /* src_mask */
720 0x3ff7fff, /* dst_mask */
721 FALSE), /* pcrel_offset */
1c0d3aa6
NC
722
723 /*R_SCORE_PC19 */
07d6d2b8
AM
724 HOWTO (R_SCORE_PC19, /* type */
725 1, /* rightshift */
726 2, /* size (0 = byte, 1 = short, 2 = long) */
727 19, /* bitsize */
728 TRUE, /* pc_relative */
729 1, /* bitpos */
730 complain_overflow_dont,/* complain_on_overflow */
731 bfd_elf_generic_reloc, /* special_function */
732 "R_SCORE_PC19", /* name */
733 FALSE, /* partial_inplace */
734 0x3ff03fe, /* src_mask */
735 0x3ff03fe, /* dst_mask */
736 FALSE), /* pcrel_offset */
1c0d3aa6
NC
737
738 /*R_SCORE16_11 */
07d6d2b8
AM
739 HOWTO (R_SCORE16_11, /* type */
740 1, /* rightshift */
741 1, /* size (0 = byte, 1 = short, 2 = long) */
742 11, /* bitsize */
743 FALSE, /* pc_relative */
744 1, /* bitpos */
745 complain_overflow_dont,/* complain_on_overflow */
746 bfd_elf_generic_reloc, /* special_function */
747 "R_SCORE16_11", /* name */
748 FALSE, /* partial_inplace */
749 0x000000ffe, /* src_mask */
750 0x000000ffe, /* dst_mask */
751 FALSE), /* pcrel_offset */
1c0d3aa6
NC
752
753 /* R_SCORE16_PC8 */
07d6d2b8
AM
754 HOWTO (R_SCORE16_PC8, /* type */
755 1, /* rightshift */
756 1, /* size (0 = byte, 1 = short, 2 = long) */
757 9, /* bitsize */
758 TRUE, /* pc_relative */
759 0, /* bitpos */
760 complain_overflow_dont,/* complain_on_overflow */
761 bfd_elf_generic_reloc, /* special_function */
762 "R_SCORE16_PC8", /* name */
763 FALSE, /* partial_inplace */
764 0x000001ff, /* src_mask */
765 0x000001ff, /* dst_mask */
766 FALSE), /* pcrel_offset */
1c0d3aa6
NC
767
768 /* 32 bit absolute */
07d6d2b8
AM
769 HOWTO (R_SCORE_ABS32, /* type 8 */
770 0, /* rightshift */
771 2, /* size (0 = byte, 1 = short, 2 = long) */
772 32, /* bitsize */
773 FALSE, /* pc_relative */
774 0, /* bitpos */
775 complain_overflow_bitfield, /* complain_on_overflow */
776 bfd_elf_generic_reloc, /* special_function */
777 "R_SCORE_ABS32", /* name */
778 FALSE, /* partial_inplace */
779 0xffffffff, /* src_mask */
780 0xffffffff, /* dst_mask */
781 FALSE), /* pcrel_offset */
1c0d3aa6
NC
782
783 /* 16 bit absolute */
07d6d2b8
AM
784 HOWTO (R_SCORE_ABS16, /* type 11 */
785 0, /* rightshift */
786 1, /* size (0 = byte, 1 = short, 2 = long) */
787 16, /* bitsize */
788 FALSE, /* pc_relative */
789 0, /* bitpos */
790 complain_overflow_bitfield, /* complain_on_overflow */
791 bfd_elf_generic_reloc, /* special_function */
792 "R_SCORE_ABS16", /* name */
793 FALSE, /* partial_inplace */
794 0x0000ffff, /* src_mask */
795 0x0000ffff, /* dst_mask */
796 FALSE), /* pcrel_offset */
1c0d3aa6
NC
797
798 /* R_SCORE_DUMMY2 */
07d6d2b8
AM
799 HOWTO (R_SCORE_DUMMY2, /* type */
800 0, /* rightshift */
801 2, /* size (0 = byte, 1 = short, 2 = long) */
802 16, /* bitsize */
803 FALSE, /* pc_relative */
804 0, /* bitpos */
805 complain_overflow_dont,/* complain_on_overflow */
806 bfd_elf_generic_reloc, /* special_function */
807 "R_SCORE_DUMMY2", /* name */
808 TRUE, /* partial_inplace */
809 0x00007fff, /* src_mask */
810 0x00007fff, /* dst_mask */
811 FALSE), /* pcrel_offset */
1c0d3aa6
NC
812
813 /* R_SCORE_GP15 */
07d6d2b8
AM
814 HOWTO (R_SCORE_GP15, /* type */
815 0, /* rightshift */
816 2, /* size (0 = byte, 1 = short, 2 = long) */
817 16, /* bitsize */
818 FALSE, /* pc_relative */
819 0, /* bitpos */
820 complain_overflow_dont,/* complain_on_overflow */
821 score_elf_gprel15_reloc,/* special_function */
822 "R_SCORE_GP15", /* name */
823 TRUE, /* partial_inplace */
824 0x00007fff, /* src_mask */
825 0x00007fff, /* dst_mask */
826 FALSE), /* pcrel_offset */
1c0d3aa6
NC
827
828 /* GNU extension to record C++ vtable hierarchy. */
829 HOWTO (R_SCORE_GNU_VTINHERIT, /* type */
07d6d2b8
AM
830 0, /* rightshift */
831 2, /* size (0 = byte, 1 = short, 2 = long) */
832 0, /* bitsize */
833 FALSE, /* pc_relative */
834 0, /* bitpos */
835 complain_overflow_dont,/* complain_on_overflow */
836 NULL, /* special_function */
837 "R_SCORE_GNU_VTINHERIT", /* name */
838 FALSE, /* partial_inplace */
839 0, /* src_mask */
840 0, /* dst_mask */
841 FALSE), /* pcrel_offset */
1c0d3aa6
NC
842
843 /* GNU extension to record C++ vtable member usage */
07d6d2b8
AM
844 HOWTO (R_SCORE_GNU_VTENTRY, /* type */
845 0, /* rightshift */
846 2, /* size (0 = byte, 1 = short, 2 = long) */
847 0, /* bitsize */
848 FALSE, /* pc_relative */
849 0, /* bitpos */
850 complain_overflow_dont,/* complain_on_overflow */
851 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
852 "R_SCORE_GNU_VTENTRY", /* name */
853 FALSE, /* partial_inplace */
854 0, /* src_mask */
855 0, /* dst_mask */
856 FALSE), /* pcrel_offset */
1c0d3aa6
NC
857
858 /* Reference to global offset table. */
07d6d2b8
AM
859 HOWTO (R_SCORE_GOT15, /* type */
860 0, /* rightshift */
861 2, /* size (0 = byte, 1 = short, 2 = long) */
862 16, /* bitsize */
863 FALSE, /* pc_relative */
864 0, /* bitpos */
865 complain_overflow_signed, /* complain_on_overflow */
866 score_elf_got15_reloc, /* special_function */
867 "R_SCORE_GOT15", /* name */
868 TRUE, /* partial_inplace */
869 0x00007fff, /* src_mask */
870 0x00007fff, /* dst_mask */
871 FALSE), /* pcrel_offset */
1c0d3aa6
NC
872
873 /* Low 16 bits of displacement in global offset table. */
07d6d2b8
AM
874 HOWTO (R_SCORE_GOT_LO16, /* type */
875 0, /* rightshift */
876 2, /* size (0 = byte, 1 = short, 2 = long) */
877 16, /* bitsize */
878 FALSE, /* pc_relative */
879 1, /* bitpos */
880 complain_overflow_dont,/* complain_on_overflow */
881 score_elf_got_lo16_reloc, /* special_function */
882 "R_SCORE_GOT_LO16", /* name */
883 TRUE, /* partial_inplace */
884 0x37ffe, /* src_mask */
885 0x37ffe, /* dst_mask */
886 FALSE), /* pcrel_offset */
1c0d3aa6
NC
887
888 /* 15 bit call through global offset table. */
07d6d2b8
AM
889 HOWTO (R_SCORE_CALL15, /* type */
890 0, /* rightshift */
891 2, /* size (0 = byte, 1 = short, 2 = long) */
892 16, /* bitsize */
893 FALSE, /* pc_relative */
894 0, /* bitpos */
895 complain_overflow_signed, /* complain_on_overflow */
896 bfd_elf_generic_reloc, /* special_function */
897 "R_SCORE_CALL15", /* name */
898 TRUE, /* partial_inplace */
899 0x0000ffff, /* src_mask */
900 0x0000ffff, /* dst_mask */
901 FALSE), /* pcrel_offset */
1c0d3aa6
NC
902
903 /* 32 bit GP relative reference. */
07d6d2b8
AM
904 HOWTO (R_SCORE_GPREL32, /* type */
905 0, /* rightshift */
906 2, /* size (0 = byte, 1 = short, 2 = long) */
907 32, /* bitsize */
908 FALSE, /* pc_relative */
909 0, /* bitpos */
910 complain_overflow_dont,/* complain_on_overflow */
911 score_elf_gprel32_reloc, /* special_function */
912 "R_SCORE_GPREL32", /* name */
913 TRUE, /* partial_inplace */
914 0xffffffff, /* src_mask */
915 0xffffffff, /* dst_mask */
916 FALSE), /* pcrel_offset */
1c0d3aa6
NC
917
918 /* 32 bit symbol relative relocation. */
07d6d2b8
AM
919 HOWTO (R_SCORE_REL32, /* type */
920 0, /* rightshift */
921 2, /* size (0 = byte, 1 = short, 2 = long) */
922 32, /* bitsize */
923 FALSE, /* pc_relative */
924 0, /* bitpos */
925 complain_overflow_dont,/* complain_on_overflow */
926 bfd_elf_generic_reloc, /* special_function */
927 "R_SCORE_REL32", /* name */
928 TRUE, /* partial_inplace */
929 0xffffffff, /* src_mask */
930 0xffffffff, /* dst_mask */
931 FALSE), /* pcrel_offset */
1c0d3aa6
NC
932
933 /* R_SCORE_DUMMY_HI16 */
07d6d2b8
AM
934 HOWTO (R_SCORE_DUMMY_HI16, /* type */
935 0, /* rightshift */
936 2, /* size (0 = byte, 1 = short, 2 = long) */
937 16, /* bitsize */
938 FALSE, /* pc_relative */
939 1, /* bitpos */
940 complain_overflow_dont,/* complain_on_overflow */
941 score_elf_hi16_reloc, /* special_function */
942 "R_SCORE_DUMMY_HI16", /* name */
943 TRUE, /* partial_inplace */
944 0x37fff, /* src_mask */
945 0x37fff, /* dst_mask */
946 FALSE), /* pcrel_offset */
c3b7224a
NC
947
948 /* R_SCORE_IMM30 */
07d6d2b8
AM
949 HOWTO (R_SCORE_IMM30, /* type */
950 2, /* rightshift */
951 2, /* size (0 = byte, 1 = short, 2 = long) */
952 30, /* bitsize */
953 FALSE, /* pc_relative */
954 7, /* bitpos */
955 complain_overflow_dont,/* complain_on_overflow */
956 bfd_elf_generic_reloc, /* special_function */
957 "R_SCORE_IMM30", /* name */
958 FALSE, /* partial_inplace */
959 0x7f7fff7f80LL, /* src_mask */
960 0x7f7fff7f80LL, /* dst_mask */
961 FALSE), /* pcrel_offset */
c3b7224a
NC
962
963 /* R_SCORE_IMM32 */
07d6d2b8
AM
964 HOWTO (R_SCORE_IMM32, /* type */
965 0, /* rightshift */
966 2, /* size (0 = byte, 1 = short, 2 = long) */
967 32, /* bitsize */
968 FALSE, /* pc_relative */
969 5, /* bitpos */
970 complain_overflow_dont,/* complain_on_overflow */
971 bfd_elf_generic_reloc, /* special_function */
972 "R_SCORE_IMM32", /* name */
973 FALSE, /* partial_inplace */
974 0x7f7fff7fe0LL, /* src_mask */
975 0x7f7fff7fe0LL, /* dst_mask */
976 FALSE), /* pcrel_offset */
1c0d3aa6
NC
977};
978
979struct score_reloc_map
980{
981 bfd_reloc_code_real_type bfd_reloc_val;
982 unsigned char elf_reloc_val;
983};
984
985static const struct score_reloc_map elf32_score_reloc_map[] =
986{
07d6d2b8
AM
987 {BFD_RELOC_NONE, R_SCORE_NONE},
988 {BFD_RELOC_HI16_S, R_SCORE_HI16},
989 {BFD_RELOC_LO16, R_SCORE_LO16},
990 {BFD_RELOC_SCORE_BCMP, R_SCORE_BCMP},
991 {BFD_RELOC_SCORE_JMP, R_SCORE_24},
992 {BFD_RELOC_SCORE_BRANCH, R_SCORE_PC19},
993 {BFD_RELOC_SCORE16_JMP, R_SCORE16_11},
994 {BFD_RELOC_SCORE16_BRANCH, R_SCORE16_PC8},
995 {BFD_RELOC_32, R_SCORE_ABS32},
996 {BFD_RELOC_16, R_SCORE_ABS16},
997 {BFD_RELOC_SCORE_DUMMY2, R_SCORE_DUMMY2},
998 {BFD_RELOC_SCORE_GPREL15, R_SCORE_GP15},
999 {BFD_RELOC_VTABLE_INHERIT, R_SCORE_GNU_VTINHERIT},
1000 {BFD_RELOC_VTABLE_ENTRY, R_SCORE_GNU_VTENTRY},
1001 {BFD_RELOC_SCORE_GOT15, R_SCORE_GOT15},
1002 {BFD_RELOC_SCORE_GOT_LO16, R_SCORE_GOT_LO16},
1003 {BFD_RELOC_SCORE_CALL15, R_SCORE_CALL15},
1004 {BFD_RELOC_GPREL32, R_SCORE_GPREL32},
1005 {BFD_RELOC_32_PCREL, R_SCORE_REL32},
1006 {BFD_RELOC_SCORE_DUMMY_HI16, R_SCORE_DUMMY_HI16},
1007 {BFD_RELOC_SCORE_IMM30, R_SCORE_IMM30},
1008 {BFD_RELOC_SCORE_IMM32, R_SCORE_IMM32},
1c0d3aa6
NC
1009};
1010
1011/* got_entries only match if they're identical, except for gotidx, so
1012 use all fields to compute the hash, and compare the appropriate
1013 union members. */
1c0d3aa6
NC
1014static hashval_t
1015score_elf_got_entry_hash (const void *entry_)
1016{
1017 const struct score_got_entry *entry = (struct score_got_entry *)entry_;
1018
1019 return entry->symndx
1020 + (!entry->abfd ? entry->d.address : entry->abfd->id);
1021}
1022
1023static int
1024score_elf_got_entry_eq (const void *entry1, const void *entry2)
1025{
1026 const struct score_got_entry *e1 = (struct score_got_entry *)entry1;
1027 const struct score_got_entry *e2 = (struct score_got_entry *)entry2;
1028
1029 return e1->abfd == e2->abfd && e1->symndx == e2->symndx
1030 && (! e1->abfd ? e1->d.address == e2->d.address
07d6d2b8
AM
1031 : e1->symndx >= 0 ? e1->d.addend == e2->d.addend
1032 : e1->d.h == e2->d.h);
1c0d3aa6
NC
1033}
1034
1035/* If H needs a GOT entry, assign it the highest available dynamic
1036 index. Otherwise, assign it the lowest available dynamic
1037 index. */
1c0d3aa6
NC
1038static bfd_boolean
1039score_elf_sort_hash_table_f (struct score_elf_link_hash_entry *h, void *data)
1040{
1041 struct score_elf_hash_sort_data *hsd = data;
1042
1c0d3aa6
NC
1043 /* Symbols without dynamic symbol table entries aren't interesting at all. */
1044 if (h->root.dynindx == -1)
1045 return TRUE;
1046
1047 /* Global symbols that need GOT entries that are not explicitly
1048 referenced are marked with got offset 2. Those that are
1049 referenced get a 1, and those that don't need GOT entries get
1050 -1. */
1051 if (h->root.got.offset == 2)
1052 {
1053 if (hsd->max_unref_got_dynindx == hsd->min_got_dynindx)
07d6d2b8 1054 hsd->low = (struct elf_link_hash_entry *) h;
1c0d3aa6
NC
1055 h->root.dynindx = hsd->max_unref_got_dynindx++;
1056 }
1057 else if (h->root.got.offset != 1)
1058 h->root.dynindx = hsd->max_non_got_dynindx++;
1059 else
1060 {
1061 h->root.dynindx = --hsd->min_got_dynindx;
1062 hsd->low = (struct elf_link_hash_entry *) h;
1063 }
1064
1065 return TRUE;
1066}
1067
1068static asection *
1069score_elf_got_section (bfd *abfd, bfd_boolean maybe_excluded)
1070{
3d4d4302 1071 asection *sgot = bfd_get_linker_section (abfd, ".got");
1c0d3aa6
NC
1072
1073 if (sgot == NULL || (! maybe_excluded && (sgot->flags & SEC_EXCLUDE) != 0))
1074 return NULL;
1075 return sgot;
1076}
1077
1078/* Returns the GOT information associated with the link indicated by
1079 INFO. If SGOTP is non-NULL, it is filled in with the GOT section. */
1c0d3aa6
NC
1080static struct score_got_info *
1081score_elf_got_info (bfd *abfd, asection **sgotp)
1082{
1083 asection *sgot;
1084 struct score_got_info *g;
1085
1086 sgot = score_elf_got_section (abfd, TRUE);
1087 BFD_ASSERT (sgot != NULL);
1088 BFD_ASSERT (elf_section_data (sgot) != NULL);
1089 g = score_elf_section_data (sgot)->u.got_info;
1090 BFD_ASSERT (g != NULL);
1091
1092 if (sgotp)
1093 *sgotp = sgot;
1094 return g;
1095}
1096
1097/* Sort the dynamic symbol table so that symbols that need GOT entries
1098 appear towards the end. This reduces the amount of GOT space
1099 required. MAX_LOCAL is used to set the number of local symbols
1100 known to be in the dynamic symbol table. During
c3b7224a 1101 s3_bfd_score_elf_size_dynamic_sections, this value is 1. Afterward, the
1c0d3aa6 1102 section symbols are added and the count is higher. */
1c0d3aa6
NC
1103static bfd_boolean
1104score_elf_sort_hash_table (struct bfd_link_info *info,
07d6d2b8 1105 unsigned long max_local)
1c0d3aa6
NC
1106{
1107 struct score_elf_hash_sort_data hsd;
1108 struct score_got_info *g;
1109 bfd *dynobj;
1110
1111 dynobj = elf_hash_table (info)->dynobj;
1112
1113 g = score_elf_got_info (dynobj, NULL);
1114
1115 hsd.low = NULL;
1116 hsd.max_unref_got_dynindx =
1117 hsd.min_got_dynindx = elf_hash_table (info)->dynsymcount
1118 /* In the multi-got case, assigned_gotno of the master got_info
1119 indicate the number of entries that aren't referenced in the
1120 primary GOT, but that must have entries because there are
1121 dynamic relocations that reference it. Since they aren't
1122 referenced, we move them to the end of the GOT, so that they
1123 don't prevent other entries that are referenced from getting
1124 too large offsets. */
1125 - (g->next ? g->assigned_gotno : 0);
1126 hsd.max_non_got_dynindx = max_local;
4dfe6ac6
NC
1127 score_elf_link_hash_traverse (elf_hash_table (info),
1128 score_elf_sort_hash_table_f,
1129 &hsd);
1c0d3aa6
NC
1130
1131 /* There should have been enough room in the symbol table to
1132 accommodate both the GOT and non-GOT symbols. */
1133 BFD_ASSERT (hsd.max_non_got_dynindx <= hsd.min_got_dynindx);
1134 BFD_ASSERT ((unsigned long)hsd.max_unref_got_dynindx
07d6d2b8 1135 <= elf_hash_table (info)->dynsymcount);
1c0d3aa6
NC
1136
1137 /* Now we know which dynamic symbol has the lowest dynamic symbol
1138 table index in the GOT. */
1139 g->global_gotsym = hsd.low;
1140
1141 return TRUE;
1142}
1143
1144/* Create an entry in an score ELF linker hash table. */
4dfe6ac6 1145
1c0d3aa6
NC
1146static struct bfd_hash_entry *
1147score_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
07d6d2b8
AM
1148 struct bfd_hash_table *table,
1149 const char *string)
1c0d3aa6 1150{
4dfe6ac6 1151 struct score_elf_link_hash_entry *ret = (struct score_elf_link_hash_entry *) entry;
1c0d3aa6
NC
1152
1153 /* Allocate the structure if it has not already been allocated by a subclass. */
1154 if (ret == NULL)
1155 ret = bfd_hash_allocate (table, sizeof (struct score_elf_link_hash_entry));
1156 if (ret == NULL)
4dfe6ac6 1157 return (struct bfd_hash_entry *) ret;
1c0d3aa6
NC
1158
1159 /* Call the allocation method of the superclass. */
1160 ret = ((struct score_elf_link_hash_entry *)
07d6d2b8 1161 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
1c0d3aa6
NC
1162
1163 if (ret != NULL)
1164 {
1165 ret->possibly_dynamic_relocs = 0;
1166 ret->readonly_reloc = FALSE;
1167 ret->no_fn_stub = FALSE;
1168 ret->forced_local = FALSE;
1169 }
1170
4dfe6ac6 1171 return (struct bfd_hash_entry *) ret;
1c0d3aa6
NC
1172}
1173
1174/* Returns the first relocation of type r_type found, beginning with
1175 RELOCATION. RELEND is one-past-the-end of the relocation table. */
1c0d3aa6
NC
1176static const Elf_Internal_Rela *
1177score_elf_next_relocation (bfd *abfd ATTRIBUTE_UNUSED, unsigned int r_type,
07d6d2b8
AM
1178 const Elf_Internal_Rela *relocation,
1179 const Elf_Internal_Rela *relend)
1c0d3aa6
NC
1180{
1181 while (relocation < relend)
1182 {
1183 if (ELF32_R_TYPE (relocation->r_info) == r_type)
07d6d2b8 1184 return relocation;
1c0d3aa6
NC
1185
1186 ++relocation;
1187 }
1188
1189 /* We didn't find it. */
1190 bfd_set_error (bfd_error_bad_value);
1191 return NULL;
1192}
1193
1194/* This function is called via qsort() to sort the dynamic relocation
1195 entries by increasing r_symndx value. */
1c0d3aa6
NC
1196static int
1197score_elf_sort_dynamic_relocs (const void *arg1, const void *arg2)
1198{
1199 Elf_Internal_Rela int_reloc1;
1200 Elf_Internal_Rela int_reloc2;
1201
1202 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd, arg1, &int_reloc1);
1203 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd, arg2, &int_reloc2);
1204
1205 return (ELF32_R_SYM (int_reloc1.r_info) - ELF32_R_SYM (int_reloc2.r_info));
1206}
1207
1208/* Return whether a relocation is against a local symbol. */
1c0d3aa6
NC
1209static bfd_boolean
1210score_elf_local_relocation_p (bfd *input_bfd,
07d6d2b8
AM
1211 const Elf_Internal_Rela *relocation,
1212 asection **local_sections,
1213 bfd_boolean check_forced)
1c0d3aa6
NC
1214{
1215 unsigned long r_symndx;
1216 Elf_Internal_Shdr *symtab_hdr;
1217 struct score_elf_link_hash_entry *h;
1218 size_t extsymoff;
1219
1220 r_symndx = ELF32_R_SYM (relocation->r_info);
1221 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
c3b7224a 1222 extsymoff = (elf_bad_symtab (input_bfd)) ? 0 : symtab_hdr->sh_info;
1c0d3aa6
NC
1223
1224 if (r_symndx < extsymoff)
1225 return TRUE;
c3b7224a
NC
1226 if (elf_bad_symtab (input_bfd) && local_sections[r_symndx] != NULL)
1227 return TRUE;
1c0d3aa6
NC
1228
1229 if (check_forced)
1230 {
1231 /* Look up the hash table to check whether the symbol was forced local. */
1232 h = (struct score_elf_link_hash_entry *)
07d6d2b8 1233 elf_sym_hashes (input_bfd) [r_symndx - extsymoff];
1c0d3aa6
NC
1234 /* Find the real hash-table entry for this symbol. */
1235 while (h->root.root.type == bfd_link_hash_indirect
07d6d2b8
AM
1236 || h->root.root.type == bfd_link_hash_warning)
1237 h = (struct score_elf_link_hash_entry *) h->root.root.u.i.link;
1c0d3aa6 1238 if (h->root.forced_local)
07d6d2b8 1239 return TRUE;
1c0d3aa6
NC
1240 }
1241
1242 return FALSE;
1243}
1244
1245/* Returns the dynamic relocation section for DYNOBJ. */
1c0d3aa6
NC
1246static asection *
1247score_elf_rel_dyn_section (bfd *dynobj, bfd_boolean create_p)
1248{
1249 static const char dname[] = ".rel.dyn";
1250 asection *sreloc;
1251
3d4d4302 1252 sreloc = bfd_get_linker_section (dynobj, dname);
1c0d3aa6
NC
1253 if (sreloc == NULL && create_p)
1254 {
3d4d4302
AM
1255 sreloc = bfd_make_section_anyway_with_flags (dynobj, dname,
1256 (SEC_ALLOC
1257 | SEC_LOAD
1258 | SEC_HAS_CONTENTS
1259 | SEC_IN_MEMORY
1260 | SEC_LINKER_CREATED
1261 | SEC_READONLY));
1c0d3aa6 1262 if (sreloc == NULL
fd361982
AM
1263 || !bfd_set_section_alignment (sreloc,
1264 SCORE_ELF_LOG_FILE_ALIGN (dynobj)))
07d6d2b8 1265 return NULL;
1c0d3aa6 1266 }
c3b7224a 1267 return sreloc;
1c0d3aa6
NC
1268}
1269
1270static void
1271score_elf_allocate_dynamic_relocations (bfd *abfd, unsigned int n)
1272{
1273 asection *s;
1274
1275 s = score_elf_rel_dyn_section (abfd, FALSE);
1276 BFD_ASSERT (s != NULL);
1277
1278 if (s->size == 0)
1279 {
1280 /* Make room for a null element. */
1281 s->size += SCORE_ELF_REL_SIZE (abfd);
1282 ++s->reloc_count;
1283 }
1284 s->size += n * SCORE_ELF_REL_SIZE (abfd);
1285}
1286
1287/* Create a rel.dyn relocation for the dynamic linker to resolve. REL
1288 is the original relocation, which is now being transformed into a
1289 dynamic relocation. The ADDENDP is adjusted if necessary; the
1290 caller should store the result in place of the original addend. */
1c0d3aa6
NC
1291static bfd_boolean
1292score_elf_create_dynamic_relocation (bfd *output_bfd,
07d6d2b8
AM
1293 struct bfd_link_info *info,
1294 const Elf_Internal_Rela *rel,
1295 struct score_elf_link_hash_entry *h,
1296 bfd_vma symbol,
1297 bfd_vma *addendp, asection *input_section)
1c0d3aa6
NC
1298{
1299 Elf_Internal_Rela outrel[3];
1300 asection *sreloc;
1301 bfd *dynobj;
1302 int r_type;
1303 long indx;
1304 bfd_boolean defined_p;
1305
1306 r_type = ELF32_R_TYPE (rel->r_info);
1307 dynobj = elf_hash_table (info)->dynobj;
1308 sreloc = score_elf_rel_dyn_section (dynobj, FALSE);
1309 BFD_ASSERT (sreloc != NULL);
1310 BFD_ASSERT (sreloc->contents != NULL);
1311 BFD_ASSERT (sreloc->reloc_count * SCORE_ELF_REL_SIZE (output_bfd) < sreloc->size);
1312
1313 outrel[0].r_offset =
1314 _bfd_elf_section_offset (output_bfd, info, input_section, rel[0].r_offset);
1315 outrel[1].r_offset =
1316 _bfd_elf_section_offset (output_bfd, info, input_section, rel[1].r_offset);
1317 outrel[2].r_offset =
1318 _bfd_elf_section_offset (output_bfd, info, input_section, rel[2].r_offset);
1319
1320 if (outrel[0].r_offset == MINUS_ONE)
1321 /* The relocation field has been deleted. */
1322 return TRUE;
1323
1324 if (outrel[0].r_offset == MINUS_TWO)
1325 {
1326 /* The relocation field has been converted into a relative value of
07d6d2b8
AM
1327 some sort. Functions like _bfd_elf_write_section_eh_frame expect
1328 the field to be fully relocated, so add in the symbol's value. */
1c0d3aa6
NC
1329 *addendp += symbol;
1330 return TRUE;
1331 }
1332
1333 /* We must now calculate the dynamic symbol table index to use
1334 in the relocation. */
1335 if (h != NULL
1336 && (! info->symbolic || !h->root.def_regular)
1337 /* h->root.dynindx may be -1 if this symbol was marked to
07d6d2b8 1338 become local. */
1c0d3aa6
NC
1339 && h->root.dynindx != -1)
1340 {
1341 indx = h->root.dynindx;
07d6d2b8
AM
1342 /* ??? glibc's ld.so just adds the final GOT entry to the
1343 relocation field. It therefore treats relocs against
1344 defined symbols in the same way as relocs against
1345 undefined symbols. */
1c0d3aa6
NC
1346 defined_p = FALSE;
1347 }
1348 else
1349 {
9838404f 1350 indx = 0;
1c0d3aa6
NC
1351 defined_p = TRUE;
1352 }
1353
1354 /* If the relocation was previously an absolute relocation and
1355 this symbol will not be referred to by the relocation, we must
1356 adjust it by the value we give it in the dynamic symbol table.
1357 Otherwise leave the job up to the dynamic linker. */
1358 if (defined_p && r_type != R_SCORE_REL32)
1359 *addendp += symbol;
1360
1361 /* The relocation is always an REL32 relocation because we don't
1362 know where the shared library will wind up at load-time. */
1363 outrel[0].r_info = ELF32_R_INFO ((unsigned long) indx, R_SCORE_REL32);
1364
1365 /* For strict adherence to the ABI specification, we should
1366 generate a R_SCORE_64 relocation record by itself before the
1367 _REL32/_64 record as well, such that the addend is read in as
1368 a 64-bit value (REL32 is a 32-bit relocation, after all).
1369 However, since none of the existing ELF64 SCORE dynamic
1370 loaders seems to care, we don't waste space with these
1371 artificial relocations. If this turns out to not be true,
1372 score_elf_allocate_dynamic_relocations() should be tweaked so
1373 as to make room for a pair of dynamic relocations per
1374 invocation if ABI_64_P, and here we should generate an
1375 additional relocation record with R_SCORE_64 by itself for a
1376 NULL symbol before this relocation record. */
1377 outrel[1].r_info = ELF32_R_INFO (0, R_SCORE_NONE);
1378 outrel[2].r_info = ELF32_R_INFO (0, R_SCORE_NONE);
1379
1380 /* Adjust the output offset of the relocation to reference the
1381 correct location in the output file. */
1382 outrel[0].r_offset += (input_section->output_section->vma
07d6d2b8 1383 + input_section->output_offset);
1c0d3aa6 1384 outrel[1].r_offset += (input_section->output_section->vma
07d6d2b8 1385 + input_section->output_offset);
1c0d3aa6 1386 outrel[2].r_offset += (input_section->output_section->vma
07d6d2b8 1387 + input_section->output_offset);
1c0d3aa6
NC
1388
1389 /* Put the relocation back out. We have to use the special
1390 relocation outputter in the 64-bit case since the 64-bit
1391 relocation format is non-standard. */
1392 bfd_elf32_swap_reloc_out
1393 (output_bfd, &outrel[0],
1394 (sreloc->contents + sreloc->reloc_count * sizeof (Elf32_External_Rel)));
1395
1396 /* We've now added another relocation. */
1397 ++sreloc->reloc_count;
1398
1399 /* Make sure the output section is writable. The dynamic linker
1400 will be writing to it. */
1401 elf_section_data (input_section->output_section)->this_hdr.sh_flags |= SHF_WRITE;
1402
1403 return TRUE;
1404}
1405
1406static bfd_boolean
1407score_elf_create_got_section (bfd *abfd,
07d6d2b8
AM
1408 struct bfd_link_info *info,
1409 bfd_boolean maybe_exclude)
1c0d3aa6
NC
1410{
1411 flagword flags;
1412 asection *s;
1413 struct elf_link_hash_entry *h;
1414 struct bfd_link_hash_entry *bh;
1415 struct score_got_info *g;
986f0783 1416 size_t amt;
1c0d3aa6
NC
1417
1418 /* This function may be called more than once. */
1419 s = score_elf_got_section (abfd, TRUE);
1420 if (s)
1421 {
1422 if (! maybe_exclude)
07d6d2b8 1423 s->flags &= ~SEC_EXCLUDE;
1c0d3aa6
NC
1424 return TRUE;
1425 }
1426
1427 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
1428
1429 if (maybe_exclude)
1430 flags |= SEC_EXCLUDE;
1431
1432 /* We have to use an alignment of 2**4 here because this is hardcoded
1433 in the function stub generation and in the linker script. */
3d4d4302 1434 s = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
ce558b89
AM
1435 elf_hash_table (info)->sgot = s;
1436 if (s == NULL
fd361982 1437 || !bfd_set_section_alignment (s, 4))
1c0d3aa6
NC
1438 return FALSE;
1439
1440 /* Define the symbol _GLOBAL_OFFSET_TABLE_. We don't do this in the
1441 linker script because we don't want to define the symbol if we
1442 are not creating a global offset table. */
1443 bh = NULL;
1444 if (! (_bfd_generic_link_add_one_symbol
07d6d2b8
AM
1445 (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL, s,
1446 0, NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
1c0d3aa6
NC
1447 return FALSE;
1448
1449 h = (struct elf_link_hash_entry *) bh;
1450 h->non_elf = 0;
1451 h->def_regular = 1;
1452 h->type = STT_OBJECT;
ce558b89 1453 elf_hash_table (info)->hgot = h;
1c0d3aa6 1454
0e1862bb 1455 if (bfd_link_pic (info) && ! bfd_elf_link_record_dynamic_symbol (info, h))
1c0d3aa6
NC
1456 return FALSE;
1457
1458 amt = sizeof (struct score_got_info);
1459 g = bfd_alloc (abfd, amt);
1460 if (g == NULL)
1461 return FALSE;
1462
1463 g->global_gotsym = NULL;
1464 g->global_gotno = 0;
1465
1466 g->local_gotno = SCORE_RESERVED_GOTNO;
1467 g->assigned_gotno = SCORE_RESERVED_GOTNO;
1468 g->next = NULL;
1469
1470 g->got_entries = htab_try_create (1, score_elf_got_entry_hash,
07d6d2b8 1471 score_elf_got_entry_eq, NULL);
1c0d3aa6
NC
1472 if (g->got_entries == NULL)
1473 return FALSE;
1474 score_elf_section_data (s)->u.got_info = g;
1475 score_elf_section_data (s)->elf.this_hdr.sh_flags |= SHF_ALLOC | SHF_WRITE | SHF_SCORE_GPREL;
1476
1477 return TRUE;
1478}
1479
1480/* Calculate the %high function. */
1c0d3aa6
NC
1481static bfd_vma
1482score_elf_high (bfd_vma value)
1483{
1484 return ((value + (bfd_vma) 0x8000) >> 16) & 0xffff;
1485}
1486
1487/* Create a local GOT entry for VALUE. Return the index of the entry,
1488 or -1 if it could not be created. */
1c0d3aa6
NC
1489static struct score_got_entry *
1490score_elf_create_local_got_entry (bfd *abfd,
07d6d2b8
AM
1491 bfd *ibfd ATTRIBUTE_UNUSED,
1492 struct score_got_info *gg,
1493 asection *sgot, bfd_vma value,
1494 unsigned long r_symndx ATTRIBUTE_UNUSED,
1495 struct score_elf_link_hash_entry *h ATTRIBUTE_UNUSED,
1496 int r_type ATTRIBUTE_UNUSED)
1c0d3aa6
NC
1497{
1498 struct score_got_entry entry, **loc;
1499 struct score_got_info *g;
1500
1501 entry.abfd = NULL;
1502 entry.symndx = -1;
1503 entry.d.address = value;
1504
1505 g = gg;
1506 loc = (struct score_got_entry **) htab_find_slot (g->got_entries, &entry, INSERT);
1507 if (*loc)
1508 return *loc;
1509
1510 entry.gotidx = SCORE_ELF_GOT_SIZE (abfd) * g->assigned_gotno++;
1511
1512 *loc = bfd_alloc (abfd, sizeof entry);
1513
1514 if (! *loc)
1515 return NULL;
1516
1517 memcpy (*loc, &entry, sizeof entry);
1518
1519 if (g->assigned_gotno >= g->local_gotno)
1520 {
1521 (*loc)->gotidx = -1;
1522 /* We didn't allocate enough space in the GOT. */
4eca0228 1523 _bfd_error_handler
07d6d2b8 1524 (_("not enough GOT space for local GOT entries"));
1c0d3aa6
NC
1525 bfd_set_error (bfd_error_bad_value);
1526 return NULL;
1527 }
1528
c3b7224a 1529 score_bfd_put_32 (abfd, value, (sgot->contents + entry.gotidx));
1c0d3aa6
NC
1530
1531 return *loc;
1532}
1533
1534/* Find a GOT entry whose higher-order 16 bits are the same as those
1535 for value. Return the index into the GOT for this entry. */
1c0d3aa6
NC
1536static bfd_vma
1537score_elf_got16_entry (bfd *abfd, bfd *ibfd, struct bfd_link_info *info,
07d6d2b8 1538 bfd_vma value, bfd_boolean external)
1c0d3aa6
NC
1539{
1540 asection *sgot;
1541 struct score_got_info *g;
1542 struct score_got_entry *entry;
1543
1544 if (!external)
1545 {
1546 /* Although the ABI says that it is "the high-order 16 bits" that we
07d6d2b8
AM
1547 want, it is really the %high value. The complete value is
1548 calculated with a `addiu' of a LO16 relocation, just as with a
1549 HI16/LO16 pair. */
1c0d3aa6
NC
1550 value = score_elf_high (value) << 16;
1551 }
1552
1553 g = score_elf_got_info (elf_hash_table (info)->dynobj, &sgot);
1554
1555 entry = score_elf_create_local_got_entry (abfd, ibfd, g, sgot, value, 0, NULL,
07d6d2b8 1556 R_SCORE_GOT15);
1c0d3aa6
NC
1557 if (entry)
1558 return entry->gotidx;
1559 else
1560 return MINUS_ONE;
1561}
1562
1563static void
c3b7224a 1564s3_bfd_score_elf_hide_symbol (struct bfd_link_info *info,
07d6d2b8
AM
1565 struct elf_link_hash_entry *entry,
1566 bfd_boolean force_local)
1c0d3aa6
NC
1567{
1568 bfd *dynobj;
1569 asection *got;
1570 struct score_got_info *g;
1571 struct score_elf_link_hash_entry *h;
1572
1573 h = (struct score_elf_link_hash_entry *) entry;
1574 if (h->forced_local)
1575 return;
1576 h->forced_local = TRUE;
1577
1578 dynobj = elf_hash_table (info)->dynobj;
1579 if (dynobj != NULL && force_local)
1580 {
1581 got = score_elf_got_section (dynobj, FALSE);
1582 if (got == NULL)
07d6d2b8 1583 return;
1c0d3aa6
NC
1584 g = score_elf_section_data (got)->u.got_info;
1585
1586 if (g->next)
07d6d2b8
AM
1587 {
1588 struct score_got_entry e;
1589 struct score_got_info *gg = g;
1590
1591 /* Since we're turning what used to be a global symbol into a
1592 local one, bump up the number of local entries of each GOT
1593 that had an entry for it. This will automatically decrease
1594 the number of global entries, since global_gotno is actually
1595 the upper limit of global entries. */
1596 e.abfd = dynobj;
1597 e.symndx = -1;
1598 e.d.h = h;
1599
1600 for (g = g->next; g != gg; g = g->next)
1601 if (htab_find (g->got_entries, &e))
1602 {
1603 BFD_ASSERT (g->global_gotno > 0);
1604 g->local_gotno++;
1605 g->global_gotno--;
1606 }
1607
1608 /* If this was a global symbol forced into the primary GOT, we
1609 no longer need an entry for it. We can't release the entry
1610 at this point, but we must at least stop counting it as one
1611 of the symbols that required a forced got entry. */
1612 if (h->root.got.offset == 2)
1613 {
1614 BFD_ASSERT (gg->assigned_gotno > 0);
1615 gg->assigned_gotno--;
1616 }
1617 }
1c0d3aa6 1618 else if (g->global_gotno == 0 && g->global_gotsym == NULL)
07d6d2b8
AM
1619 /* If we haven't got through GOT allocation yet, just bump up the
1620 number of local entries, as this symbol won't be counted as
1621 global. */
1622 g->local_gotno++;
1c0d3aa6 1623 else if (h->root.got.offset == 1)
07d6d2b8
AM
1624 {
1625 /* If we're past non-multi-GOT allocation and this symbol had
1626 been marked for a global got entry, give it a local entry
1627 instead. */
1628 BFD_ASSERT (g->global_gotno > 0);
1629 g->local_gotno++;
1630 g->global_gotno--;
1631 }
1c0d3aa6
NC
1632 }
1633
1634 _bfd_elf_link_hash_hide_symbol (info, &h->root, force_local);
1635}
1636
1637/* If H is a symbol that needs a global GOT entry, but has a dynamic
1638 symbol table index lower than any we've seen to date, record it for
1639 posterity. */
1c0d3aa6
NC
1640static bfd_boolean
1641score_elf_record_global_got_symbol (struct elf_link_hash_entry *h,
07d6d2b8
AM
1642 bfd *abfd,
1643 struct bfd_link_info *info,
1644 struct score_got_info *g)
1c0d3aa6
NC
1645{
1646 struct score_got_entry entry, **loc;
1647
1648 /* A global symbol in the GOT must also be in the dynamic symbol table. */
1649 if (h->dynindx == -1)
1650 {
1651 switch (ELF_ST_VISIBILITY (h->other))
07d6d2b8
AM
1652 {
1653 case STV_INTERNAL:
1654 case STV_HIDDEN:
1655 s3_bfd_score_elf_hide_symbol (info, h, TRUE);
1656 break;
1657 }
1c0d3aa6 1658 if (!bfd_elf_link_record_dynamic_symbol (info, h))
07d6d2b8 1659 return FALSE;
1c0d3aa6
NC
1660 }
1661
1662 entry.abfd = abfd;
1663 entry.symndx = -1;
1664 entry.d.h = (struct score_elf_link_hash_entry *)h;
1665
1666 loc = (struct score_got_entry **)htab_find_slot (g->got_entries, &entry, INSERT);
1667
1668 /* If we've already marked this entry as needing GOT space, we don't
1669 need to do it again. */
1670 if (*loc)
1671 return TRUE;
1672
1673 *loc = bfd_alloc (abfd, sizeof entry);
1674 if (! *loc)
1675 return FALSE;
1676
1677 entry.gotidx = -1;
1678
1679 memcpy (*loc, &entry, sizeof (entry));
1680
1681 if (h->got.offset != MINUS_ONE)
1682 return TRUE;
1683
1684 /* By setting this to a value other than -1, we are indicating that
1685 there needs to be a GOT entry for H. Avoid using zero, as the
1686 generic ELF copy_indirect_symbol tests for <= 0. */
1687 h->got.offset = 1;
1688
1689 return TRUE;
1690}
1691
1692/* Reserve space in G for a GOT entry containing the value of symbol
1693 SYMNDX in input bfd ABDF, plus ADDEND. */
1c0d3aa6
NC
1694static bfd_boolean
1695score_elf_record_local_got_symbol (bfd *abfd,
07d6d2b8
AM
1696 long symndx,
1697 bfd_vma addend,
1698 struct score_got_info *g)
1c0d3aa6
NC
1699{
1700 struct score_got_entry entry, **loc;
1701
1702 entry.abfd = abfd;
1703 entry.symndx = symndx;
1704 entry.d.addend = addend;
1705 loc = (struct score_got_entry **)htab_find_slot (g->got_entries, &entry, INSERT);
1706
1707 if (*loc)
1708 return TRUE;
1709
1710 entry.gotidx = g->local_gotno++;
1711
1712 *loc = bfd_alloc (abfd, sizeof(entry));
1713 if (! *loc)
1714 return FALSE;
1715
1716 memcpy (*loc, &entry, sizeof (entry));
1717
1718 return TRUE;
1719}
1720
1721/* Returns the GOT offset at which the indicated address can be found.
1722 If there is not yet a GOT entry for this value, create one.
1723 Returns -1 if no satisfactory GOT offset can be found. */
1c0d3aa6
NC
1724static bfd_vma
1725score_elf_local_got_index (bfd *abfd, bfd *ibfd, struct bfd_link_info *info,
07d6d2b8
AM
1726 bfd_vma value, unsigned long r_symndx,
1727 struct score_elf_link_hash_entry *h, int r_type)
1c0d3aa6
NC
1728{
1729 asection *sgot;
1730 struct score_got_info *g;
1731 struct score_got_entry *entry;
1732
1733 g = score_elf_got_info (elf_hash_table (info)->dynobj, &sgot);
1734
1735 entry = score_elf_create_local_got_entry (abfd, ibfd, g, sgot, value,
07d6d2b8 1736 r_symndx, h, r_type);
1c0d3aa6
NC
1737 if (!entry)
1738 return MINUS_ONE;
1739
1740 else
1741 return entry->gotidx;
1742}
1743
1744/* Returns the GOT index for the global symbol indicated by H. */
1745
1746static bfd_vma
1747score_elf_global_got_index (bfd *abfd, struct elf_link_hash_entry *h)
1748{
91d6fa6a 1749 bfd_vma got_index;
1c0d3aa6
NC
1750 asection *sgot;
1751 struct score_got_info *g;
1752 long global_got_dynindx = 0;
1753
1754 g = score_elf_got_info (abfd, &sgot);
1755 if (g->global_gotsym != NULL)
1756 global_got_dynindx = g->global_gotsym->dynindx;
1757
1758 /* Once we determine the global GOT entry with the lowest dynamic
1759 symbol table index, we must put all dynamic symbols with greater
1760 indices into the GOT. That makes it easy to calculate the GOT
1761 offset. */
1762 BFD_ASSERT (h->dynindx >= global_got_dynindx);
91d6fa6a
NC
1763 got_index = ((h->dynindx - global_got_dynindx + g->local_gotno) * SCORE_ELF_GOT_SIZE (abfd));
1764 BFD_ASSERT (got_index < sgot->size);
1c0d3aa6 1765
91d6fa6a 1766 return got_index;
1c0d3aa6
NC
1767}
1768
1769/* Returns the offset for the entry at the INDEXth position in the GOT. */
91d6fa6a 1770
1c0d3aa6 1771static bfd_vma
91d6fa6a
NC
1772score_elf_got_offset_from_index (bfd *dynobj,
1773 bfd *output_bfd,
07d6d2b8 1774 bfd *input_bfd ATTRIBUTE_UNUSED,
91d6fa6a 1775 bfd_vma got_index)
1c0d3aa6
NC
1776{
1777 asection *sgot;
1778 bfd_vma gp;
1c0d3aa6 1779
c7e2358a 1780 score_elf_got_info (dynobj, &sgot);
1c0d3aa6
NC
1781 gp = _bfd_get_gp_value (output_bfd);
1782
91d6fa6a 1783 return sgot->output_section->vma + sgot->output_offset + got_index - gp;
1c0d3aa6
NC
1784}
1785
1786/* Follow indirect and warning hash entries so that each got entry
1787 points to the final symbol definition. P must point to a pointer
1788 to the hash table we're traversing. Since this traversal may
1789 modify the hash table, we set this pointer to NULL to indicate
1790 we've made a potentially-destructive change to the hash table, so
1791 the traversal must be restarted. */
1792static int
1793score_elf_resolve_final_got_entry (void **entryp, void *p)
1794{
1795 struct score_got_entry *entry = (struct score_got_entry *)*entryp;
1796 htab_t got_entries = *(htab_t *)p;
1797
1798 if (entry->abfd != NULL && entry->symndx == -1)
1799 {
1800 struct score_elf_link_hash_entry *h = entry->d.h;
1801
1802 while (h->root.root.type == bfd_link_hash_indirect
07d6d2b8
AM
1803 || h->root.root.type == bfd_link_hash_warning)
1804 h = (struct score_elf_link_hash_entry *) h->root.root.u.i.link;
1c0d3aa6
NC
1805
1806 if (entry->d.h == h)
07d6d2b8 1807 return 1;
1c0d3aa6
NC
1808
1809 entry->d.h = h;
1810
1811 /* If we can't find this entry with the new bfd hash, re-insert
07d6d2b8 1812 it, and get the traversal restarted. */
1c0d3aa6 1813 if (! htab_find (got_entries, entry))
07d6d2b8
AM
1814 {
1815 htab_clear_slot (got_entries, entryp);
1816 entryp = htab_find_slot (got_entries, entry, INSERT);
1817 if (! *entryp)
1818 *entryp = entry;
1819 /* Abort the traversal, since the whole table may have
1820 moved, and leave it up to the parent to restart the
1821 process. */
1822 *(htab_t *)p = NULL;
1823 return 0;
1824 }
1c0d3aa6 1825 /* We might want to decrement the global_gotno count, but it's
07d6d2b8 1826 either too early or too late for that at this point. */
1c0d3aa6
NC
1827 }
1828
1829 return 1;
1830}
1831
1832/* Turn indirect got entries in a got_entries table into their final locations. */
1833static void
1834score_elf_resolve_final_got_entries (struct score_got_info *g)
1835{
1836 htab_t got_entries;
1837
1838 do
1839 {
1840 got_entries = g->got_entries;
1841
1842 htab_traverse (got_entries,
07d6d2b8
AM
1843 score_elf_resolve_final_got_entry,
1844 &got_entries);
1c0d3aa6
NC
1845 }
1846 while (got_entries == NULL);
1847}
1848
1849/* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS. for -r */
1c0d3aa6
NC
1850static void
1851score_elf_add_to_rel (bfd *abfd,
07d6d2b8
AM
1852 bfd_byte *address,
1853 reloc_howto_type *howto,
1854 bfd_signed_vma increment)
1c0d3aa6
NC
1855{
1856 bfd_signed_vma addend;
1857 bfd_vma contents;
1858 unsigned long offset;
1859 unsigned long r_type = howto->type;
1860 unsigned long hi16_addend, hi16_offset, hi16_value, uvalue;
1861
c3b7224a 1862 contents = score_bfd_get_32 (abfd, address);
1c0d3aa6
NC
1863 /* Get the (signed) value from the instruction. */
1864 addend = contents & howto->src_mask;
1865 if (addend & ((howto->src_mask + 1) >> 1))
1866 {
1867 bfd_signed_vma mask;
1868
1869 mask = -1;
1870 mask &= ~howto->src_mask;
1871 addend |= mask;
1872 }
1873 /* Add in the increment, (which is a byte value). */
1874 switch (r_type)
1875 {
1876 case R_SCORE_PC19:
1877 offset =
07d6d2b8 1878 (((contents & howto->src_mask) & 0x3ff0000) >> 6) | ((contents & howto->src_mask) & 0x3ff);
1c0d3aa6
NC
1879 offset += increment;
1880 contents =
07d6d2b8
AM
1881 (contents & ~howto->
1882 src_mask) | (((offset << 6) & howto->src_mask) & 0x3ff0000) | (offset & 0x3ff);
c3b7224a 1883 score_bfd_put_32 (abfd, contents, address);
1c0d3aa6
NC
1884 break;
1885 case R_SCORE_HI16:
1886 break;
1887 case R_SCORE_LO16:
c3b7224a 1888 hi16_addend = score_bfd_get_32 (abfd, address - 4);
1c0d3aa6
NC
1889 hi16_offset = ((((hi16_addend >> 16) & 0x3) << 15) | (hi16_addend & 0x7fff)) >> 1;
1890 offset = ((((contents >> 16) & 0x3) << 15) | (contents & 0x7fff)) >> 1;
1891 offset = (hi16_offset << 16) | (offset & 0xffff);
1892 uvalue = increment + offset;
1893 hi16_offset = (uvalue >> 16) << 1;
1894 hi16_value = (hi16_addend & (~(howto->dst_mask)))
07d6d2b8 1895 | (hi16_offset & 0x7fff) | ((hi16_offset << 1) & 0x30000);
c3b7224a 1896 score_bfd_put_32 (abfd, hi16_value, address - 4);
1c0d3aa6
NC
1897 offset = (uvalue & 0xffff) << 1;
1898 contents = (contents & (~(howto->dst_mask))) | (offset & 0x7fff) | ((offset << 1) & 0x30000);
c3b7224a 1899 score_bfd_put_32 (abfd, contents, address);
1c0d3aa6
NC
1900 break;
1901 case R_SCORE_24:
1902 offset =
07d6d2b8 1903 (((contents & howto->src_mask) >> 1) & 0x1ff8000) | ((contents & howto->src_mask) & 0x7fff);
1c0d3aa6
NC
1904 offset += increment;
1905 contents =
07d6d2b8
AM
1906 (contents & ~howto->
1907 src_mask) | (((offset << 1) & howto->src_mask) & 0x3ff0000) | (offset & 0x7fff);
c3b7224a 1908 score_bfd_put_32 (abfd, contents, address);
1c0d3aa6 1909 break;
c3b7224a 1910
1c0d3aa6
NC
1911 case R_SCORE16_11:
1912
c3b7224a 1913 contents = score_bfd_get_16 (abfd, address);
1c0d3aa6
NC
1914 offset = contents & howto->src_mask;
1915 offset += increment;
1916 contents = (contents & ~howto->src_mask) | (offset & howto->src_mask);
c3b7224a 1917 score_bfd_put_16 (abfd, contents, address);
1c0d3aa6
NC
1918
1919 break;
1920 case R_SCORE16_PC8:
1921
c3b7224a
NC
1922 contents = score_bfd_get_16 (abfd, address);
1923 offset = (contents & howto->src_mask) + ((increment >> 1) & 0x1ff);
1924 contents = (contents & (~howto->src_mask)) | (offset & howto->src_mask);
1925 score_bfd_put_16 (abfd, contents, address);
1926
1927 break;
1928
1929 case R_SCORE_BCMP:
1930 contents = score_bfd_get_32 (abfd, address);
1931 offset = (contents & howto->src_mask);
1932 offset <<= howto->rightshift;
1933 offset += increment;
1934 offset >>= howto->rightshift;
1935 contents = (contents & (~howto->src_mask)) | (offset & howto->src_mask);
1936 score_bfd_put_32 (abfd, contents, address);
1937 break;
1938
1939 case R_SCORE_IMM30:
1940 contents = score_bfd_get_48 (abfd, address);
1941 offset = (contents & howto->src_mask);
1942 offset <<= howto->rightshift;
1943 offset += increment;
1944 offset >>= howto->rightshift;
1c0d3aa6 1945 contents = (contents & (~howto->src_mask)) | (offset & howto->src_mask);
c3b7224a
NC
1946 score_bfd_put_48 (abfd, contents, address);
1947 break;
1c0d3aa6 1948
c3b7224a
NC
1949 case R_SCORE_IMM32:
1950 contents = score_bfd_get_48 (abfd, address);
1951 offset = (contents & howto->src_mask);
1952 offset += increment;
1953 contents = (contents & (~howto->src_mask)) | (offset & howto->src_mask);
1954 score_bfd_put_48 (abfd, contents, address);
1c0d3aa6 1955 break;
c3b7224a 1956
1c0d3aa6
NC
1957 default:
1958 addend += increment;
1959 contents = (contents & ~howto->dst_mask) | (addend & howto->dst_mask);
c3b7224a 1960 score_bfd_put_32 (abfd, contents, address);
1c0d3aa6
NC
1961 break;
1962 }
1963}
1964
1965/* Perform a relocation as part of a final link. */
1c0d3aa6
NC
1966static bfd_reloc_status_type
1967score_elf_final_link_relocate (reloc_howto_type *howto,
07d6d2b8
AM
1968 bfd *input_bfd,
1969 bfd *output_bfd,
1970 asection *input_section,
1971 bfd_byte *contents,
1972 Elf_Internal_Rela *rel,
1973 Elf_Internal_Rela *relocs,
1974 bfd_vma symbol,
1975 struct bfd_link_info *info,
1976 const char *sym_name ATTRIBUTE_UNUSED,
1977 int sym_flags ATTRIBUTE_UNUSED,
1978 struct score_elf_link_hash_entry *h,
1979 asection **local_sections,
1980 bfd_boolean gp_disp_p)
1c0d3aa6
NC
1981{
1982 unsigned long r_type;
1983 unsigned long r_symndx;
1984 bfd_byte *hit_data = contents + rel->r_offset;
1985 bfd_vma addend;
1986 /* The final GP value to be used for the relocatable, executable, or
1987 shared object file being produced. */
1988 bfd_vma gp = MINUS_ONE;
1989 /* The place (section offset or address) of the storage unit being relocated. */
1990 bfd_vma rel_addr;
1c0d3aa6
NC
1991 /* The offset into the global offset table at which the address of the relocation entry
1992 symbol, adjusted by the addend, resides during execution. */
1993 bfd_vma g = MINUS_ONE;
1994 /* TRUE if the symbol referred to by this relocation is a local symbol. */
1995 bfd_boolean local_p;
1996 /* The eventual value we will relocate. */
1997 bfd_vma value = symbol;
1998 unsigned long hi16_addend, hi16_offset, hi16_value, uvalue, offset, abs_value = 0;
1999
c3b7224a 2000
1c0d3aa6
NC
2001 if (elf_gp (output_bfd) == 0)
2002 {
2003 struct bfd_link_hash_entry *bh;
2004 asection *o;
2005
2006 bh = bfd_link_hash_lookup (info->hash, "_gp", 0, 0, 1);
c3b7224a 2007 if (bh != NULL && bh->type == bfd_link_hash_defined)
07d6d2b8
AM
2008 elf_gp (output_bfd) = (bh->u.def.value
2009 + bh->u.def.section->output_section->vma
2010 + bh->u.def.section->output_offset);
0e1862bb 2011 else if (bfd_link_relocatable (info))
07d6d2b8
AM
2012 {
2013 bfd_vma lo = -1;
2014
2015 /* Find the GP-relative section with the lowest offset. */
2016 for (o = output_bfd->sections; o != NULL; o = o->next)
2017 if (o->vma < lo)
2018 lo = o->vma;
2019 /* And calculate GP relative to that. */
2020 elf_gp (output_bfd) = lo + ELF_SCORE_GP_OFFSET (input_bfd);
2021 }
1c0d3aa6 2022 else
07d6d2b8
AM
2023 {
2024 /* If the relocate_section function needs to do a reloc
2025 involving the GP value, it should make a reloc_dangerous
2026 callback to warn that GP is not defined. */
2027 }
1c0d3aa6
NC
2028 }
2029
2030 /* Parse the relocation. */
2031 r_symndx = ELF32_R_SYM (rel->r_info);
2032 r_type = ELF32_R_TYPE (rel->r_info);
2033 rel_addr = (input_section->output_section->vma + input_section->output_offset + rel->r_offset);
c3b7224a 2034 local_p = score_elf_local_relocation_p (input_bfd, rel, local_sections, TRUE);
1c0d3aa6 2035
1c0d3aa6
NC
2036 if (r_type == R_SCORE_GOT15)
2037 {
2038 const Elf_Internal_Rela *relend;
2039 const Elf_Internal_Rela *lo16_rel;
1c0d3aa6
NC
2040 bfd_vma lo_value = 0;
2041
056bafd4 2042 relend = relocs + input_section->reloc_count;
1c0d3aa6 2043 lo16_rel = score_elf_next_relocation (input_bfd, R_SCORE_GOT_LO16, rel, relend);
0150d082 2044 if ((local_p) && (lo16_rel != NULL))
07d6d2b8
AM
2045 {
2046 bfd_vma tmp = 0;
2047 tmp = score_bfd_get_32 (input_bfd, contents + lo16_rel->r_offset);
2048 lo_value = (((tmp >> 16) & 0x3) << 14) | ((tmp & 0x7fff) >> 1);
2049 }
0150d082 2050 addend = lo_value;
1c0d3aa6 2051 }
c3b7224a
NC
2052 /* For score3 R_SCORE_ABS32. */
2053 else if (r_type == R_SCORE_ABS32 || r_type == R_SCORE_REL32)
1c0d3aa6
NC
2054 {
2055 addend = (bfd_get_32 (input_bfd, hit_data) >> howto->bitpos) & howto->src_mask;
2056 }
c3b7224a
NC
2057 else
2058 {
2059 addend = (score_bfd_get_32 (input_bfd, hit_data) >> howto->bitpos) & howto->src_mask;
2060 }
1c0d3aa6 2061
1c0d3aa6
NC
2062 /* If we haven't already determined the GOT offset, or the GP value,
2063 and we're going to need it, get it now. */
2064 switch (r_type)
2065 {
2066 case R_SCORE_CALL15:
2067 case R_SCORE_GOT15:
2068 if (!local_p)
07d6d2b8
AM
2069 {
2070 g = score_elf_global_got_index (elf_hash_table (info)->dynobj,
2071 (struct elf_link_hash_entry *) h);
2072 if ((! elf_hash_table (info)->dynamic_sections_created
2073 || (bfd_link_pic (info)
2074 && (info->symbolic || h->root.dynindx == -1)
2075 && h->root.def_regular)))
2076 {
2077 /* This is a static link or a -Bsymbolic link. The
2078 symbol is defined locally, or was forced to be local.
2079 We must initialize this entry in the GOT. */
2080 bfd *tmpbfd = elf_hash_table (info)->dynobj;
2081 asection *sgot = score_elf_got_section (tmpbfd, FALSE);
2082 score_bfd_put_32 (tmpbfd, value, sgot->contents + g);
2083 }
2084 }
1c0d3aa6 2085 else if (r_type == R_SCORE_GOT15 || r_type == R_SCORE_CALL15)
07d6d2b8
AM
2086 {
2087 /* There's no need to create a local GOT entry here; the
2088 calculation for a local GOT15 entry does not involve G. */
2089 ;
2090 }
1c0d3aa6 2091 else
07d6d2b8
AM
2092 {
2093 g = score_elf_local_got_index (output_bfd, input_bfd, info,
2094 symbol + addend, r_symndx, h, r_type);
2095 if (g == MINUS_ONE)
2096 return bfd_reloc_outofrange;
2097 }
1c0d3aa6
NC
2098
2099 /* Convert GOT indices to actual offsets. */
2100 g = score_elf_got_offset_from_index (elf_hash_table (info)->dynobj,
07d6d2b8 2101 output_bfd, input_bfd, g);
1c0d3aa6
NC
2102 break;
2103
2104 case R_SCORE_HI16:
2105 case R_SCORE_LO16:
2106 case R_SCORE_GPREL32:
1c0d3aa6
NC
2107 gp = _bfd_get_gp_value (output_bfd);
2108 break;
2109
2110 case R_SCORE_GP15:
2111 gp = _bfd_get_gp_value (output_bfd);
2112
2113 default:
2114 break;
2115 }
2116
2117 switch (r_type)
2118 {
2119 case R_SCORE_NONE:
2120 return bfd_reloc_ok;
2121
2122 case R_SCORE_ABS32:
2123 case R_SCORE_REL32:
0e1862bb 2124 if ((bfd_link_pic (info)
07d6d2b8
AM
2125 || (elf_hash_table (info)->dynamic_sections_created
2126 && h != NULL
2127 && h->root.def_dynamic
2128 && !h->root.def_regular))
2129 && r_symndx != STN_UNDEF
2130 && (input_section->flags & SEC_ALLOC) != 0)
2131 {
2132 /* If we're creating a shared library, or this relocation is against a symbol
2133 in a shared library, then we can't know where the symbol will end up.
2134 So, we create a relocation record in the output, and leave the job up
2135 to the dynamic linker. */
2136 value = addend;
2137 if (!score_elf_create_dynamic_relocation (output_bfd, info, rel, h,
2138 symbol, &value,
2139 input_section))
2140 return bfd_reloc_undefined;
2141 }
cf35638d 2142 else if (r_symndx == STN_UNDEF)
07d6d2b8
AM
2143 /* r_symndx will be STN_UNDEF (zero) only for relocs against symbols
2144 from removed linkonce sections, or sections discarded by
2145 a linker script. */
2146 value = 0;
1c0d3aa6 2147 else
07d6d2b8
AM
2148 {
2149 if (r_type != R_SCORE_REL32)
2150 value = symbol + addend;
2151 else
2152 value = addend;
2153 }
1c0d3aa6
NC
2154 value &= howto->dst_mask;
2155 bfd_put_32 (input_bfd, value, hit_data);
2156 return bfd_reloc_ok;
2157
2158 case R_SCORE_ABS16:
2159 value += addend;
2160 if ((long)value > 0x7fff || (long)value < -0x8000)
07d6d2b8 2161 return bfd_reloc_overflow;
c3b7224a 2162 score_bfd_put_16 (input_bfd, value, hit_data);
1c0d3aa6
NC
2163 return bfd_reloc_ok;
2164
2165 case R_SCORE_24:
c3b7224a 2166 addend = score_bfd_get_32 (input_bfd, hit_data);
1c0d3aa6
NC
2167 offset = (((addend & howto->src_mask) >> 1) & 0x1ff8000) | ((addend & howto->src_mask) & 0x7fff);
2168 if ((offset & 0x1000000) != 0)
07d6d2b8 2169 offset |= 0xfe000000;
1c0d3aa6 2170 value += offset;
b6518b38 2171 abs_value = value - rel_addr;
c3b7224a 2172 if ((abs_value & 0xfe000000) != 0)
07d6d2b8 2173 return bfd_reloc_overflow;
1c0d3aa6 2174 addend = (addend & ~howto->src_mask)
07d6d2b8 2175 | (((value << 1) & howto->src_mask) & 0x3ff0000) | (value & 0x7fff);
c3b7224a 2176 score_bfd_put_32 (input_bfd, addend, hit_data);
1c0d3aa6
NC
2177 return bfd_reloc_ok;
2178
c3b7224a
NC
2179 /* signed imm32. */
2180 case R_SCORE_IMM30:
2181 {
07d6d2b8
AM
2182 int not_word_align_p = 0;
2183 bfd_vma imm_offset = 0;
2184 addend = score_bfd_get_48 (input_bfd, hit_data);
2185 imm_offset = ((addend >> 7) & 0xff)
2186 | (((addend >> 16) & 0x7fff) << 8)
2187 | (((addend >> 32) & 0x7f) << 23);
2188 imm_offset <<= howto->rightshift;
2189 value += imm_offset;
2190 value &= 0xffffffff;
2191
2192 /* Check lw48/sw48 rd, value/label word align. */
2193 if ((value & 0x3) != 0)
2194 not_word_align_p = 1;
2195
2196 value >>= howto->rightshift;
2197 addend = (addend & ~howto->src_mask)
2198 | (((value & 0xff) >> 0) << 7)
2199 | (((value & 0x7fff00) >> 8) << 16)
2200 | (((value & 0x3f800000) >> 23) << 32);
2201 score_bfd_put_48 (input_bfd, addend, hit_data);
2202 if (not_word_align_p)
2203 return bfd_reloc_other;
2204 else
2205 return bfd_reloc_ok;
c3b7224a
NC
2206 }
2207
2208 case R_SCORE_IMM32:
2209 {
07d6d2b8
AM
2210 bfd_vma imm_offset = 0;
2211 addend = score_bfd_get_48 (input_bfd, hit_data);
2212 imm_offset = ((addend >> 5) & 0x3ff)
2213 | (((addend >> 16) & 0x7fff) << 10)
2214 | (((addend >> 32) & 0x7f) << 25);
2215 value += imm_offset;
2216 value &= 0xffffffff;
2217 addend = (addend & ~howto->src_mask)
2218 | ((value & 0x3ff) << 5)
2219 | (((value >> 10) & 0x7fff) << 16)
2220 | (((value >> 25) & 0x7f) << 32);
2221 score_bfd_put_48 (input_bfd, addend, hit_data);
2222 return bfd_reloc_ok;
c3b7224a
NC
2223 }
2224
1c0d3aa6 2225 case R_SCORE_PC19:
c3b7224a 2226 addend = score_bfd_get_32 (input_bfd, hit_data);
1c0d3aa6
NC
2227 offset = (((addend & howto->src_mask) & 0x3ff0000) >> 6) | ((addend & howto->src_mask) & 0x3ff);
2228 if ((offset & 0x80000) != 0)
07d6d2b8 2229 offset |= 0xfff00000;
1c0d3aa6
NC
2230 abs_value = value = value - rel_addr + offset;
2231 /* exceed 20 bit : overflow. */
2232 if ((abs_value & 0x80000000) == 0x80000000)
07d6d2b8 2233 abs_value = 0xffffffff - value + 1;
1c0d3aa6 2234 if ((abs_value & 0xfff80000) != 0)
07d6d2b8 2235 return bfd_reloc_overflow;
1c0d3aa6 2236 addend = (addend & ~howto->src_mask)
07d6d2b8 2237 | (((value << 6) & howto->src_mask) & 0x3ff0000) | (value & 0x3ff);
c3b7224a 2238 score_bfd_put_32 (input_bfd, addend, hit_data);
1c0d3aa6
NC
2239 return bfd_reloc_ok;
2240
2241 case R_SCORE16_11:
c3b7224a 2242 addend = score_bfd_get_16 (input_bfd, hit_data);
1c0d3aa6 2243 offset = addend & howto->src_mask;
07d6d2b8
AM
2244 if ((offset & 0x800) != 0) /* Offset is negative. */
2245 offset |= 0xfffff000;
1c0d3aa6 2246 value += offset;
b6518b38 2247 abs_value = value - rel_addr;
c3b7224a 2248 if ((abs_value & 0xfffff000) != 0)
07d6d2b8 2249 return bfd_reloc_overflow;
1c0d3aa6 2250 addend = (addend & ~howto->src_mask) | (value & howto->src_mask);
c3b7224a 2251 score_bfd_put_16 (input_bfd, addend, hit_data);
1c0d3aa6
NC
2252 return bfd_reloc_ok;
2253
2254 case R_SCORE16_PC8:
c3b7224a 2255 addend = score_bfd_get_16 (input_bfd, hit_data);
1c0d3aa6 2256 offset = (addend & howto->src_mask) << 1;
07d6d2b8
AM
2257 if ((offset & 0x200) != 0) /* Offset is negative. */
2258 offset |= 0xfffffe00;
1c0d3aa6
NC
2259 abs_value = value = value - rel_addr + offset;
2260 /* Sign bit + exceed 9 bit. */
c3b7224a 2261 if (((value & 0xfffffe00) != 0) && ((value & 0xfffffe00) != 0xfffffe00))
07d6d2b8 2262 return bfd_reloc_overflow;
1c0d3aa6
NC
2263 value >>= 1;
2264 addend = (addend & ~howto->src_mask) | (value & howto->src_mask);
c3b7224a
NC
2265 score_bfd_put_16 (input_bfd, addend, hit_data);
2266 return bfd_reloc_ok;
2267
2268 case R_SCORE_BCMP:
2269 addend = score_bfd_get_32 (input_bfd, hit_data);
2270 offset = (addend & howto->src_mask) << howto->rightshift;
07d6d2b8
AM
2271 if ((offset & 0x200) != 0) /* Offset is negative. */
2272 offset |= 0xfffffe00;
c3b7224a
NC
2273 value = value - rel_addr + offset;
2274 /* Sign bit + exceed 9 bit. */
2275 if (((value & 0xfffffe00) != 0) && ((value & 0xfffffe00) != 0xfffffe00))
07d6d2b8 2276 return bfd_reloc_overflow;
c3b7224a
NC
2277 value >>= howto->rightshift;
2278 addend = (addend & ~howto->src_mask)
07d6d2b8
AM
2279 | (value & 0x1)
2280 | (((value >> 1) & 0x7) << 7)
2281 | (((value >> 4) & 0x1f) << 21);
c3b7224a 2282 score_bfd_put_32 (input_bfd, addend, hit_data);
1c0d3aa6
NC
2283 return bfd_reloc_ok;
2284
2285 case R_SCORE_HI16:
2286 return bfd_reloc_ok;
2287
2288 case R_SCORE_LO16:
c3b7224a 2289 hi16_addend = score_bfd_get_32 (input_bfd, hit_data - 4);
1c0d3aa6 2290 hi16_offset = ((((hi16_addend >> 16) & 0x3) << 15) | (hi16_addend & 0x7fff)) >> 1;
c3b7224a 2291 addend = score_bfd_get_32 (input_bfd, hit_data);
1c0d3aa6
NC
2292 offset = ((((addend >> 16) & 0x3) << 15) | (addend & 0x7fff)) >> 1;
2293 offset = (hi16_offset << 16) | (offset & 0xffff);
2294
2295 if (!gp_disp_p)
07d6d2b8 2296 uvalue = value + offset;
1c0d3aa6 2297 else
07d6d2b8 2298 uvalue = offset + gp - rel_addr + 4;
1c0d3aa6
NC
2299
2300 hi16_offset = (uvalue >> 16) << 1;
2301 hi16_value = (hi16_addend & (~(howto->dst_mask)))
07d6d2b8 2302 | (hi16_offset & 0x7fff) | ((hi16_offset << 1) & 0x30000);
c3b7224a 2303 score_bfd_put_32 (input_bfd, hi16_value, hit_data - 4);
1c0d3aa6
NC
2304 offset = (uvalue & 0xffff) << 1;
2305 value = (addend & (~(howto->dst_mask))) | (offset & 0x7fff) | ((offset << 1) & 0x30000);
c3b7224a 2306 score_bfd_put_32 (input_bfd, value, hit_data);
1c0d3aa6
NC
2307 return bfd_reloc_ok;
2308
2309 case R_SCORE_GP15:
c3b7224a 2310 addend = score_bfd_get_32 (input_bfd, hit_data);
1c0d3aa6
NC
2311 offset = addend & 0x7fff;
2312 if ((offset & 0x4000) == 0x4000)
07d6d2b8 2313 offset |= 0xffffc000;
1c0d3aa6
NC
2314 value = value + offset - gp;
2315 if (((value & 0xffffc000) != 0) && ((value & 0xffffc000) != 0xffffc000))
07d6d2b8 2316 return bfd_reloc_overflow;
1c0d3aa6 2317 value = (addend & ~howto->src_mask) | (value & howto->src_mask);
c3b7224a 2318 score_bfd_put_32 (input_bfd, value, hit_data);
1c0d3aa6
NC
2319 return bfd_reloc_ok;
2320
2321 case R_SCORE_GOT15:
2322 case R_SCORE_CALL15:
2323 if (local_p)
07d6d2b8
AM
2324 {
2325 bfd_boolean forced;
2326
2327 /* The special case is when the symbol is forced to be local. We need the
2328 full address in the GOT since no R_SCORE_GOT_LO16 relocation follows. */
2329 forced = ! score_elf_local_relocation_p (input_bfd, rel,
2330 local_sections, FALSE);
2331 value = score_elf_got16_entry (output_bfd, input_bfd, info,
2332 symbol + addend, forced);
2333 if (value == MINUS_ONE)
2334 return bfd_reloc_outofrange;
2335 value = score_elf_got_offset_from_index (elf_hash_table (info)->dynobj,
2336 output_bfd, input_bfd, value);
2337 }
1c0d3aa6 2338 else
07d6d2b8
AM
2339 {
2340 value = g;
2341 }
1c0d3aa6
NC
2342
2343 if ((long) value > 0x3fff || (long) value < -0x4000)
07d6d2b8 2344 return bfd_reloc_overflow;
0150d082 2345
c3b7224a 2346 addend = score_bfd_get_32 (input_bfd, hit_data);
0150d082 2347 value = (addend & ~howto->dst_mask) | (value & howto->dst_mask);
c3b7224a 2348 score_bfd_put_32 (input_bfd, value, hit_data);
1c0d3aa6
NC
2349 return bfd_reloc_ok;
2350
2351 case R_SCORE_GPREL32:
2352 value = (addend + symbol - gp);
2353 value &= howto->dst_mask;
c3b7224a 2354 score_bfd_put_32 (input_bfd, value, hit_data);
1c0d3aa6
NC
2355 return bfd_reloc_ok;
2356
2357 case R_SCORE_GOT_LO16:
c3b7224a 2358 addend = score_bfd_get_32 (input_bfd, hit_data);
0150d082 2359 value = (((addend >> 16) & 0x3) << 14) | ((addend & 0x7fff) >> 1);
1c0d3aa6 2360 value += symbol;
c3b7224a 2361 value = (addend & (~(howto->dst_mask))) | ((value & 0x3fff) << 1)
07d6d2b8 2362 | (((value >> 14) & 0x3) << 16);
1c0d3aa6 2363
c3b7224a 2364 score_bfd_put_32 (input_bfd, value, hit_data);
1c0d3aa6
NC
2365 return bfd_reloc_ok;
2366
2367 case R_SCORE_DUMMY_HI16:
2368 return bfd_reloc_ok;
2369
2370 case R_SCORE_GNU_VTINHERIT:
2371 case R_SCORE_GNU_VTENTRY:
2372 /* We don't do anything with these at present. */
2373 return bfd_reloc_continue;
2374
2375 default:
2376 return bfd_reloc_notsupported;
2377 }
2378}
2379
2380/* Score backend functions. */
f3185997 2381static bfd_boolean
c3b7224a 2382s3_bfd_score_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
07d6d2b8
AM
2383 arelent *bfd_reloc,
2384 Elf_Internal_Rela *elf_reloc)
1c0d3aa6
NC
2385{
2386 unsigned int r_type;
2387
2388 r_type = ELF32_R_TYPE (elf_reloc->r_info);
c3b7224a 2389 if (r_type >= ARRAY_SIZE (elf32_score_howto_table))
f3185997
NC
2390 return FALSE;
2391
2392 bfd_reloc->howto = &elf32_score_howto_table[r_type];
2393 return TRUE;
1c0d3aa6
NC
2394}
2395
2396/* Relocate an score ELF section. */
1c0d3aa6 2397static bfd_boolean
c3b7224a 2398s3_bfd_score_elf_relocate_section (bfd *output_bfd,
07d6d2b8
AM
2399 struct bfd_link_info *info,
2400 bfd *input_bfd,
2401 asection *input_section,
2402 bfd_byte *contents,
2403 Elf_Internal_Rela *relocs,
2404 Elf_Internal_Sym *local_syms,
2405 asection **local_sections)
1c0d3aa6
NC
2406{
2407 Elf_Internal_Shdr *symtab_hdr;
1c0d3aa6
NC
2408 Elf_Internal_Rela *rel;
2409 Elf_Internal_Rela *relend;
2410 const char *name;
2411 unsigned long offset;
2412 unsigned long hi16_addend, hi16_offset, hi16_value, uvalue;
2413 size_t extsymoff;
2414 bfd_boolean gp_disp_p = FALSE;
2415
1c0d3aa6
NC
2416 /* Sort dynsym. */
2417 if (elf_hash_table (info)->dynamic_sections_created)
2418 {
2419 bfd_size_type dynsecsymcount = 0;
0e1862bb 2420 if (bfd_link_pic (info))
07d6d2b8
AM
2421 {
2422 asection * p;
2423 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
c3b7224a 2424
07d6d2b8
AM
2425 for (p = output_bfd->sections; p ; p = p->next)
2426 if ((p->flags & SEC_EXCLUDE) == 0
2427 && (p->flags & SEC_ALLOC) != 0
2428 && !(*bed->elf_backend_omit_section_dynsym) (output_bfd, info, p))
2429 ++ dynsecsymcount;
2430 }
1c0d3aa6
NC
2431
2432 if (!score_elf_sort_hash_table (info, dynsecsymcount + 1))
07d6d2b8 2433 return FALSE;
1c0d3aa6
NC
2434 }
2435
2436 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
c3b7224a 2437 extsymoff = (elf_bad_symtab (input_bfd)) ? 0 : symtab_hdr->sh_info;
1c0d3aa6
NC
2438 rel = relocs;
2439 relend = relocs + input_section->reloc_count;
2440 for (; rel < relend; rel++)
2441 {
2442 int r_type;
2443 reloc_howto_type *howto;
2444 unsigned long r_symndx;
2445 Elf_Internal_Sym *sym;
2446 asection *sec;
2447 struct score_elf_link_hash_entry *h;
2448 bfd_vma relocation = 0;
2449 bfd_reloc_status_type r;
2450 arelent bfd_reloc;
2451
2452 r_symndx = ELF32_R_SYM (rel->r_info);
2453 r_type = ELF32_R_TYPE (rel->r_info);
2454
f3185997
NC
2455 if (! s3_bfd_score_info_to_howto (input_bfd, &bfd_reloc, (Elf_Internal_Rela *) rel))
2456 continue;
1c0d3aa6
NC
2457 howto = bfd_reloc.howto;
2458
1c0d3aa6
NC
2459 h = NULL;
2460 sym = NULL;
2461 sec = NULL;
2462
2463 if (r_symndx < extsymoff)
07d6d2b8
AM
2464 {
2465 sym = local_syms + r_symndx;
2466 sec = local_sections[r_symndx];
2467 relocation = (sec->output_section->vma
2468 + sec->output_offset
2469 + sym->st_value);
2470 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
2471
2472 if (!bfd_link_relocatable (info)
2473 && (sec->flags & SEC_MERGE)
2474 && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2475 {
2476 asection *msec;
2477 bfd_vma addend, value;
2478
2479 switch (r_type)
2480 {
2481 case R_SCORE_HI16:
2482 break;
2483 case R_SCORE_LO16:
2484 hi16_addend = score_bfd_get_32 (input_bfd, contents + rel->r_offset - 4);
2485 hi16_offset = ((((hi16_addend >> 16) & 0x3) << 15) | (hi16_addend & 0x7fff)) >> 1;
2486 value = score_bfd_get_32 (input_bfd, contents + rel->r_offset);
2487 offset = ((((value >> 16) & 0x3) << 15) | (value & 0x7fff)) >> 1;
2488 addend = (hi16_offset << 16) | (offset & 0xffff);
2489 msec = sec;
2490 addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend);
2491 addend -= relocation;
2492 addend += msec->output_section->vma + msec->output_offset;
2493 uvalue = addend;
2494 hi16_offset = (uvalue >> 16) << 1;
2495 hi16_value = (hi16_addend & (~(howto->dst_mask)))
2496 | (hi16_offset & 0x7fff) | ((hi16_offset << 1) & 0x30000);
2497 score_bfd_put_32 (input_bfd, hi16_value, contents + rel->r_offset - 4);
2498 offset = (uvalue & 0xffff) << 1;
2499 value = (value & (~(howto->dst_mask)))
2500 | (offset & 0x7fff) | ((offset << 1) & 0x30000);
2501 score_bfd_put_32 (input_bfd, value, contents + rel->r_offset);
2502 break;
2503
2504 case R_SCORE_IMM32:
2505 {
2506 value = score_bfd_get_48 (input_bfd, contents + rel->r_offset);
2507 addend = ((value >> 5) & 0x3ff)
2508 | (((value >> 16) & 0x7fff) << 10)
2509 | (((value >> 32) & 0x7f) << 25);
2510 msec = sec;
2511 addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend);
2512 addend -= relocation;
2513 addend += msec->output_section->vma + msec->output_offset;
2514 addend &= 0xffffffff;
2515 value = (value & ~howto->src_mask)
2516 | ((addend & 0x3ff) << 5)
2517 | (((addend >> 10) & 0x7fff) << 16)
2518 | (((addend >> 25) & 0x7f) << 32);
2519 score_bfd_put_48 (input_bfd, value, contents + rel->r_offset);
2520 break;
2521 }
2522
2523 case R_SCORE_IMM30:
2524 {
2525 int not_word_align_p = 0;
2526 value = score_bfd_get_48 (input_bfd, contents + rel->r_offset);
2527 addend = ((value >> 7) & 0xff)
2528 | (((value >> 16) & 0x7fff) << 8)
2529 | (((value >> 32) & 0x7f) << 23);
2530 addend <<= howto->rightshift;
2531 msec = sec;
2532 addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend);
2533 addend -= relocation;
2534 addend += msec->output_section->vma + msec->output_offset;
2535 addend &= 0xffffffff;
2536
2537 /* Check lw48/sw48 rd, value/label word align. */
2538 if ((addend & 0x3) != 0)
2539 not_word_align_p = 1;
2540
2541 addend >>= howto->rightshift;
2542 value = (value & ~howto->src_mask)
2543 | (((addend & 0xff) >> 0) << 7)
2544 | (((addend & 0x7fff00) >> 8) << 16)
2545 | (((addend & 0x3f800000) >> 23) << 32);
2546 score_bfd_put_48 (input_bfd, value, contents + rel->r_offset);
2547
2548 if (not_word_align_p)
2549 return bfd_reloc_other;
2550 else
2551 break;
2552 }
2553
2554 case R_SCORE_GOT_LO16:
2555 value = score_bfd_get_32 (input_bfd, contents + rel->r_offset);
2556 addend = (((value >> 16) & 0x3) << 14) | ((value & 0x7fff) >> 1);
2557 msec = sec;
2558 addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend) - relocation;
2559 addend += msec->output_section->vma + msec->output_offset;
2560 value = (value & (~(howto->dst_mask))) | ((addend & 0x3fff) << 1)
2561 | (((addend >> 14) & 0x3) << 16);
2562
2563 score_bfd_put_32 (input_bfd, value, contents + rel->r_offset);
2564 break;
2565
2566 case R_SCORE_ABS32:
2567 case R_SCORE_REL32:
2568 value = bfd_get_32 (input_bfd, contents + rel->r_offset);
2569 /* Get the (signed) value from the instruction. */
2570 addend = value & howto->src_mask;
2571 if (addend & ((howto->src_mask + 1) >> 1))
2572 {
2573 bfd_signed_vma mask;
2574
2575 mask = -1;
2576 mask &= ~howto->src_mask;
2577 addend |= mask;
2578 }
2579 msec = sec;
2580 addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend) - relocation;
2581 addend += msec->output_section->vma + msec->output_offset;
2582 value = (value & ~howto->dst_mask) | (addend & howto->dst_mask);
2583 bfd_put_32 (input_bfd, value, contents + rel->r_offset);
2584 break;
2585
2586 default:
2587 value = score_bfd_get_32 (input_bfd, contents + rel->r_offset);
2588 /* Get the (signed) value from the instruction. */
2589 addend = value & howto->src_mask;
2590 if (addend & ((howto->src_mask + 1) >> 1))
2591 {
2592 bfd_signed_vma mask;
2593
2594 mask = -1;
2595 mask &= ~howto->src_mask;
2596 addend |= mask;
2597 }
2598 msec = sec;
2599 addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend) - relocation;
2600 addend += msec->output_section->vma + msec->output_offset;
2601 value = (value & ~howto->dst_mask) | (addend & howto->dst_mask);
2602 score_bfd_put_32 (input_bfd, value, contents + rel->r_offset);
2603 break;
2604 }
2605 }
2606 }
1c0d3aa6 2607 else
07d6d2b8
AM
2608 {
2609 /* For global symbols we look up the symbol in the hash-table. */
2610 h = ((struct score_elf_link_hash_entry *)
2611 elf_sym_hashes (input_bfd) [r_symndx - extsymoff]);
8a5da09b
AM
2612
2613 if (info->wrap_hash != NULL
2614 && (input_section->flags & SEC_DEBUGGING) != 0)
2615 h = ((struct score_elf_link_hash_entry *)
2616 unwrap_hash_lookup (info, input_bfd, &h->root.root));
2617
07d6d2b8
AM
2618 /* Find the real hash-table entry for this symbol. */
2619 while (h->root.root.type == bfd_link_hash_indirect
2620 || h->root.root.type == bfd_link_hash_warning)
2621 h = (struct score_elf_link_hash_entry *) h->root.root.u.i.link;
2622
2623 /* Record the name of this symbol, for our caller. */
2624 name = h->root.root.root.string;
2625
2626 /* See if this is the special GP_DISP_LABEL symbol. Note that such a
2627 symbol must always be a global symbol. */
2628 if (strcmp (name, GP_DISP_LABEL) == 0)
2629 {
2630 /* Relocations against GP_DISP_LABEL are permitted only with
2631 R_SCORE_HI16 and R_SCORE_LO16 relocations. */
2632 if (r_type != R_SCORE_HI16 && r_type != R_SCORE_LO16)
2633 return bfd_reloc_notsupported;
2634
2635 gp_disp_p = TRUE;
2636 }
2637
2638 /* If this symbol is defined, calculate its address. Note that
2639 GP_DISP_LABEL is a magic symbol, always implicitly defined by the
2640 linker, so it's inappropriate to check to see whether or not
2641 its defined. */
2642 else if ((h->root.root.type == bfd_link_hash_defined
2643 || h->root.root.type == bfd_link_hash_defweak)
2644 && h->root.root.u.def.section)
2645 {
2646 sec = h->root.root.u.def.section;
2647 if (sec->output_section)
2648 relocation = (h->root.root.u.def.value
2649 + sec->output_section->vma
2650 + sec->output_offset);
2651 else
2652 {
2653 relocation = h->root.root.u.def.value;
2654 }
2655 }
2656 else if (h->root.root.type == bfd_link_hash_undefweak)
2657 /* We allow relocations against undefined weak symbols, giving
2658 it the value zero, so that you can undefined weak functions
2659 and check to see if they exist by looking at their addresses. */
2660 relocation = 0;
2661 else if (info->unresolved_syms_in_objects == RM_IGNORE
2662 && ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
2663 relocation = 0;
2664 else if (strcmp (name, "_DYNAMIC_LINK") == 0)
2665 {
2666 /* If this is a dynamic link, we should have created a _DYNAMIC_LINK symbol
2667 in s3_bfd_score_elf_create_dynamic_sections. Otherwise, we should define
2668 the symbol with a value of 0. */
2669 BFD_ASSERT (! bfd_link_pic (info));
2670 BFD_ASSERT (bfd_get_section_by_name (output_bfd, ".dynamic") == NULL);
2671 relocation = 0;
2672 }
2673 else if (!bfd_link_relocatable (info))
2674 {
95a51568
FS
2675 info->callbacks->undefined_symbol
2676 (info, h->root.root.root.string, input_bfd, input_section,
2677 rel->r_offset,
2678 (info->unresolved_syms_in_objects == RM_DIAGNOSE
2679 && !info->warn_unresolved_syms)
1a72702b 2680 || ELF_ST_VISIBILITY (h->root.other));
95a51568
FS
2681 relocation = 0;
2682 }
07d6d2b8 2683 }
1c0d3aa6 2684
dbaa2011 2685 if (sec != NULL && discarded_section (sec))
e4067dbb 2686 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
545fd46b 2687 rel, 1, relend, howto, 0, contents);
ab96bf03 2688
0e1862bb 2689 if (bfd_link_relocatable (info))
07d6d2b8
AM
2690 {
2691 /* This is a relocatable link. We don't have to change
2692 anything, unless the reloc is against a section symbol,
2693 in which case we have to adjust according to where the
2694 section symbol winds up in the output section. */
2695 if (r_symndx < symtab_hdr->sh_info)
2696 {
2697 sym = local_syms + r_symndx;
2698 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2699 {
2700 sec = local_sections[r_symndx];
2701 score_elf_add_to_rel (input_bfd, contents + rel->r_offset,
2702 howto, (bfd_signed_vma) (sec->output_offset + sym->st_value));
2703 }
2704 }
2705 continue;
2706 }
ab96bf03 2707
c3b7224a 2708 /* This is a final link. */
1c0d3aa6 2709 r = score_elf_final_link_relocate (howto, input_bfd, output_bfd,
07d6d2b8
AM
2710 input_section, contents, rel, relocs,
2711 relocation, info, name,
2712 (h ? ELF_ST_TYPE ((unsigned int)h->root.root.type) :
2713 ELF_ST_TYPE ((unsigned int)sym->st_info)), h, local_sections,
2714 gp_disp_p);
1c0d3aa6
NC
2715
2716 if (r != bfd_reloc_ok)
07d6d2b8
AM
2717 {
2718 const char *msg = (const char *)0;
2719
2720 switch (r)
2721 {
2722 case bfd_reloc_overflow:
2723 /* If the overflowing reloc was to an undefined symbol,
2724 we have already printed one error message and there
2725 is no point complaining again. */
1a72702b
AM
2726 if (!h || h->root.root.type != bfd_link_hash_undefined)
2727 (*info->callbacks->reloc_overflow)
2728 (info, NULL, name, howto->name, (bfd_vma) 0,
2729 input_bfd, input_section, rel->r_offset);
07d6d2b8
AM
2730 break;
2731 case bfd_reloc_undefined:
1a72702b
AM
2732 (*info->callbacks->undefined_symbol)
2733 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
07d6d2b8 2734 break;
1c0d3aa6 2735
07d6d2b8
AM
2736 case bfd_reloc_outofrange:
2737 msg = _("internal error: out of range error");
2738 goto common_error;
1c0d3aa6 2739
07d6d2b8
AM
2740 case bfd_reloc_notsupported:
2741 msg = _("internal error: unsupported relocation error");
2742 goto common_error;
1c0d3aa6 2743
07d6d2b8
AM
2744 case bfd_reloc_dangerous:
2745 msg = _("internal error: dangerous error");
2746 goto common_error;
1c0d3aa6 2747
07d6d2b8
AM
2748 /* Use bfd_reloc_other to check lw48, sw48 word align. */
2749 case bfd_reloc_other:
38f14ab8 2750 msg = _("address not word aligned");
07d6d2b8 2751 goto common_error;
c3b7224a 2752
07d6d2b8
AM
2753 default:
2754 msg = _("internal error: unknown error");
2755 /* Fall through. */
1c0d3aa6 2756
07d6d2b8 2757 common_error:
1a72702b
AM
2758 (*info->callbacks->warning) (info, msg, name, input_bfd,
2759 input_section, rel->r_offset);
07d6d2b8
AM
2760 break;
2761 }
2762 }
1c0d3aa6
NC
2763 }
2764
2765 return TRUE;
2766}
2767
2768/* Look through the relocs for a section during the first phase, and
2769 allocate space in the global offset table. */
1c0d3aa6 2770static bfd_boolean
c3b7224a 2771s3_bfd_score_elf_check_relocs (bfd *abfd,
07d6d2b8
AM
2772 struct bfd_link_info *info,
2773 asection *sec,
2774 const Elf_Internal_Rela *relocs)
1c0d3aa6 2775{
1c0d3aa6
NC
2776 bfd *dynobj;
2777 Elf_Internal_Shdr *symtab_hdr;
2778 struct elf_link_hash_entry **sym_hashes;
2779 struct score_got_info *g;
2780 size_t extsymoff;
2781 const Elf_Internal_Rela *rel;
2782 const Elf_Internal_Rela *rel_end;
2783 asection *sgot;
2784 asection *sreloc;
1c0d3aa6 2785
0e1862bb 2786 if (bfd_link_relocatable (info))
1c0d3aa6
NC
2787 return TRUE;
2788
2789 dynobj = elf_hash_table (info)->dynobj;
2790 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2791 sym_hashes = elf_sym_hashes (abfd);
c3b7224a 2792 extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info;
1c0d3aa6 2793
1c0d3aa6
NC
2794 if (dynobj == NULL)
2795 {
2796 sgot = NULL;
2797 g = NULL;
2798 }
2799 else
2800 {
2801 sgot = score_elf_got_section (dynobj, FALSE);
2802 if (sgot == NULL)
07d6d2b8 2803 g = NULL;
1c0d3aa6 2804 else
07d6d2b8
AM
2805 {
2806 BFD_ASSERT (score_elf_section_data (sgot) != NULL);
2807 g = score_elf_section_data (sgot)->u.got_info;
2808 BFD_ASSERT (g != NULL);
2809 }
1c0d3aa6
NC
2810 }
2811
2812 sreloc = NULL;
056bafd4 2813 rel_end = relocs + sec->reloc_count;
1c0d3aa6
NC
2814 for (rel = relocs; rel < rel_end; ++rel)
2815 {
2816 unsigned long r_symndx;
2817 unsigned int r_type;
2818 struct elf_link_hash_entry *h;
2819
2820 r_symndx = ELF32_R_SYM (rel->r_info);
2821 r_type = ELF32_R_TYPE (rel->r_info);
2822
2823 if (r_symndx < extsymoff)
07d6d2b8
AM
2824 {
2825 h = NULL;
2826 }
1c0d3aa6 2827 else if (r_symndx >= extsymoff + NUM_SHDR_ENTRIES (symtab_hdr))
07d6d2b8 2828 {
4eca0228 2829 _bfd_error_handler
695344c0 2830 /* xgettext:c-format */
38f14ab8 2831 (_("%pB: malformed reloc detected for section %pA"), abfd, sec);
07d6d2b8
AM
2832 bfd_set_error (bfd_error_bad_value);
2833 return FALSE;
2834 }
1c0d3aa6 2835 else
07d6d2b8
AM
2836 {
2837 h = sym_hashes[r_symndx - extsymoff];
1c0d3aa6 2838
07d6d2b8
AM
2839 /* This may be an indirect symbol created because of a version. */
2840 if (h != NULL)
2841 {
2842 while (h->root.type == bfd_link_hash_indirect)
2843 h = (struct elf_link_hash_entry *)h->root.u.i.link;
2844 }
2845 }
1c0d3aa6
NC
2846
2847 /* Some relocs require a global offset table. */
2848 if (dynobj == NULL || sgot == NULL)
07d6d2b8
AM
2849 {
2850 switch (r_type)
2851 {
2852 case R_SCORE_GOT15:
2853 case R_SCORE_CALL15:
2854 if (dynobj == NULL)
2855 elf_hash_table (info)->dynobj = dynobj = abfd;
2856 if (!score_elf_create_got_section (dynobj, info, FALSE))
2857 return FALSE;
2858 g = score_elf_got_info (dynobj, &sgot);
2859 break;
2860 case R_SCORE_ABS32:
2861 case R_SCORE_REL32:
2862 if (dynobj == NULL
0e1862bb
L
2863 && (bfd_link_pic (info) || h != NULL)
2864 && (sec->flags & SEC_ALLOC) != 0)
07d6d2b8
AM
2865 elf_hash_table (info)->dynobj = dynobj = abfd;
2866 break;
2867 default:
2868 break;
2869 }
2870 }
1c0d3aa6
NC
2871
2872 if (!h && (r_type == R_SCORE_GOT_LO16))
07d6d2b8
AM
2873 {
2874 if (! score_elf_record_local_got_symbol (abfd, r_symndx, rel->r_addend, g))
2875 return FALSE;
2876 }
1c0d3aa6
NC
2877
2878 switch (r_type)
07d6d2b8
AM
2879 {
2880 case R_SCORE_CALL15:
2881 if (h == NULL)
2882 {
4eca0228 2883 _bfd_error_handler
695344c0 2884 /* xgettext:c-format */
2dcf00ce
AM
2885 (_("%pB: CALL15 reloc at %#" PRIx64 " not against global symbol"),
2886 abfd, (uint64_t) rel->r_offset);
07d6d2b8
AM
2887 bfd_set_error (bfd_error_bad_value);
2888 return FALSE;
2889 }
2890 else
2891 {
2892 /* This symbol requires a global offset table entry. */
2893 if (! score_elf_record_global_got_symbol (h, abfd, info, g))
2894 return FALSE;
2895
2896 /* We need a stub, not a plt entry for the undefined function. But we record
2897 it as if it needs plt. See _bfd_elf_adjust_dynamic_symbol. */
2898 h->needs_plt = 1;
2899 h->type = STT_FUNC;
2900 }
2901 break;
2902 case R_SCORE_GOT15:
2903 if (h && ! score_elf_record_global_got_symbol (h, abfd, info, g))
2904 return FALSE;
2905 break;
2906 case R_SCORE_ABS32:
2907 case R_SCORE_REL32:
2908 if ((bfd_link_pic (info) || h != NULL)
0e1862bb 2909 && (sec->flags & SEC_ALLOC) != 0)
07d6d2b8
AM
2910 {
2911 if (sreloc == NULL)
2912 {
2913 sreloc = score_elf_rel_dyn_section (dynobj, TRUE);
2914 if (sreloc == NULL)
2915 return FALSE;
2916 }
1c0d3aa6 2917#define SCORE_READONLY_SECTION (SEC_ALLOC | SEC_LOAD | SEC_READONLY)
07d6d2b8
AM
2918 if (bfd_link_pic (info))
2919 {
2920 /* When creating a shared object, we must copy these reloc types into
2921 the output file as R_SCORE_REL32 relocs. We make room for this reloc
2922 in the .rel.dyn reloc section. */
2923 score_elf_allocate_dynamic_relocations (dynobj, 1);
2924 if ((sec->flags & SCORE_READONLY_SECTION)
2925 == SCORE_READONLY_SECTION)
2926 /* We tell the dynamic linker that there are
2927 relocations against the text segment. */
2928 info->flags |= DF_TEXTREL;
2929 }
2930 else
2931 {
2932 struct score_elf_link_hash_entry *hscore;
2933
2934 /* We only need to copy this reloc if the symbol is
2935 defined in a dynamic object. */
2936 hscore = (struct score_elf_link_hash_entry *)h;
2937 ++hscore->possibly_dynamic_relocs;
2938 if ((sec->flags & SCORE_READONLY_SECTION)
2939 == SCORE_READONLY_SECTION)
2940 /* We need it to tell the dynamic linker if there
2941 are relocations against the text segment. */
2942 hscore->readonly_reloc = TRUE;
2943 }
2944
2945 /* Even though we don't directly need a GOT entry for this symbol,
2946 a symbol must have a dynamic symbol table index greater that
2947 DT_SCORE_GOTSYM if there are dynamic relocations against it. */
2948 if (h != NULL)
2949 {
2950 if (dynobj == NULL)
2951 elf_hash_table (info)->dynobj = dynobj = abfd;
2952 if (! score_elf_create_got_section (dynobj, info, TRUE))
2953 return FALSE;
2954 g = score_elf_got_info (dynobj, &sgot);
2955 if (! score_elf_record_global_got_symbol (h, abfd, info, g))
2956 return FALSE;
2957 }
2958 }
2959 break;
2960
2961 /* This relocation describes the C++ object vtable hierarchy.
2962 Reconstruct it for later use during GC. */
2963 case R_SCORE_GNU_VTINHERIT:
2964 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2965 return FALSE;
2966 break;
2967
2968 /* This relocation describes which C++ vtable entries are actually
2969 used. Record for later use during GC. */
2970 case R_SCORE_GNU_VTENTRY:
2971 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
2972 return FALSE;
2973 break;
2974 default:
2975 break;
2976 }
1c0d3aa6
NC
2977
2978 /* We must not create a stub for a symbol that has relocations
07d6d2b8 2979 related to taking the function's address. */
1c0d3aa6 2980 switch (r_type)
07d6d2b8
AM
2981 {
2982 default:
2983 if (h != NULL)
2984 {
2985 struct score_elf_link_hash_entry *sh;
2986
2987 sh = (struct score_elf_link_hash_entry *) h;
2988 sh->no_fn_stub = TRUE;
2989 }
2990 break;
2991 case R_SCORE_CALL15:
2992 break;
2993 }
1c0d3aa6
NC
2994 }
2995
2996 return TRUE;
2997}
2998
2999static bfd_boolean
c3b7224a 3000s3_bfd_score_elf_add_symbol_hook (bfd *abfd,
07d6d2b8
AM
3001 struct bfd_link_info *info ATTRIBUTE_UNUSED,
3002 Elf_Internal_Sym *sym,
3003 const char **namep ATTRIBUTE_UNUSED,
3004 flagword *flagsp ATTRIBUTE_UNUSED,
3005 asection **secp,
3006 bfd_vma *valp)
1c0d3aa6
NC
3007{
3008 switch (sym->st_shndx)
3009 {
3010 case SHN_COMMON:
3011 if (sym->st_size > elf_gp_size (abfd))
07d6d2b8 3012 break;
1c0d3aa6
NC
3013 /* Fall through. */
3014 case SHN_SCORE_SCOMMON:
3015 *secp = bfd_make_section_old_way (abfd, ".scommon");
10885e24 3016 (*secp)->flags |= SEC_IS_COMMON | SEC_SMALL_DATA;
1c0d3aa6
NC
3017 *valp = sym->st_size;
3018 break;
3019 }
3020
3021 return TRUE;
3022}
3023
3024static void
c3b7224a 3025s3_bfd_score_elf_symbol_processing (bfd *abfd, asymbol *asym)
1c0d3aa6
NC
3026{
3027 elf_symbol_type *elfsym;
3028
3029 elfsym = (elf_symbol_type *) asym;
3030 switch (elfsym->internal_elf_sym.st_shndx)
3031 {
3032 case SHN_COMMON:
3033 if (asym->value > elf_gp_size (abfd))
07d6d2b8 3034 break;
1c0d3aa6
NC
3035 /* Fall through. */
3036 case SHN_SCORE_SCOMMON:
1c0d3aa6
NC
3037 asym->section = &score_elf_scom_section;
3038 asym->value = elfsym->internal_elf_sym.st_size;
3039 break;
3040 }
3041}
3042
6e0b88f1 3043static int
c3b7224a 3044s3_bfd_score_elf_link_output_symbol_hook (struct bfd_link_info *info ATTRIBUTE_UNUSED,
07d6d2b8
AM
3045 const char *name ATTRIBUTE_UNUSED,
3046 Elf_Internal_Sym *sym,
3047 asection *input_sec,
3048 struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
1c0d3aa6
NC
3049{
3050 /* If we see a common symbol, which implies a relocatable link, then
3051 if a symbol was small common in an input file, mark it as small
3052 common in the output file. */
3053 if (sym->st_shndx == SHN_COMMON && strcmp (input_sec->name, ".scommon") == 0)
3054 sym->st_shndx = SHN_SCORE_SCOMMON;
3055
6e0b88f1 3056 return 1;
1c0d3aa6
NC
3057}
3058
3059static bfd_boolean
c3b7224a 3060s3_bfd_score_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
07d6d2b8
AM
3061 asection *sec,
3062 int *retval)
1c0d3aa6 3063{
fd361982 3064 if (strcmp (bfd_section_name (sec), ".scommon") == 0)
1c0d3aa6
NC
3065 {
3066 *retval = SHN_SCORE_SCOMMON;
3067 return TRUE;
3068 }
3069
3070 return FALSE;
3071}
3072
3073/* Adjust a symbol defined by a dynamic object and referenced by a
3074 regular object. The current definition is in some section of the
3075 dynamic object, but we're not including those sections. We have to
3076 change the definition to something the rest of the link can understand. */
1c0d3aa6 3077static bfd_boolean
c3b7224a 3078s3_bfd_score_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
07d6d2b8 3079 struct elf_link_hash_entry *h)
1c0d3aa6
NC
3080{
3081 bfd *dynobj;
3082 struct score_elf_link_hash_entry *hscore;
3083 asection *s;
3084
3085 dynobj = elf_hash_table (info)->dynobj;
3086
3087 /* Make sure we know what is going on here. */
3088 BFD_ASSERT (dynobj != NULL
07d6d2b8
AM
3089 && (h->needs_plt
3090 || h->is_weakalias
3091 || (h->def_dynamic && h->ref_regular && !h->def_regular)));
1c0d3aa6
NC
3092
3093 /* If this symbol is defined in a dynamic object, we need to copy
3094 any R_SCORE_ABS32 or R_SCORE_REL32 relocs against it into the output
3095 file. */
3096 hscore = (struct score_elf_link_hash_entry *)h;
0e1862bb 3097 if (!bfd_link_relocatable (info)
1c0d3aa6
NC
3098 && hscore->possibly_dynamic_relocs != 0
3099 && (h->root.type == bfd_link_hash_defweak || !h->def_regular))
3100 {
3101 score_elf_allocate_dynamic_relocations (dynobj, hscore->possibly_dynamic_relocs);
3102 if (hscore->readonly_reloc)
07d6d2b8
AM
3103 /* We tell the dynamic linker that there are relocations
3104 against the text segment. */
3105 info->flags |= DF_TEXTREL;
1c0d3aa6
NC
3106 }
3107
3108 /* For a function, create a stub, if allowed. */
3109 if (!hscore->no_fn_stub && h->needs_plt)
3110 {
3111 if (!elf_hash_table (info)->dynamic_sections_created)
07d6d2b8 3112 return TRUE;
1c0d3aa6
NC
3113
3114 /* If this symbol is not defined in a regular file, then set
07d6d2b8
AM
3115 the symbol to the stub location. This is required to make
3116 function pointers compare as equal between the normal
3117 executable and the shared library. */
1c0d3aa6 3118 if (!h->def_regular)
07d6d2b8
AM
3119 {
3120 /* We need .stub section. */
3121 s = bfd_get_linker_section (dynobj, SCORE_ELF_STUB_SECTION_NAME);
3122 BFD_ASSERT (s != NULL);
1c0d3aa6 3123
07d6d2b8
AM
3124 h->root.u.def.section = s;
3125 h->root.u.def.value = s->size;
1c0d3aa6 3126
07d6d2b8
AM
3127 /* XXX Write this stub address somewhere. */
3128 h->plt.offset = s->size;
1c0d3aa6 3129
07d6d2b8
AM
3130 /* Make room for this stub code. */
3131 s->size += SCORE_FUNCTION_STUB_SIZE;
1c0d3aa6 3132
07d6d2b8
AM
3133 /* The last half word of the stub will be filled with the index
3134 of this symbol in .dynsym section. */
3135 return TRUE;
3136 }
1c0d3aa6
NC
3137 }
3138 else if ((h->type == STT_FUNC) && !h->needs_plt)
3139 {
3140 /* This will set the entry for this symbol in the GOT to 0, and
07d6d2b8 3141 the dynamic linker will take care of this. */
1c0d3aa6
NC
3142 h->root.u.def.value = 0;
3143 return TRUE;
3144 }
3145
3146 /* If this is a weak symbol, and there is a real definition, the
3147 processor independent code will have arranged for us to see the
3148 real definition first, and we can just use the same value. */
60d67dc8 3149 if (h->is_weakalias)
1c0d3aa6 3150 {
60d67dc8
AM
3151 struct elf_link_hash_entry *def = weakdef (h);
3152 BFD_ASSERT (def->root.type == bfd_link_hash_defined);
3153 h->root.u.def.section = def->root.u.def.section;
3154 h->root.u.def.value = def->root.u.def.value;
1c0d3aa6
NC
3155 return TRUE;
3156 }
3157
3158 /* This is a reference to a symbol defined by a dynamic object which
3159 is not a function. */
3160 return TRUE;
3161}
3162
3163/* This function is called after all the input files have been read,
3164 and the input sections have been assigned to output sections. */
1c0d3aa6 3165static bfd_boolean
c3b7224a 3166s3_bfd_score_elf_always_size_sections (bfd *output_bfd,
07d6d2b8 3167 struct bfd_link_info *info)
1c0d3aa6
NC
3168{
3169 bfd *dynobj;
3170 asection *s;
3171 struct score_got_info *g;
3172 int i;
3173 bfd_size_type loadable_size = 0;
3174 bfd_size_type local_gotno;
3175 bfd *sub;
3176
3177 dynobj = elf_hash_table (info)->dynobj;
3178 if (dynobj == NULL)
3179 /* Relocatable links don't have it. */
3180 return TRUE;
3181
3182 g = score_elf_got_info (dynobj, &s);
3183 if (s == NULL)
3184 return TRUE;
3185
3186 /* Calculate the total loadable size of the output. That will give us the
3187 maximum number of GOT_PAGE entries required. */
c72f2fb2 3188 for (sub = info->input_bfds; sub; sub = sub->link.next)
1c0d3aa6
NC
3189 {
3190 asection *subsection;
3191
3192 for (subsection = sub->sections;
07d6d2b8
AM
3193 subsection;
3194 subsection = subsection->next)
3195 {
3196 if ((subsection->flags & SEC_ALLOC) == 0)
3197 continue;
3198 loadable_size += ((subsection->size + 0xf)
3199 &~ (bfd_size_type) 0xf);
3200 }
1c0d3aa6
NC
3201 }
3202
3203 /* There has to be a global GOT entry for every symbol with
3204 a dynamic symbol table index of DT_SCORE_GOTSYM or
3205 higher. Therefore, it make sense to put those symbols
3206 that need GOT entries at the end of the symbol table. We
3207 do that here. */
3208 if (! score_elf_sort_hash_table (info, 1))
3209 return FALSE;
3210
3211 if (g->global_gotsym != NULL)
3212 i = elf_hash_table (info)->dynsymcount - g->global_gotsym->dynindx;
3213 else
3214 /* If there are no global symbols, or none requiring
3215 relocations, then GLOBAL_GOTSYM will be NULL. */
3216 i = 0;
3217
3218 /* In the worst case, we'll get one stub per dynamic symbol. */
3219 loadable_size += SCORE_FUNCTION_STUB_SIZE * i;
3220
3221 /* Assume there are two loadable segments consisting of
3222 contiguous sections. Is 5 enough? */
3223 local_gotno = (loadable_size >> 16) + 5;
3224
3225 g->local_gotno += local_gotno;
3226 s->size += g->local_gotno * SCORE_ELF_GOT_SIZE (output_bfd);
3227
3228 g->global_gotno = i;
3229 s->size += i * SCORE_ELF_GOT_SIZE (output_bfd);
3230
3231 score_elf_resolve_final_got_entries (g);
3232
3233 if (s->size > SCORE_ELF_GOT_MAX_SIZE (output_bfd))
3234 {
3235 /* Fixme. Error message or Warning message should be issued here. */
3236 }
3237
3238 return TRUE;
3239}
3240
3241/* Set the sizes of the dynamic sections. */
1c0d3aa6 3242static bfd_boolean
c3b7224a 3243s3_bfd_score_elf_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
1c0d3aa6
NC
3244{
3245 bfd *dynobj;
3246 asection *s;
3247 bfd_boolean reltext;
3248
3249 dynobj = elf_hash_table (info)->dynobj;
3250 BFD_ASSERT (dynobj != NULL);
3251
3252 if (elf_hash_table (info)->dynamic_sections_created)
3253 {
3254 /* Set the contents of the .interp section to the interpreter. */
f5233a16 3255 if (bfd_link_executable (info) && !info->nointerp)
07d6d2b8
AM
3256 {
3257 s = bfd_get_linker_section (dynobj, ".interp");
3258 BFD_ASSERT (s != NULL);
3259 s->size = strlen (ELF_DYNAMIC_INTERPRETER) + 1;
3260 s->contents = (bfd_byte *) ELF_DYNAMIC_INTERPRETER;
3261 }
1c0d3aa6
NC
3262 }
3263
3264 /* The check_relocs and adjust_dynamic_symbol entry points have
3265 determined the sizes of the various dynamic sections. Allocate
3266 memory for them. */
3267 reltext = FALSE;
3268 for (s = dynobj->sections; s != NULL; s = s->next)
3269 {
3270 const char *name;
3271
3272 if ((s->flags & SEC_LINKER_CREATED) == 0)
07d6d2b8 3273 continue;
1c0d3aa6
NC
3274
3275 /* It's OK to base decisions on the section name, because none
07d6d2b8 3276 of the dynobj section names depend upon the input files. */
fd361982 3277 name = bfd_section_name (s);
1c0d3aa6
NC
3278
3279 if (CONST_STRNEQ (name, ".rel"))
07d6d2b8
AM
3280 {
3281 if (s->size == 0)
3282 {
3283 /* We only strip the section if the output section name
3284 has the same name. Otherwise, there might be several
3285 input sections for this output section. FIXME: This
3286 code is probably not needed these days anyhow, since
3287 the linker now does not create empty output sections. */
3288 if (s->output_section != NULL
3289 && strcmp (name,
fd361982 3290 bfd_section_name (s->output_section)) == 0)
07d6d2b8
AM
3291 s->flags |= SEC_EXCLUDE;
3292 }
3293 else
3294 {
3295 const char *outname;
3296 asection *target;
3297
3298 /* If this relocation section applies to a read only
3299 section, then we probably need a DT_TEXTREL entry.
3300 If the relocation section is .rel.dyn, we always
3301 assert a DT_TEXTREL entry rather than testing whether
3302 there exists a relocation to a read only section or
3303 not. */
fd361982 3304 outname = bfd_section_name (s->output_section);
07d6d2b8
AM
3305 target = bfd_get_section_by_name (output_bfd, outname + 4);
3306 if ((target != NULL
3307 && (target->flags & SEC_READONLY) != 0
3308 && (target->flags & SEC_ALLOC) != 0) || strcmp (outname, ".rel.dyn") == 0)
3309 reltext = TRUE;
3310
3311 /* We use the reloc_count field as a counter if we need
3312 to copy relocs into the output file. */
3313 if (strcmp (name, ".rel.dyn") != 0)
3314 s->reloc_count = 0;
3315 }
3316 }
1c0d3aa6 3317 else if (CONST_STRNEQ (name, ".got"))
07d6d2b8
AM
3318 {
3319 /* s3_bfd_score_elf_always_size_sections() has already done
3320 most of the work, but some symbols may have been mapped
3321 to versions that we must now resolve in the got_entries
3322 hash tables. */
3323 }
1c0d3aa6 3324 else if (strcmp (name, SCORE_ELF_STUB_SECTION_NAME) == 0)
07d6d2b8
AM
3325 {
3326 /* IRIX rld assumes that the function stub isn't at the end
3327 of .text section. So put a dummy. XXX */
3328 s->size += SCORE_FUNCTION_STUB_SIZE;
3329 }
1c0d3aa6 3330 else if (! CONST_STRNEQ (name, ".init"))
07d6d2b8
AM
3331 {
3332 /* It's not one of our sections, so don't allocate space. */
3333 continue;
3334 }
1c0d3aa6
NC
3335
3336 /* Allocate memory for the section contents. */
3337 s->contents = bfd_zalloc (dynobj, s->size);
3338 if (s->contents == NULL && s->size != 0)
07d6d2b8
AM
3339 {
3340 bfd_set_error (bfd_error_no_memory);
3341 return FALSE;
3342 }
1c0d3aa6
NC
3343 }
3344
3345 if (elf_hash_table (info)->dynamic_sections_created)
3346 {
3347 /* Add some entries to the .dynamic section. We fill in the
07d6d2b8
AM
3348 values later, in s3_bfd_score_elf_finish_dynamic_sections, but we
3349 must add the entries now so that we get the correct size for
3350 the .dynamic section. The DT_DEBUG entry is filled in by the
3351 dynamic linker and used by the debugger. */
1c0d3aa6
NC
3352
3353 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_DEBUG, 0))
07d6d2b8 3354 return FALSE;
1c0d3aa6
NC
3355
3356 if (reltext)
07d6d2b8 3357 info->flags |= DF_TEXTREL;
1c0d3aa6
NC
3358
3359 if ((info->flags & DF_TEXTREL) != 0)
07d6d2b8
AM
3360 {
3361 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_TEXTREL, 0))
3362 return FALSE;
3363 }
1c0d3aa6
NC
3364
3365 if (! SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTGOT, 0))
07d6d2b8 3366 return FALSE;
1c0d3aa6
NC
3367
3368 if (score_elf_rel_dyn_section (dynobj, FALSE))
07d6d2b8
AM
3369 {
3370 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_REL, 0))
3371 return FALSE;
1c0d3aa6 3372
07d6d2b8
AM
3373 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELSZ, 0))
3374 return FALSE;
1c0d3aa6 3375
07d6d2b8
AM
3376 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELENT, 0))
3377 return FALSE;
3378 }
1c0d3aa6
NC
3379
3380 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_SCORE_BASE_ADDRESS, 0))
07d6d2b8 3381 return FALSE;
1c0d3aa6
NC
3382
3383 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_SCORE_LOCAL_GOTNO, 0))
07d6d2b8 3384 return FALSE;
1c0d3aa6
NC
3385
3386 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_SCORE_SYMTABNO, 0))
07d6d2b8 3387 return FALSE;
1c0d3aa6
NC
3388
3389 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_SCORE_UNREFEXTNO, 0))
07d6d2b8 3390 return FALSE;
1c0d3aa6
NC
3391
3392 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_SCORE_GOTSYM, 0))
07d6d2b8 3393 return FALSE;
1c0d3aa6
NC
3394
3395 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_SCORE_HIPAGENO, 0))
07d6d2b8 3396 return FALSE;
1c0d3aa6
NC
3397 }
3398
3399 return TRUE;
3400}
3401
3402static bfd_boolean
c3b7224a 3403s3_bfd_score_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
1c0d3aa6
NC
3404{
3405 struct elf_link_hash_entry *h;
3406 struct bfd_link_hash_entry *bh;
3407 flagword flags;
3408 asection *s;
3409
3410 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
07d6d2b8 3411 | SEC_LINKER_CREATED | SEC_READONLY);
1c0d3aa6
NC
3412
3413 /* ABI requests the .dynamic section to be read only. */
3d4d4302 3414 s = bfd_get_linker_section (abfd, ".dynamic");
1c0d3aa6
NC
3415 if (s != NULL)
3416 {
fd361982 3417 if (!bfd_set_section_flags (s, flags))
07d6d2b8 3418 return FALSE;
1c0d3aa6
NC
3419 }
3420
3421 /* We need to create .got section. */
3422 if (!score_elf_create_got_section (abfd, info, FALSE))
3423 return FALSE;
3424
3425 if (!score_elf_rel_dyn_section (elf_hash_table (info)->dynobj, TRUE))
3426 return FALSE;
3427
3428 /* Create .stub section. */
3d4d4302 3429 if (bfd_get_linker_section (abfd, SCORE_ELF_STUB_SECTION_NAME) == NULL)
1c0d3aa6 3430 {
3d4d4302
AM
3431 s = bfd_make_section_anyway_with_flags (abfd, SCORE_ELF_STUB_SECTION_NAME,
3432 flags | SEC_CODE);
1c0d3aa6 3433 if (s == NULL
fd361982 3434 || !bfd_set_section_alignment (s, 2))
1c0d3aa6 3435
07d6d2b8 3436 return FALSE;
1c0d3aa6
NC
3437 }
3438
0e1862bb 3439 if (!bfd_link_pic (info))
1c0d3aa6
NC
3440 {
3441 const char *name;
3442
3443 name = "_DYNAMIC_LINK";
3444 bh = NULL;
3445 if (!(_bfd_generic_link_add_one_symbol
07d6d2b8
AM
3446 (info, abfd, name, BSF_GLOBAL, bfd_abs_section_ptr,
3447 (bfd_vma) 0, NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
3448 return FALSE;
1c0d3aa6
NC
3449
3450 h = (struct elf_link_hash_entry *)bh;
3451 h->non_elf = 0;
3452 h->def_regular = 1;
3453 h->type = STT_SECTION;
3454
3455 if (!bfd_elf_link_record_dynamic_symbol (info, h))
07d6d2b8 3456 return FALSE;
1c0d3aa6
NC
3457 }
3458
3459 return TRUE;
3460}
3461
3462
3463/* Finish up dynamic symbol handling. We set the contents of various
3464 dynamic sections here. */
1c0d3aa6 3465static bfd_boolean
c3b7224a 3466s3_bfd_score_elf_finish_dynamic_symbol (bfd *output_bfd,
07d6d2b8
AM
3467 struct bfd_link_info *info,
3468 struct elf_link_hash_entry *h,
3469 Elf_Internal_Sym *sym)
1c0d3aa6
NC
3470{
3471 bfd *dynobj;
3472 asection *sgot;
3473 struct score_got_info *g;
3474 const char *name;
3475
3476 dynobj = elf_hash_table (info)->dynobj;
3477
3478 if (h->plt.offset != MINUS_ONE)
3479 {
3480 asection *s;
3481 bfd_byte stub[SCORE_FUNCTION_STUB_SIZE];
3482
3483 /* This symbol has a stub. Set it up. */
3484 BFD_ASSERT (h->dynindx != -1);
3485
3d4d4302 3486 s = bfd_get_linker_section (dynobj, SCORE_ELF_STUB_SECTION_NAME);
1c0d3aa6
NC
3487 BFD_ASSERT (s != NULL);
3488
3489 /* FIXME: Can h->dynindex be more than 64K? */
3490 if (h->dynindx & 0xffff0000)
07d6d2b8 3491 return FALSE;
1c0d3aa6
NC
3492
3493 /* Fill the stub. */
c3b7224a
NC
3494 score_bfd_put_32 (output_bfd, STUB_LW, stub);
3495 score_bfd_put_32 (output_bfd, STUB_MOVE, stub + 4);
3496 score_bfd_put_32 (output_bfd, STUB_LI16 | (h->dynindx << 1), stub + 8);
3497 score_bfd_put_32 (output_bfd, STUB_BRL, stub + 12);
1c0d3aa6
NC
3498
3499 BFD_ASSERT (h->plt.offset <= s->size);
3500 memcpy (s->contents + h->plt.offset, stub, SCORE_FUNCTION_STUB_SIZE);
3501
3502 /* Mark the symbol as undefined. plt.offset != -1 occurs
07d6d2b8 3503 only for the referenced symbol. */
1c0d3aa6
NC
3504 sym->st_shndx = SHN_UNDEF;
3505
3506 /* The run-time linker uses the st_value field of the symbol
07d6d2b8
AM
3507 to reset the global offset table entry for this external
3508 to its stub address when unlinking a shared object. */
1c0d3aa6
NC
3509 sym->st_value = (s->output_section->vma + s->output_offset + h->plt.offset);
3510 }
3511
3512 BFD_ASSERT (h->dynindx != -1 || h->forced_local);
3513
3514 sgot = score_elf_got_section (dynobj, FALSE);
3515 BFD_ASSERT (sgot != NULL);
3516 BFD_ASSERT (score_elf_section_data (sgot) != NULL);
3517 g = score_elf_section_data (sgot)->u.got_info;
3518 BFD_ASSERT (g != NULL);
3519
3520 /* Run through the global symbol table, creating GOT entries for all
3521 the symbols that need them. */
3522 if (g->global_gotsym != NULL && h->dynindx >= g->global_gotsym->dynindx)
3523 {
3524 bfd_vma offset;
3525 bfd_vma value;
3526
3527 value = sym->st_value;
3528 offset = score_elf_global_got_index (dynobj, h);
c3b7224a 3529 score_bfd_put_32 (output_bfd, value, sgot->contents + offset);
1c0d3aa6
NC
3530 }
3531
3532 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3533 name = h->root.root.string;
9637f6ef
L
3534 if (h == elf_hash_table (info)->hdynamic
3535 || h == elf_hash_table (info)->hgot)
1c0d3aa6
NC
3536 sym->st_shndx = SHN_ABS;
3537 else if (strcmp (name, "_DYNAMIC_LINK") == 0)
3538 {
3539 sym->st_shndx = SHN_ABS;
3540 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
3541 sym->st_value = 1;
3542 }
3543 else if (strcmp (name, GP_DISP_LABEL) == 0)
3544 {
3545 sym->st_shndx = SHN_ABS;
3546 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
3547 sym->st_value = elf_gp (output_bfd);
3548 }
3549
3550 return TRUE;
3551}
3552
3553/* Finish up the dynamic sections. */
1c0d3aa6 3554static bfd_boolean
c3b7224a 3555s3_bfd_score_elf_finish_dynamic_sections (bfd *output_bfd,
07d6d2b8 3556 struct bfd_link_info *info)
1c0d3aa6
NC
3557{
3558 bfd *dynobj;
3559 asection *sdyn;
3560 asection *sgot;
3561 asection *s;
3562 struct score_got_info *g;
3563
3564 dynobj = elf_hash_table (info)->dynobj;
3565
3d4d4302 3566 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
1c0d3aa6
NC
3567
3568 sgot = score_elf_got_section (dynobj, FALSE);
3569 if (sgot == NULL)
3570 g = NULL;
3571 else
3572 {
3573 BFD_ASSERT (score_elf_section_data (sgot) != NULL);
3574 g = score_elf_section_data (sgot)->u.got_info;
3575 BFD_ASSERT (g != NULL);
3576 }
3577
3578 if (elf_hash_table (info)->dynamic_sections_created)
3579 {
3580 bfd_byte *b;
3581
3582 BFD_ASSERT (sdyn != NULL);
3583 BFD_ASSERT (g != NULL);
3584
3585 for (b = sdyn->contents;
07d6d2b8
AM
3586 b < sdyn->contents + sdyn->size;
3587 b += SCORE_ELF_DYN_SIZE (dynobj))
3588 {
3589 Elf_Internal_Dyn dyn;
3590 const char *name;
3591 size_t elemsize;
3592 bfd_boolean swap_out_p;
3593
3594 /* Read in the current dynamic entry. */
3595 (*get_elf_backend_data (dynobj)->s->swap_dyn_in) (dynobj, b, &dyn);
3596
3597 /* Assume that we're going to modify it and write it out. */
3598 swap_out_p = TRUE;
3599
3600 switch (dyn.d_tag)
3601 {
3602 case DT_RELENT:
3603 dyn.d_un.d_val = SCORE_ELF_REL_SIZE (dynobj);
3604 break;
3605
3606 case DT_STRSZ:
3607 /* Rewrite DT_STRSZ. */
3608 dyn.d_un.d_val
3609 = _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
3610 break;
3611
3612 case DT_PLTGOT:
3613 s = elf_hash_table (info)->sgot;
3614 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
3615 break;
3616
3617 case DT_SCORE_BASE_ADDRESS:
3618 s = output_bfd->sections;
3619 BFD_ASSERT (s != NULL);
3620 dyn.d_un.d_ptr = s->vma & ~(bfd_vma) 0xffff;
3621 break;
3622
3623 case DT_SCORE_LOCAL_GOTNO:
3624 dyn.d_un.d_val = g->local_gotno;
3625 break;
3626
3627 case DT_SCORE_UNREFEXTNO:
3628 /* The index into the dynamic symbol table which is the
3629 entry of the first external symbol that is not
3630 referenced within the same object. */
3631 dyn.d_un.d_val = bfd_count_sections (output_bfd) + 1;
3632 break;
3633
3634 case DT_SCORE_GOTSYM:
3635 if (g->global_gotsym)
3636 {
3637 dyn.d_un.d_val = g->global_gotsym->dynindx;
3638 break;
3639 }
3640 /* In case if we don't have global got symbols we default
3641 to setting DT_SCORE_GOTSYM to the same value as
3642 DT_SCORE_SYMTABNO. */
1a0670f3 3643 /* Fall through. */
c3b7224a 3644
07d6d2b8
AM
3645 case DT_SCORE_SYMTABNO:
3646 name = ".dynsym";
3647 elemsize = SCORE_ELF_SYM_SIZE (output_bfd);
3648 s = bfd_get_linker_section (dynobj, name);
3649 dyn.d_un.d_val = s->size / elemsize;
3650 break;
3651
3652 case DT_SCORE_HIPAGENO:
3653 dyn.d_un.d_val = g->local_gotno - SCORE_RESERVED_GOTNO;
3654 break;
3655
3656 default:
3657 swap_out_p = FALSE;
3658 break;
3659 }
3660
3661 if (swap_out_p)
3662 (*get_elf_backend_data (dynobj)->s->swap_dyn_out) (dynobj, &dyn, b);
3663 }
1c0d3aa6
NC
3664 }
3665
3666 /* The first entry of the global offset table will be filled at
3667 runtime. The second entry will be used by some runtime loaders.
3668 This isn't the case of IRIX rld. */
3669 if (sgot != NULL && sgot->size > 0)
3670 {
c3b7224a
NC
3671 score_bfd_put_32 (output_bfd, 0, sgot->contents);
3672 score_bfd_put_32 (output_bfd, 0x80000000, sgot->contents + SCORE_ELF_GOT_SIZE (output_bfd));
1c0d3aa6
NC
3673 }
3674
3675 if (sgot != NULL)
3676 elf_section_data (sgot->output_section)->this_hdr.sh_entsize
3677 = SCORE_ELF_GOT_SIZE (output_bfd);
3678
3679
3680 /* We need to sort the entries of the dynamic relocation section. */
3681 s = score_elf_rel_dyn_section (dynobj, FALSE);
3682
3683 if (s != NULL && s->size > (bfd_vma)2 * SCORE_ELF_REL_SIZE (output_bfd))
3684 {
3685 reldyn_sorting_bfd = output_bfd;
3686 qsort ((Elf32_External_Rel *) s->contents + 1, s->reloc_count - 1,
07d6d2b8 3687 sizeof (Elf32_External_Rel), score_elf_sort_dynamic_relocs);
1c0d3aa6
NC
3688 }
3689
3690 return TRUE;
3691}
3692
3693/* This function set up the ELF section header for a BFD section in preparation for writing
3694 it out. This is where the flags and type fields are set for unusual sections. */
1c0d3aa6 3695static bfd_boolean
c3b7224a 3696s3_bfd_score_elf_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
07d6d2b8
AM
3697 Elf_Internal_Shdr *hdr,
3698 asection *sec)
1c0d3aa6
NC
3699{
3700 const char *name;
3701
fd361982 3702 name = bfd_section_name (sec);
1c0d3aa6
NC
3703
3704 if (strcmp (name, ".got") == 0
3705 || strcmp (name, ".srdata") == 0
3706 || strcmp (name, ".sdata") == 0
3707 || strcmp (name, ".sbss") == 0)
3708 hdr->sh_flags |= SHF_SCORE_GPREL;
3709
3710 return TRUE;
3711}
3712
3713/* This function do additional processing on the ELF section header before writing
3714 it out. This is used to set the flags and type fields for some sections. */
3715
3716/* assign_file_positions_except_relocs() check section flag and if it is allocatable,
3717 warning message will be issued. backend_fake_section is called before
3718 assign_file_positions_except_relocs(); backend_section_processing after it. so, we
3719 modify section flag there, but not backend_fake_section. */
1c0d3aa6 3720static bfd_boolean
c3b7224a 3721s3_bfd_score_elf_section_processing (bfd *abfd ATTRIBUTE_UNUSED, Elf_Internal_Shdr *hdr)
1c0d3aa6
NC
3722{
3723 if (hdr->bfd_section != NULL)
3724 {
fd361982 3725 const char *name = bfd_section_name (hdr->bfd_section);
1c0d3aa6
NC
3726
3727 if (strcmp (name, ".sdata") == 0)
07d6d2b8
AM
3728 {
3729 hdr->sh_flags |= SHF_ALLOC | SHF_WRITE | SHF_SCORE_GPREL;
3730 hdr->sh_type = SHT_PROGBITS;
3731 }
1c0d3aa6 3732 else if (strcmp (name, ".sbss") == 0)
07d6d2b8
AM
3733 {
3734 hdr->sh_flags |= SHF_ALLOC | SHF_WRITE | SHF_SCORE_GPREL;
3735 hdr->sh_type = SHT_NOBITS;
3736 }
1c0d3aa6 3737 else if (strcmp (name, ".srdata") == 0)
07d6d2b8
AM
3738 {
3739 hdr->sh_flags |= SHF_ALLOC | SHF_SCORE_GPREL;
3740 hdr->sh_type = SHT_PROGBITS;
3741 }
1c0d3aa6
NC
3742 }
3743
3744 return TRUE;
3745}
3746
3747static bfd_boolean
c3b7224a 3748s3_bfd_score_elf_write_section (bfd *output_bfd, asection *sec, bfd_byte *contents)
1c0d3aa6
NC
3749{
3750 bfd_byte *to, *from, *end;
3751 int i;
3752
3753 if (strcmp (sec->name, ".pdr") != 0)
3754 return FALSE;
3755
3756 if (score_elf_section_data (sec)->u.tdata == NULL)
3757 return FALSE;
3758
3759 to = contents;
3760 end = contents + sec->size;
3761 for (from = contents, i = 0; from < end; from += PDR_SIZE, i++)
3762 {
3763 if ((score_elf_section_data (sec)->u.tdata)[i] == 1)
07d6d2b8 3764 continue;
1c0d3aa6
NC
3765
3766 if (to != from)
07d6d2b8 3767 memcpy (to, from, PDR_SIZE);
1c0d3aa6
NC
3768
3769 to += PDR_SIZE;
3770 }
3771 bfd_set_section_contents (output_bfd, sec->output_section, contents,
07d6d2b8 3772 (file_ptr) sec->output_offset, sec->size);
1c0d3aa6
NC
3773
3774 return TRUE;
3775}
3776
3777/* Copy data from a SCORE ELF indirect symbol to its direct symbol, hiding the old
3778 indirect symbol. Process additional relocation information. */
1c0d3aa6 3779static void
c3b7224a 3780s3_bfd_score_elf_copy_indirect_symbol (struct bfd_link_info *info,
07d6d2b8
AM
3781 struct elf_link_hash_entry *dir,
3782 struct elf_link_hash_entry *ind)
1c0d3aa6
NC
3783{
3784 struct score_elf_link_hash_entry *dirscore, *indscore;
3785
3786 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
3787
3788 if (ind->root.type != bfd_link_hash_indirect)
3789 return;
3790
3791 dirscore = (struct score_elf_link_hash_entry *) dir;
3792 indscore = (struct score_elf_link_hash_entry *) ind;
3793 dirscore->possibly_dynamic_relocs += indscore->possibly_dynamic_relocs;
3794
3795 if (indscore->readonly_reloc)
3796 dirscore->readonly_reloc = TRUE;
3797
3798 if (indscore->no_fn_stub)
3799 dirscore->no_fn_stub = TRUE;
3800}
3801
3802/* Remove information about discarded functions from other sections which mention them. */
1c0d3aa6 3803static bfd_boolean
c3b7224a 3804s3_bfd_score_elf_discard_info (bfd *abfd, struct elf_reloc_cookie *cookie,
07d6d2b8 3805 struct bfd_link_info *info)
1c0d3aa6
NC
3806{
3807 asection *o;
3808 bfd_boolean ret = FALSE;
3809 unsigned char *tdata;
3810 size_t i, skip;
3811
3812 o = bfd_get_section_by_name (abfd, ".pdr");
3813 if ((!o) || (o->size == 0) || (o->size % PDR_SIZE != 0)
3814 || (o->output_section != NULL && bfd_is_abs_section (o->output_section)))
3815 return FALSE;
3816
3817 tdata = bfd_zmalloc (o->size / PDR_SIZE);
3818 if (!tdata)
3819 return FALSE;
3820
3821 cookie->rels = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL, info->keep_memory);
3822 if (!cookie->rels)
3823 {
3824 free (tdata);
3825 return FALSE;
3826 }
3827
3828 cookie->rel = cookie->rels;
3829 cookie->relend = cookie->rels + o->reloc_count;
3830
3831 for (i = 0, skip = 0; i < o->size; i++)
3832 {
3833 if (bfd_elf_reloc_symbol_deleted_p (i * PDR_SIZE, cookie))
07d6d2b8
AM
3834 {
3835 tdata[i] = 1;
3836 skip++;
3837 }
1c0d3aa6
NC
3838 }
3839
3840 if (skip != 0)
3841 {
3842 score_elf_section_data (o)->u.tdata = tdata;
3843 o->size -= skip * PDR_SIZE;
3844 ret = TRUE;
3845 }
3846 else
3847 free (tdata);
3848
3849 if (!info->keep_memory)
3850 free (cookie->rels);
3851
3852 return ret;
3853}
3854
3855/* Signal that discard_info() has removed the discarded relocations for this section. */
1c0d3aa6 3856static bfd_boolean
c3b7224a 3857s3_bfd_score_elf_ignore_discarded_relocs (asection *sec)
1c0d3aa6
NC
3858{
3859 if (strcmp (sec->name, ".pdr") == 0)
3860 return TRUE;
3861 return FALSE;
3862}
3863
07adf181
AM
3864/* Return the section that should be marked against GC for a given
3865 relocation. */
1c0d3aa6 3866static asection *
c3b7224a 3867s3_bfd_score_elf_gc_mark_hook (asection *sec,
07d6d2b8
AM
3868 struct bfd_link_info *info,
3869 Elf_Internal_Rela *rel,
3870 struct elf_link_hash_entry *h,
3871 Elf_Internal_Sym *sym)
1c0d3aa6
NC
3872{
3873 if (h != NULL)
07adf181
AM
3874 switch (ELF32_R_TYPE (rel->r_info))
3875 {
3876 case R_SCORE_GNU_VTINHERIT:
3877 case R_SCORE_GNU_VTENTRY:
07d6d2b8 3878 return NULL;
07adf181 3879 }
1c0d3aa6 3880
07adf181 3881 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1c0d3aa6
NC
3882}
3883
3884/* Support for core dump NOTE sections. */
3885
3886static bfd_boolean
c3b7224a 3887s3_bfd_score_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
1c0d3aa6
NC
3888{
3889 int offset;
3890 unsigned int raw_size;
3891
3892 switch (note->descsz)
3893 {
3894 default:
3895 return FALSE;
3896
07d6d2b8 3897 case 148: /* Linux/Score 32-bit. */
1c0d3aa6 3898 /* pr_cursig */
228e534f
AM
3899 elf_tdata (abfd)->core->signal
3900 = score_bfd_get_16 (abfd, note->descdata + 12);
1c0d3aa6
NC
3901
3902 /* pr_pid */
228e534f
AM
3903 elf_tdata (abfd)->core->lwpid
3904 = score_bfd_get_32 (abfd, note->descdata + 24);
1c0d3aa6
NC
3905
3906 /* pr_reg */
3907 offset = 72;
3908 raw_size = 72;
3909
3910 break;
3911 }
3912
3913 /* Make a ".reg/999" section. */
228e534f
AM
3914 return _bfd_elfcore_make_pseudosection (abfd, ".reg", raw_size,
3915 note->descpos + offset);
1c0d3aa6
NC
3916}
3917
3918static bfd_boolean
c3b7224a 3919s3_bfd_score_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
1c0d3aa6
NC
3920{
3921 switch (note->descsz)
3922 {
3923 default:
3924 return FALSE;
3925
07d6d2b8 3926 case 124: /* Linux/Score elf_prpsinfo. */
228e534f
AM
3927 elf_tdata (abfd)->core->program
3928 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
3929 elf_tdata (abfd)->core->command
3930 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
1c0d3aa6
NC
3931 }
3932
3933 /* Note that for some reason, a spurious space is tacked
3934 onto the end of the args in some (at least one anyway)
3935 implementations, so strip it off if it exists. */
3936
3937 {
228e534f 3938 char *command = elf_tdata (abfd)->core->command;
1c0d3aa6
NC
3939 int n = strlen (command);
3940
3941 if (0 < n && command[n - 1] == ' ')
3942 command[n - 1] = '\0';
3943 }
3944
3945 return TRUE;
3946}
3947
3948
3949/* Score BFD functions. */
1c0d3aa6 3950static reloc_howto_type *
c3b7224a 3951s3_elf32_score_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED, bfd_reloc_code_real_type code)
1c0d3aa6
NC
3952{
3953 unsigned int i;
3954
c3b7224a 3955 for (i = 0; i < ARRAY_SIZE (elf32_score_reloc_map); i++)
1c0d3aa6
NC
3956 if (elf32_score_reloc_map[i].bfd_reloc_val == code)
3957 return &elf32_score_howto_table[elf32_score_reloc_map[i].elf_reloc_val];
3958
3959 return NULL;
3960}
3961
157090f7
AM
3962static reloc_howto_type *
3963elf32_score_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
07d6d2b8 3964 const char *r_name)
157090f7
AM
3965{
3966 unsigned int i;
3967
3968 for (i = 0;
3969 i < (sizeof (elf32_score_howto_table)
07d6d2b8 3970 / sizeof (elf32_score_howto_table[0]));
157090f7
AM
3971 i++)
3972 if (elf32_score_howto_table[i].name != NULL
07d6d2b8 3973 && strcasecmp (elf32_score_howto_table[i].name, r_name) == 0)
157090f7
AM
3974 return &elf32_score_howto_table[i];
3975
3976 return NULL;
3977}
3978
1c0d3aa6 3979static bfd_boolean
c3b7224a 3980s3_elf32_score_print_private_bfd_data (bfd *abfd, void * ptr)
1c0d3aa6
NC
3981{
3982 FILE *file = (FILE *) ptr;
3983
3984 BFD_ASSERT (abfd != NULL && ptr != NULL);
3985
3986 /* Print normal ELF private data. */
3987 _bfd_elf_print_private_bfd_data (abfd, ptr);
3988
3989 /* xgettext:c-format */
3990 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
3991 if (elf_elfheader (abfd)->e_flags & EF_SCORE_PIC)
3992 {
3993 fprintf (file, _(" [pic]"));
3994 }
3995 if (elf_elfheader (abfd)->e_flags & EF_SCORE_FIXDEP)
3996 {
3997 fprintf (file, _(" [fix dep]"));
3998 }
3999 fputc ('\n', file);
4000
4001 return TRUE;
4002}
4003
4004static bfd_boolean
50e03d47 4005s3_elf32_score_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
1c0d3aa6 4006{
50e03d47 4007 bfd *obfd = info->output_bfd;
1c0d3aa6
NC
4008 flagword in_flags;
4009 flagword out_flags;
4010
50e03d47 4011 if (!_bfd_generic_verify_endian_match (ibfd, info))
1c0d3aa6
NC
4012 return FALSE;
4013
6b728d32
AM
4014 /* FIXME: What should be checked when linking shared libraries? */
4015 if ((ibfd->flags & DYNAMIC) != 0)
4016 return TRUE;
4017
1c0d3aa6
NC
4018 in_flags = elf_elfheader (ibfd)->e_flags;
4019 out_flags = elf_elfheader (obfd)->e_flags;
4020
4021 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4022 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4023 return TRUE;
4024
4025 in_flags = elf_elfheader (ibfd)->e_flags;
4026 out_flags = elf_elfheader (obfd)->e_flags;
4027
4028 if (! elf_flags_init (obfd))
4029 {
4030 elf_flags_init (obfd) = TRUE;
4031 elf_elfheader (obfd)->e_flags = in_flags;
4032
4033 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
07d6d2b8
AM
4034 && bfd_get_arch_info (obfd)->the_default)
4035 {
4036 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
4037 }
1c0d3aa6
NC
4038
4039 return TRUE;
4040 }
4041
4042 if (((in_flags & EF_SCORE_PIC) != 0) != ((out_flags & EF_SCORE_PIC) != 0))
4eca0228 4043 _bfd_error_handler
871b3ab2 4044 (_("%pB: warning: linking PIC files with non-PIC files"), ibfd);
1c0d3aa6
NC
4045
4046 /* FIXME: Maybe dependency fix compatibility should be checked here. */
4047
4048 return TRUE;
4049}
4050
4051static bfd_boolean
c3b7224a 4052s3_elf32_score_new_section_hook (bfd *abfd, asection *sec)
1c0d3aa6
NC
4053{
4054 struct _score_elf_section_data *sdata;
986f0783 4055 size_t amt = sizeof (*sdata);
1c0d3aa6
NC
4056
4057 sdata = bfd_zalloc (abfd, amt);
4058 if (sdata == NULL)
4059 return FALSE;
4060 sec->used_by_bfd = sdata;
4061
4062 return _bfd_elf_new_section_hook (abfd, sec);
4063}
4064
c3b7224a
NC
4065/*****************************************************************************/
4066
4067/* s3_s7: backend hooks. */
f3185997 4068static bfd_boolean
c3b7224a 4069_bfd_score_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
07d6d2b8
AM
4070 arelent *bfd_reloc,
4071 Elf_Internal_Rela *elf_reloc)
c3b7224a
NC
4072{
4073 if (bfd_get_mach (abfd) == bfd_mach_score3)
4074 return s3_bfd_score_info_to_howto (abfd, bfd_reloc, elf_reloc);
4075 else
4076 return s7_bfd_score_info_to_howto (abfd, bfd_reloc, elf_reloc);
4077}
4078
4079static bfd_boolean
4080_bfd_score_elf_relocate_section (bfd *output_bfd,
07d6d2b8
AM
4081 struct bfd_link_info *info,
4082 bfd *input_bfd,
4083 asection *input_section,
4084 bfd_byte *contents,
4085 Elf_Internal_Rela *relocs,
4086 Elf_Internal_Sym *local_syms,
4087 asection **local_sections)
c3b7224a
NC
4088{
4089 if (bfd_get_mach (output_bfd) == bfd_mach_score3)
4090 return s3_bfd_score_elf_relocate_section (output_bfd,
07d6d2b8
AM
4091 info, input_bfd, input_section, contents, relocs,
4092 local_syms, local_sections);
c3b7224a
NC
4093 else
4094 return s7_bfd_score_elf_relocate_section (output_bfd,
07d6d2b8
AM
4095 info, input_bfd, input_section, contents, relocs,
4096 local_syms, local_sections);
c3b7224a
NC
4097}
4098
4099static bfd_boolean
4100_bfd_score_elf_check_relocs (bfd *abfd,
07d6d2b8
AM
4101 struct bfd_link_info *info,
4102 asection *sec,
4103 const Elf_Internal_Rela *relocs)
c3b7224a
NC
4104{
4105 if (bfd_get_mach (abfd) == bfd_mach_score3)
4106 return s3_bfd_score_elf_check_relocs (abfd, info, sec, relocs);
4107 else
4108 return s7_bfd_score_elf_check_relocs (abfd, info, sec, relocs);
4109}
4110
4111static bfd_boolean
4112_bfd_score_elf_add_symbol_hook (bfd *abfd,
07d6d2b8
AM
4113 struct bfd_link_info *info ATTRIBUTE_UNUSED,
4114 Elf_Internal_Sym *sym,
4115 const char **namep ATTRIBUTE_UNUSED,
4116 flagword *flagsp ATTRIBUTE_UNUSED,
4117 asection **secp,
4118 bfd_vma *valp)
c3b7224a
NC
4119{
4120 if (bfd_get_mach (abfd) == bfd_mach_score3)
4121 return s3_bfd_score_elf_add_symbol_hook (abfd, info, sym, namep, flagsp,
07d6d2b8 4122 secp, valp);
c3b7224a
NC
4123 else
4124 return s7_bfd_score_elf_add_symbol_hook (abfd, info, sym, namep, flagsp,
07d6d2b8 4125 secp, valp);
c3b7224a
NC
4126}
4127
4128static void
4129_bfd_score_elf_symbol_processing (bfd *abfd, asymbol *asym)
4130{
4131 if (bfd_get_mach (abfd) == bfd_mach_score3)
4132 return s3_bfd_score_elf_symbol_processing (abfd, asym);
4133 else
4134 return s7_bfd_score_elf_symbol_processing (abfd, asym);
4135}
4136
6e0b88f1 4137static int
c3b7224a
NC
4138_bfd_score_elf_link_output_symbol_hook (struct bfd_link_info *info ATTRIBUTE_UNUSED,
4139 const char *name ATTRIBUTE_UNUSED,
4140 Elf_Internal_Sym *sym,
4141 asection *input_sec,
4142 struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
4143{
4144 /* If link a empty .o, then this filed is NULL. */
4145 if (info->input_bfds == NULL)
4146 {
4147 /* If we see a common symbol, which implies a relocatable link, then
07d6d2b8
AM
4148 if a symbol was small common in an input file, mark it as small
4149 common in the output file. */
c3b7224a 4150 if (sym->st_shndx == SHN_COMMON && strcmp (input_sec->name, ".scommon") == 0)
07d6d2b8 4151 sym->st_shndx = SHN_SCORE_SCOMMON;
6e0b88f1 4152 return 1;
c3b7224a
NC
4153 }
4154
4155 if (bfd_get_mach (info->input_bfds) == bfd_mach_score3)
4156 return s3_bfd_score_elf_link_output_symbol_hook (info, name, sym, input_sec, h);
4157 else
4158 return s7_bfd_score_elf_link_output_symbol_hook (info, name, sym, input_sec, h);
4159}
4160
4161static bfd_boolean
4162_bfd_score_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
07d6d2b8
AM
4163 asection *sec,
4164 int *retval)
c3b7224a
NC
4165{
4166 if (bfd_get_mach (abfd) == bfd_mach_score3)
4167 return s3_bfd_score_elf_section_from_bfd_section (abfd, sec, retval);
4168 else
4169 return s7_bfd_score_elf_section_from_bfd_section (abfd, sec, retval);
4170}
4171
4172static bfd_boolean
4173_bfd_score_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
07d6d2b8 4174 struct elf_link_hash_entry *h)
c3b7224a
NC
4175{
4176 if (bfd_get_mach (info->input_bfds) == bfd_mach_score3)
4177 return s3_bfd_score_elf_adjust_dynamic_symbol (info, h);
4178 else
4179 return s7_bfd_score_elf_adjust_dynamic_symbol (info, h);
4180}
4181
4182static bfd_boolean
4183_bfd_score_elf_always_size_sections (bfd *output_bfd,
07d6d2b8 4184 struct bfd_link_info *info)
c3b7224a
NC
4185{
4186 if (bfd_get_mach (output_bfd) == bfd_mach_score3)
4187 return s3_bfd_score_elf_always_size_sections (output_bfd, info);
4188 else
4189 return s7_bfd_score_elf_always_size_sections (output_bfd, info);
4190}
4191
4192static bfd_boolean
4193_bfd_score_elf_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
4194{
4195 if (bfd_get_mach (output_bfd) == bfd_mach_score3)
4196 return s3_bfd_score_elf_size_dynamic_sections (output_bfd, info);
4197 else
4198 return s7_bfd_score_elf_size_dynamic_sections (output_bfd, info);
4199}
4200
4201static bfd_boolean
4202_bfd_score_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
4203{
4204 if (bfd_get_mach (abfd) == bfd_mach_score3)
4205 return s3_bfd_score_elf_create_dynamic_sections (abfd, info);
4206 else
4207 return s7_bfd_score_elf_create_dynamic_sections (abfd, info);
4208}
4209
4210static bfd_boolean
4211_bfd_score_elf_finish_dynamic_symbol (bfd *output_bfd,
07d6d2b8
AM
4212 struct bfd_link_info *info,
4213 struct elf_link_hash_entry *h,
4214 Elf_Internal_Sym *sym)
c3b7224a
NC
4215{
4216 if (bfd_get_mach (output_bfd) == bfd_mach_score3)
4217 return s3_bfd_score_elf_finish_dynamic_symbol (output_bfd, info, h, sym);
4218 else
4219 return s7_bfd_score_elf_finish_dynamic_symbol (output_bfd, info, h, sym);
4220}
4221
4222static bfd_boolean
4223_bfd_score_elf_finish_dynamic_sections (bfd *output_bfd,
07d6d2b8 4224 struct bfd_link_info *info)
c3b7224a
NC
4225{
4226 if (bfd_get_mach (output_bfd) == bfd_mach_score3)
4227 return s3_bfd_score_elf_finish_dynamic_sections (output_bfd, info);
4228 else
4229 return s7_bfd_score_elf_finish_dynamic_sections (output_bfd, info);
4230}
4231
4232static bfd_boolean
4233_bfd_score_elf_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
07d6d2b8
AM
4234 Elf_Internal_Shdr *hdr,
4235 asection *sec)
c3b7224a
NC
4236{
4237 if (bfd_get_mach (abfd) == bfd_mach_score3)
4238 return s3_bfd_score_elf_fake_sections (abfd, hdr, sec);
4239 else
4240 return s7_bfd_score_elf_fake_sections (abfd, hdr, sec);
4241}
4242
4243static bfd_boolean
4244_bfd_score_elf_section_processing (bfd *abfd ATTRIBUTE_UNUSED, Elf_Internal_Shdr *hdr)
4245{
4246 if (bfd_get_mach (abfd) == bfd_mach_score3)
4247 return s3_bfd_score_elf_section_processing (abfd, hdr);
4248 else
4249 return s7_bfd_score_elf_section_processing (abfd, hdr);
4250}
4251
4252static bfd_boolean
4253_bfd_score_elf_write_section (bfd *output_bfd,
07d6d2b8
AM
4254 struct bfd_link_info *link_info ATTRIBUTE_UNUSED,
4255 asection *sec, bfd_byte *contents)
c3b7224a
NC
4256{
4257 if (bfd_get_mach (output_bfd) == bfd_mach_score3)
4258 return s3_bfd_score_elf_write_section (output_bfd, sec, contents);
4259 else
4260 return s7_bfd_score_elf_write_section (output_bfd, sec, contents);
4261}
4262
4263static void
4264_bfd_score_elf_copy_indirect_symbol (struct bfd_link_info *info,
07d6d2b8
AM
4265 struct elf_link_hash_entry *dir,
4266 struct elf_link_hash_entry *ind)
c3b7224a
NC
4267{
4268 if (bfd_get_mach (info->input_bfds) == bfd_mach_score3)
4269 return s3_bfd_score_elf_copy_indirect_symbol (info, dir, ind);
4270 else
4271 return s7_bfd_score_elf_copy_indirect_symbol (info, dir, ind);
4272}
4273
4274static void
4275_bfd_score_elf_hide_symbol (struct bfd_link_info *info,
07d6d2b8
AM
4276 struct elf_link_hash_entry *entry,
4277 bfd_boolean force_local)
c3b7224a
NC
4278{
4279 if (bfd_get_mach (info->input_bfds) == bfd_mach_score3)
4280 return s3_bfd_score_elf_hide_symbol (info, entry, force_local);
4281 else
4282 return s7_bfd_score_elf_hide_symbol (info, entry, force_local);
4283}
4284
4285static bfd_boolean
4286_bfd_score_elf_discard_info (bfd *abfd, struct elf_reloc_cookie *cookie,
07d6d2b8 4287 struct bfd_link_info *info)
c3b7224a
NC
4288{
4289 if (bfd_get_mach (abfd) == bfd_mach_score3)
4290 return s3_bfd_score_elf_discard_info (abfd, cookie, info);
4291 else
4292 return s7_bfd_score_elf_discard_info (abfd, cookie, info);
4293}
4294
4295static bfd_boolean
4296_bfd_score_elf_ignore_discarded_relocs (asection *sec)
4297{
4298 if (bfd_get_mach (sec->owner) == bfd_mach_score3)
4299 return s3_bfd_score_elf_ignore_discarded_relocs (sec);
4300 else
4301 return s7_bfd_score_elf_ignore_discarded_relocs (sec);
4302}
4303
4304static asection *
4305_bfd_score_elf_gc_mark_hook (asection *sec,
07d6d2b8
AM
4306 struct bfd_link_info *info,
4307 Elf_Internal_Rela *rel,
4308 struct elf_link_hash_entry *h,
4309 Elf_Internal_Sym *sym)
c3b7224a
NC
4310{
4311 if (bfd_get_mach (info->input_bfds) == bfd_mach_score3)
4312 return s3_bfd_score_elf_gc_mark_hook (sec, info, rel, h, sym);
4313 else
4314 return s7_bfd_score_elf_gc_mark_hook (sec, info, rel, h, sym);
4315}
4316
4317static bfd_boolean
4318_bfd_score_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
4319{
4320 if (bfd_get_mach (abfd) == bfd_mach_score3)
4321 return s3_bfd_score_elf_grok_prstatus (abfd, note);
4322 else
4323 return s7_bfd_score_elf_grok_prstatus (abfd, note);
4324}
4325
4326static bfd_boolean
4327_bfd_score_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
4328{
4329 if (bfd_get_mach (abfd) == bfd_mach_score3)
4330 return s3_bfd_score_elf_grok_psinfo (abfd, note);
4331 else
4332 return s7_bfd_score_elf_grok_psinfo (abfd, note);
4333}
4334
4335static reloc_howto_type *
4336elf32_score_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED, bfd_reloc_code_real_type code)
4337{
4338 /* s3: NOTE!!!
4339 gas will call elf32_score_reloc_type_lookup, and don't write elf file.
4340 So just using score3, but we don't know ld will call this or not.
4341 If so, this way can't work. */
4342
4343 if (score3)
4344 return s3_elf32_score_reloc_type_lookup (abfd, code);
4345 else
4346 return s7_elf32_score_reloc_type_lookup (abfd, code);
4347}
4348
4dfe6ac6
NC
4349/* Create a score elf linker hash table.
4350 This is a copy of _bfd_elf_link_hash_table_create() except with a
4351 different hash table entry creation function. */
4352
c3b7224a
NC
4353static struct bfd_link_hash_table *
4354elf32_score_link_hash_table_create (bfd *abfd)
4355{
4dfe6ac6 4356 struct elf_link_hash_table *ret;
986f0783 4357 size_t amt = sizeof (struct elf_link_hash_table);
4dfe6ac6 4358
7bf52ea2 4359 ret = (struct elf_link_hash_table *) bfd_zmalloc (amt);
4dfe6ac6
NC
4360 if (ret == NULL)
4361 return NULL;
4362
4363 if (!_bfd_elf_link_hash_table_init (ret, abfd, score_elf_link_hash_newfunc,
07d6d2b8 4364 sizeof (struct score_elf_link_hash_entry),
4dfe6ac6
NC
4365 GENERIC_ELF_DATA))
4366 {
4367 free (ret);
4368 return NULL;
4369 }
4370
4371 return &ret->root;
c3b7224a
NC
4372}
4373
4374static bfd_boolean
4375elf32_score_print_private_bfd_data (bfd *abfd, void * ptr)
4376{
4377 if (bfd_get_mach (abfd) == bfd_mach_score3)
4378 return s3_elf32_score_print_private_bfd_data (abfd, ptr);
4379 else
4380 return s7_elf32_score_print_private_bfd_data (abfd, ptr);
4381}
4382
4383static bfd_boolean
50e03d47 4384elf32_score_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
c3b7224a 4385{
50e03d47
AM
4386 if (bfd_get_mach (info->output_bfd) == bfd_mach_score3)
4387 return s3_elf32_score_merge_private_bfd_data (ibfd, info);
c3b7224a 4388 else
50e03d47 4389 return s7_elf32_score_merge_private_bfd_data (ibfd, info);
c3b7224a
NC
4390}
4391
4392static bfd_boolean
4393elf32_score_new_section_hook (bfd *abfd, asection *sec)
4394{
4395 if (bfd_get_mach (abfd) == bfd_mach_score3)
4396 return s3_elf32_score_new_section_hook (abfd, sec);
4397 else
4398 return s7_elf32_score_new_section_hook (abfd, sec);
4399}
4400
4401
4402/* s3_s7: don't need to split. */
4403
4404/* Set the right machine number. */
4405static bfd_boolean
4406_bfd_score_elf_score_object_p (bfd * abfd)
4407{
4408 int e_set = bfd_mach_score7;
4409
4410 if (elf_elfheader (abfd)->e_machine == EM_SCORE)
4411 {
4412 int e_mach = elf_elfheader (abfd)->e_flags & EF_SCORE_MACH & EF_OMIT_PIC_FIXDD;
4413 switch (e_mach)
07d6d2b8
AM
4414 {
4415 /* Set default target is score7. */
4416 default:
4417 case E_SCORE_MACH_SCORE7:
4418 e_set = bfd_mach_score7;
4419 break;
4420
4421 case E_SCORE_MACH_SCORE3:
4422 e_set = bfd_mach_score3;
4423 break;
4424 }
c3b7224a
NC
4425 }
4426
4427 return bfd_default_set_arch_mach (abfd, bfd_arch_score, e_set);
4428}
4429
4430bfd_boolean
4431_bfd_score_elf_common_definition (Elf_Internal_Sym *sym)
4432{
4433 return (sym->st_shndx == SHN_COMMON || sym->st_shndx == SHN_SCORE_SCOMMON);
4434}
4435
4436/*****************************************************************************/
4437
1c0d3aa6 4438
07d6d2b8
AM
4439#define USE_REL 1
4440#define TARGET_LITTLE_SYM score_elf32_le_vec
4441#define TARGET_LITTLE_NAME "elf32-littlescore"
4442#define TARGET_BIG_SYM score_elf32_be_vec
4443#define TARGET_BIG_NAME "elf32-bigscore"
4444#define ELF_ARCH bfd_arch_score
4445#define ELF_MACHINE_CODE EM_SCORE
4446#define ELF_MACHINE_ALT1 EM_SCORE_OLD
4447#define ELF_MAXPAGESIZE 0x8000
4448
f3185997 4449#define elf_info_to_howto NULL
07d6d2b8
AM
4450#define elf_info_to_howto_rel _bfd_score_info_to_howto
4451#define elf_backend_relocate_section _bfd_score_elf_relocate_section
4452#define elf_backend_check_relocs _bfd_score_elf_check_relocs
4453#define elf_backend_add_symbol_hook _bfd_score_elf_add_symbol_hook
4454#define elf_backend_symbol_processing _bfd_score_elf_symbol_processing
9838404f
AM
4455#define elf_backend_link_output_symbol_hook \
4456 _bfd_score_elf_link_output_symbol_hook
4457#define elf_backend_section_from_bfd_section \
4458 _bfd_score_elf_section_from_bfd_section
4459#define elf_backend_adjust_dynamic_symbol \
4460 _bfd_score_elf_adjust_dynamic_symbol
4461#define elf_backend_always_size_sections \
4462 _bfd_score_elf_always_size_sections
4463#define elf_backend_size_dynamic_sections \
4464 _bfd_score_elf_size_dynamic_sections
d00dd7dc 4465#define elf_backend_omit_section_dynsym _bfd_elf_omit_section_dynsym_all
9838404f
AM
4466#define elf_backend_create_dynamic_sections \
4467 _bfd_score_elf_create_dynamic_sections
4468#define elf_backend_finish_dynamic_symbol \
4469 _bfd_score_elf_finish_dynamic_symbol
4470#define elf_backend_finish_dynamic_sections \
4471 _bfd_score_elf_finish_dynamic_sections
07d6d2b8
AM
4472#define elf_backend_fake_sections _bfd_score_elf_fake_sections
4473#define elf_backend_section_processing _bfd_score_elf_section_processing
4474#define elf_backend_write_section _bfd_score_elf_write_section
9838404f 4475#define elf_backend_copy_indirect_symbol _bfd_score_elf_copy_indirect_symbol
07d6d2b8
AM
4476#define elf_backend_hide_symbol _bfd_score_elf_hide_symbol
4477#define elf_backend_discard_info _bfd_score_elf_discard_info
9838404f
AM
4478#define elf_backend_ignore_discarded_relocs \
4479 _bfd_score_elf_ignore_discarded_relocs
07d6d2b8
AM
4480#define elf_backend_gc_mark_hook _bfd_score_elf_gc_mark_hook
4481#define elf_backend_grok_prstatus _bfd_score_elf_grok_prstatus
4482#define elf_backend_grok_psinfo _bfd_score_elf_grok_psinfo
4483#define elf_backend_can_gc_sections 1
4484#define elf_backend_want_plt_sym 0
4485#define elf_backend_got_header_size (4 * SCORE_RESERVED_GOTNO)
4486#define elf_backend_plt_header_size 0
4487#define elf_backend_collect TRUE
4488#define elf_backend_type_change_ok TRUE
4489#define elf_backend_object_p _bfd_score_elf_score_object_p
4490
4491#define bfd_elf32_bfd_reloc_type_lookup elf32_score_reloc_type_lookup
157090f7
AM
4492#define bfd_elf32_bfd_reloc_name_lookup \
4493 elf32_score_reloc_name_lookup
9838404f
AM
4494#define bfd_elf32_bfd_link_hash_table_create elf32_score_link_hash_table_create
4495#define bfd_elf32_bfd_print_private_bfd_data elf32_score_print_private_bfd_data
4496#define bfd_elf32_bfd_merge_private_bfd_data elf32_score_merge_private_bfd_data
07d6d2b8 4497#define bfd_elf32_new_section_hook elf32_score_new_section_hook
1c0d3aa6
NC
4498
4499#include "elf32-target.h"
This page took 1.931596 seconds and 4 git commands to generate.