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