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