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