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