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