1 /* 32-bit ELF support for S+core.
2    Copyright (C) 2006-2020 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   bfd_uint64_t v;
231 
232   v = (bfd_uint64_t) addr[4];
233   v |= (bfd_uint64_t) addr[5] << 8;
234   v |= (bfd_uint64_t) addr[2] << 16;
235   v |= (bfd_uint64_t) addr[3] << 24;
236   v |= (bfd_uint64_t) addr[0] << 32;
237   v |= (bfd_uint64_t) addr[1] << 40;
238   return v;
239 }
240 
241 static bfd_vma
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_asymbol_section (symbol))
600       || bfd_is_com_section (bfd_asymbol_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 (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   size_t amt;
1414 
1415   /* This function may be called more than once.  */
1416   s = score_elf_got_section (abfd, TRUE);
1417   if (s)
1418     {
1419       if (! maybe_exclude)
1420 	s->flags &= ~SEC_EXCLUDE;
1421       return TRUE;
1422     }
1423 
1424   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED);
1425 
1426   if (maybe_exclude)
1427     flags |= SEC_EXCLUDE;
1428 
1429   /* We have to use an alignment of 2**4 here because this is hardcoded
1430      in the function stub generation and in the linker script.  */
1431   s = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
1432   elf_hash_table (info)->sgot = s;
1433   if (s == NULL
1434       || !bfd_set_section_alignment (s, 4))
1435     return FALSE;
1436 
1437   /* Define the symbol _GLOBAL_OFFSET_TABLE_.  We don't do this in the
1438      linker script because we don't want to define the symbol if we
1439      are not creating a global offset table.  */
1440   bh = NULL;
1441   if (! (_bfd_generic_link_add_one_symbol
1442 	 (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL, s,
1443 	  0, NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
1444     return FALSE;
1445 
1446   h = (struct elf_link_hash_entry *) bh;
1447   h->non_elf = 0;
1448   h->def_regular = 1;
1449   h->type = STT_OBJECT;
1450   elf_hash_table (info)->hgot = h;
1451 
1452   if (bfd_link_pic (info) && ! bfd_elf_link_record_dynamic_symbol (info, h))
1453     return FALSE;
1454 
1455   amt = sizeof (struct score_got_info);
1456   g = bfd_alloc (abfd, amt);
1457   if (g == NULL)
1458     return FALSE;
1459 
1460   g->global_gotsym = NULL;
1461   g->global_gotno = 0;
1462 
1463   g->local_gotno = SCORE_RESERVED_GOTNO;
1464   g->assigned_gotno = SCORE_RESERVED_GOTNO;
1465   g->next = NULL;
1466 
1467   g->got_entries = htab_try_create (1, score_elf_got_entry_hash,
1468 				    score_elf_got_entry_eq, NULL);
1469   if (g->got_entries == NULL)
1470     return FALSE;
1471   score_elf_section_data (s)->u.got_info = g;
1472   score_elf_section_data (s)->elf.this_hdr.sh_flags |= SHF_ALLOC | SHF_WRITE | SHF_SCORE_GPREL;
1473 
1474   return TRUE;
1475 }
1476 
1477 /* Calculate the %high function.  */
1478 static bfd_vma
score_elf_high(bfd_vma value)1479 score_elf_high (bfd_vma value)
1480 {
1481   return ((value + (bfd_vma) 0x8000) >> 16) & 0xffff;
1482 }
1483 
1484 /* Create a local GOT entry for VALUE.  Return the index of the entry,
1485    or -1 if it could not be created.  */
1486 static struct score_got_entry *
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)1487 score_elf_create_local_got_entry (bfd *abfd,
1488 				  bfd *ibfd ATTRIBUTE_UNUSED,
1489 				  struct score_got_info *gg,
1490 				  asection *sgot, bfd_vma value,
1491 				  unsigned long r_symndx ATTRIBUTE_UNUSED,
1492 				  struct score_elf_link_hash_entry *h ATTRIBUTE_UNUSED,
1493 				  int r_type ATTRIBUTE_UNUSED)
1494 {
1495   struct score_got_entry entry, **loc;
1496   struct score_got_info *g;
1497 
1498   entry.abfd = NULL;
1499   entry.symndx = -1;
1500   entry.d.address = value;
1501 
1502   g = gg;
1503   loc = (struct score_got_entry **) htab_find_slot (g->got_entries, &entry, INSERT);
1504   if (*loc)
1505     return *loc;
1506 
1507   entry.gotidx = SCORE_ELF_GOT_SIZE (abfd) * g->assigned_gotno++;
1508 
1509   *loc = bfd_alloc (abfd, sizeof entry);
1510 
1511   if (! *loc)
1512     return NULL;
1513 
1514   memcpy (*loc, &entry, sizeof entry);
1515 
1516   if (g->assigned_gotno >= g->local_gotno)
1517     {
1518       (*loc)->gotidx = -1;
1519       /* We didn't allocate enough space in the GOT.  */
1520       _bfd_error_handler
1521 	(_("not enough GOT space for local GOT entries"));
1522       bfd_set_error (bfd_error_bad_value);
1523       return NULL;
1524     }
1525 
1526   score_bfd_put_32 (abfd, value, (sgot->contents + entry.gotidx));
1527 
1528   return *loc;
1529 }
1530 
1531 /* Find a GOT entry whose higher-order 16 bits are the same as those
1532    for value.  Return the index into the GOT for this entry.  */
1533 static bfd_vma
score_elf_got16_entry(bfd * abfd,bfd * ibfd,struct bfd_link_info * info,bfd_vma value,bfd_boolean external)1534 score_elf_got16_entry (bfd *abfd, bfd *ibfd, struct bfd_link_info *info,
1535 		       bfd_vma value, bfd_boolean external)
1536 {
1537   asection *sgot;
1538   struct score_got_info *g;
1539   struct score_got_entry *entry;
1540 
1541   if (!external)
1542     {
1543       /* Although the ABI says that it is "the high-order 16 bits" that we
1544 	 want, it is really the %high value.  The complete value is
1545 	 calculated with a `addiu' of a LO16 relocation, just as with a
1546 	 HI16/LO16 pair.  */
1547       value = score_elf_high (value) << 16;
1548     }
1549 
1550   g = score_elf_got_info (elf_hash_table (info)->dynobj, &sgot);
1551 
1552   entry = score_elf_create_local_got_entry (abfd, ibfd, g, sgot, value, 0, NULL,
1553 					    R_SCORE_GOT15);
1554   if (entry)
1555     return entry->gotidx;
1556   else
1557     return MINUS_ONE;
1558 }
1559 
1560 static void
s3_bfd_score_elf_hide_symbol(struct bfd_link_info * info,struct elf_link_hash_entry * entry,bfd_boolean force_local)1561 s3_bfd_score_elf_hide_symbol (struct bfd_link_info *info,
1562 			      struct elf_link_hash_entry *entry,
1563 			      bfd_boolean force_local)
1564 {
1565   bfd *dynobj;
1566   asection *got;
1567   struct score_got_info *g;
1568   struct score_elf_link_hash_entry *h;
1569 
1570   h = (struct score_elf_link_hash_entry *) entry;
1571   if (h->forced_local)
1572     return;
1573   h->forced_local = TRUE;
1574 
1575   dynobj = elf_hash_table (info)->dynobj;
1576   if (dynobj != NULL && force_local)
1577     {
1578       got = score_elf_got_section (dynobj, FALSE);
1579       if (got == NULL)
1580 	return;
1581       g = score_elf_section_data (got)->u.got_info;
1582 
1583       if (g->next)
1584 	{
1585 	  struct score_got_entry e;
1586 	  struct score_got_info *gg = g;
1587 
1588 	  /* Since we're turning what used to be a global symbol into a
1589 	     local one, bump up the number of local entries of each GOT
1590 	     that had an entry for it.  This will automatically decrease
1591 	     the number of global entries, since global_gotno is actually
1592 	     the upper limit of global entries.  */
1593 	  e.abfd = dynobj;
1594 	  e.symndx = -1;
1595 	  e.d.h = h;
1596 
1597 	  for (g = g->next; g != gg; g = g->next)
1598 	    if (htab_find (g->got_entries, &e))
1599 	      {
1600 		BFD_ASSERT (g->global_gotno > 0);
1601 		g->local_gotno++;
1602 		g->global_gotno--;
1603 	      }
1604 
1605 	  /* If this was a global symbol forced into the primary GOT, we
1606 	     no longer need an entry for it.  We can't release the entry
1607 	     at this point, but we must at least stop counting it as one
1608 	     of the symbols that required a forced got entry.  */
1609 	  if (h->root.got.offset == 2)
1610 	    {
1611 	      BFD_ASSERT (gg->assigned_gotno > 0);
1612 	      gg->assigned_gotno--;
1613 	    }
1614 	}
1615       else if (g->global_gotno == 0 && g->global_gotsym == NULL)
1616 	/* If we haven't got through GOT allocation yet, just bump up the
1617 	      number of local entries, as this symbol won't be counted as
1618 	      global.  */
1619 	g->local_gotno++;
1620       else if (h->root.got.offset == 1)
1621 	{
1622 	  /* If we're past non-multi-GOT allocation and this symbol had
1623 		  been marked for a global got entry, give it a local entry
1624 		  instead.  */
1625 	  BFD_ASSERT (g->global_gotno > 0);
1626 	  g->local_gotno++;
1627 	  g->global_gotno--;
1628 	}
1629     }
1630 
1631   _bfd_elf_link_hash_hide_symbol (info, &h->root, force_local);
1632 }
1633 
1634 /* If H is a symbol that needs a global GOT entry, but has a dynamic
1635    symbol table index lower than any we've seen to date, record it for
1636    posterity.  */
1637 static bfd_boolean
score_elf_record_global_got_symbol(struct elf_link_hash_entry * h,bfd * abfd,struct bfd_link_info * info,struct score_got_info * g)1638 score_elf_record_global_got_symbol (struct elf_link_hash_entry *h,
1639 				    bfd *abfd,
1640 				    struct bfd_link_info *info,
1641 				    struct score_got_info *g)
1642 {
1643   struct score_got_entry entry, **loc;
1644 
1645   /* A global symbol in the GOT must also be in the dynamic symbol table.  */
1646   if (h->dynindx == -1)
1647     {
1648       switch (ELF_ST_VISIBILITY (h->other))
1649 	{
1650 	case STV_INTERNAL:
1651 	case STV_HIDDEN:
1652 	  s3_bfd_score_elf_hide_symbol (info, h, TRUE);
1653 	  break;
1654 	}
1655       if (!bfd_elf_link_record_dynamic_symbol (info, h))
1656 	return FALSE;
1657     }
1658 
1659   entry.abfd = abfd;
1660   entry.symndx = -1;
1661   entry.d.h = (struct score_elf_link_hash_entry *)h;
1662 
1663   loc = (struct score_got_entry **)htab_find_slot (g->got_entries, &entry, INSERT);
1664 
1665   /* If we've already marked this entry as needing GOT space, we don't
1666      need to do it again.  */
1667   if (*loc)
1668     return TRUE;
1669 
1670   *loc = bfd_alloc (abfd, sizeof entry);
1671   if (! *loc)
1672     return FALSE;
1673 
1674   entry.gotidx = -1;
1675 
1676   memcpy (*loc, &entry, sizeof (entry));
1677 
1678   if (h->got.offset != MINUS_ONE)
1679     return TRUE;
1680 
1681   /* By setting this to a value other than -1, we are indicating that
1682      there needs to be a GOT entry for H.  Avoid using zero, as the
1683      generic ELF copy_indirect_symbol tests for <= 0.  */
1684   h->got.offset = 1;
1685 
1686   return TRUE;
1687 }
1688 
1689 /* Reserve space in G for a GOT entry containing the value of symbol
1690    SYMNDX in input bfd ABDF, plus ADDEND.  */
1691 static bfd_boolean
score_elf_record_local_got_symbol(bfd * abfd,long symndx,bfd_vma addend,struct score_got_info * g)1692 score_elf_record_local_got_symbol (bfd *abfd,
1693 				   long symndx,
1694 				   bfd_vma addend,
1695 				   struct score_got_info *g)
1696 {
1697   struct score_got_entry entry, **loc;
1698 
1699   entry.abfd = abfd;
1700   entry.symndx = symndx;
1701   entry.d.addend = addend;
1702   loc = (struct score_got_entry **)htab_find_slot (g->got_entries, &entry, INSERT);
1703 
1704   if (*loc)
1705     return TRUE;
1706 
1707   entry.gotidx = g->local_gotno++;
1708 
1709   *loc = bfd_alloc (abfd, sizeof(entry));
1710   if (! *loc)
1711     return FALSE;
1712 
1713   memcpy (*loc, &entry, sizeof (entry));
1714 
1715   return TRUE;
1716 }
1717 
1718 /* Returns the GOT offset at which the indicated address can be found.
1719    If there is not yet a GOT entry for this value, create one.
1720    Returns -1 if no satisfactory GOT offset can be found.  */
1721 static bfd_vma
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)1722 score_elf_local_got_index (bfd *abfd, bfd *ibfd, struct bfd_link_info *info,
1723 			   bfd_vma value, unsigned long r_symndx,
1724 			   struct score_elf_link_hash_entry *h, int r_type)
1725 {
1726   asection *sgot;
1727   struct score_got_info *g;
1728   struct score_got_entry *entry;
1729 
1730   g = score_elf_got_info (elf_hash_table (info)->dynobj, &sgot);
1731 
1732   entry = score_elf_create_local_got_entry (abfd, ibfd, g, sgot, value,
1733 					     r_symndx, h, r_type);
1734   if (!entry)
1735     return MINUS_ONE;
1736 
1737   else
1738     return entry->gotidx;
1739 }
1740 
1741 /* Returns the GOT index for the global symbol indicated by H.  */
1742 
1743 static bfd_vma
score_elf_global_got_index(bfd * abfd,struct elf_link_hash_entry * h)1744 score_elf_global_got_index (bfd *abfd, struct elf_link_hash_entry *h)
1745 {
1746   bfd_vma got_index;
1747   asection *sgot;
1748   struct score_got_info *g;
1749   long global_got_dynindx = 0;
1750 
1751   g = score_elf_got_info (abfd, &sgot);
1752   if (g->global_gotsym != NULL)
1753     global_got_dynindx = g->global_gotsym->dynindx;
1754 
1755   /* Once we determine the global GOT entry with the lowest dynamic
1756      symbol table index, we must put all dynamic symbols with greater
1757      indices into the GOT.  That makes it easy to calculate the GOT
1758      offset.  */
1759   BFD_ASSERT (h->dynindx >= global_got_dynindx);
1760   got_index = ((h->dynindx - global_got_dynindx + g->local_gotno) * SCORE_ELF_GOT_SIZE (abfd));
1761   BFD_ASSERT (got_index < sgot->size);
1762 
1763   return got_index;
1764 }
1765 
1766 /* Returns the offset for the entry at the INDEXth position in the GOT.  */
1767 
1768 static bfd_vma
score_elf_got_offset_from_index(bfd * dynobj,bfd * output_bfd,bfd * input_bfd ATTRIBUTE_UNUSED,bfd_vma got_index)1769 score_elf_got_offset_from_index (bfd *dynobj,
1770 				 bfd *output_bfd,
1771 				 bfd *input_bfd ATTRIBUTE_UNUSED,
1772 				 bfd_vma got_index)
1773 {
1774   asection *sgot;
1775   bfd_vma gp;
1776 
1777   score_elf_got_info (dynobj, &sgot);
1778   gp = _bfd_get_gp_value (output_bfd);
1779 
1780   return sgot->output_section->vma + sgot->output_offset + got_index - gp;
1781 }
1782 
1783 /* Follow indirect and warning hash entries so that each got entry
1784    points to the final symbol definition.  P must point to a pointer
1785    to the hash table we're traversing.  Since this traversal may
1786    modify the hash table, we set this pointer to NULL to indicate
1787    we've made a potentially-destructive change to the hash table, so
1788    the traversal must be restarted.  */
1789 static int
score_elf_resolve_final_got_entry(void ** entryp,void * p)1790 score_elf_resolve_final_got_entry (void **entryp, void *p)
1791 {
1792   struct score_got_entry *entry = (struct score_got_entry *)*entryp;
1793   htab_t got_entries = *(htab_t *)p;
1794 
1795   if (entry->abfd != NULL && entry->symndx == -1)
1796     {
1797       struct score_elf_link_hash_entry *h = entry->d.h;
1798 
1799       while (h->root.root.type == bfd_link_hash_indirect
1800 	     || h->root.root.type == bfd_link_hash_warning)
1801 	h = (struct score_elf_link_hash_entry *) h->root.root.u.i.link;
1802 
1803       if (entry->d.h == h)
1804 	return 1;
1805 
1806       entry->d.h = h;
1807 
1808       /* If we can't find this entry with the new bfd hash, re-insert
1809 	 it, and get the traversal restarted.  */
1810       if (! htab_find (got_entries, entry))
1811 	{
1812 	  htab_clear_slot (got_entries, entryp);
1813 	  entryp = htab_find_slot (got_entries, entry, INSERT);
1814 	  if (! *entryp)
1815 	    *entryp = entry;
1816 	  /* Abort the traversal, since the whole table may have
1817 	     moved, and leave it up to the parent to restart the
1818 	     process.  */
1819 	  *(htab_t *)p = NULL;
1820 	  return 0;
1821 	}
1822       /* We might want to decrement the global_gotno count, but it's
1823 	 either too early or too late for that at this point.  */
1824     }
1825 
1826   return 1;
1827 }
1828 
1829 /* Turn indirect got entries in a got_entries table into their final locations.  */
1830 static void
score_elf_resolve_final_got_entries(struct score_got_info * g)1831 score_elf_resolve_final_got_entries (struct score_got_info *g)
1832 {
1833   htab_t got_entries;
1834 
1835   do
1836     {
1837       got_entries = g->got_entries;
1838 
1839       htab_traverse (got_entries,
1840 		     score_elf_resolve_final_got_entry,
1841 		     &got_entries);
1842     }
1843   while (got_entries == NULL);
1844 }
1845 
1846 /* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS. for -r  */
1847 static void
score_elf_add_to_rel(bfd * abfd,bfd_byte * address,reloc_howto_type * howto,bfd_signed_vma increment)1848 score_elf_add_to_rel (bfd *abfd,
1849 		      bfd_byte *address,
1850 		      reloc_howto_type *howto,
1851 		      bfd_signed_vma increment)
1852 {
1853   bfd_signed_vma addend;
1854   bfd_vma contents;
1855   unsigned long offset;
1856   unsigned long r_type = howto->type;
1857   unsigned long hi16_addend, hi16_offset, hi16_value, uvalue;
1858 
1859   contents = score_bfd_get_32 (abfd, address);
1860   /* Get the (signed) value from the instruction.  */
1861   addend = contents & howto->src_mask;
1862   if (addend & ((howto->src_mask + 1) >> 1))
1863     {
1864       bfd_signed_vma mask;
1865 
1866       mask = -1;
1867       mask &= ~howto->src_mask;
1868       addend |= mask;
1869     }
1870   /* Add in the increment, (which is a byte value).  */
1871   switch (r_type)
1872     {
1873     case R_SCORE_PC19:
1874       offset =
1875 	(((contents & howto->src_mask) & 0x3ff0000) >> 6) | ((contents & howto->src_mask) & 0x3ff);
1876       offset += increment;
1877       contents =
1878 	(contents & ~howto->
1879 	 src_mask) | (((offset << 6) & howto->src_mask) & 0x3ff0000) | (offset & 0x3ff);
1880       score_bfd_put_32 (abfd, contents, address);
1881       break;
1882     case R_SCORE_HI16:
1883       break;
1884     case R_SCORE_LO16:
1885       hi16_addend = score_bfd_get_32 (abfd, address - 4);
1886       hi16_offset = ((((hi16_addend >> 16) & 0x3) << 15) | (hi16_addend & 0x7fff)) >> 1;
1887       offset = ((((contents >> 16) & 0x3) << 15) | (contents & 0x7fff)) >> 1;
1888       offset = (hi16_offset << 16) | (offset & 0xffff);
1889       uvalue = increment + offset;
1890       hi16_offset = (uvalue >> 16) << 1;
1891       hi16_value = (hi16_addend & (~(howto->dst_mask)))
1892 	| (hi16_offset & 0x7fff) | ((hi16_offset << 1) & 0x30000);
1893       score_bfd_put_32 (abfd, hi16_value, address - 4);
1894       offset = (uvalue & 0xffff) << 1;
1895       contents = (contents & (~(howto->dst_mask))) | (offset & 0x7fff) | ((offset << 1) & 0x30000);
1896       score_bfd_put_32 (abfd, contents, address);
1897       break;
1898     case R_SCORE_24:
1899       offset =
1900 	(((contents & howto->src_mask) >> 1) & 0x1ff8000) | ((contents & howto->src_mask) & 0x7fff);
1901       offset += increment;
1902       contents =
1903 	(contents & ~howto->
1904 	 src_mask) | (((offset << 1) & howto->src_mask) & 0x3ff0000) | (offset & 0x7fff);
1905       score_bfd_put_32 (abfd, contents, address);
1906       break;
1907 
1908     case R_SCORE16_11:
1909 
1910       contents = score_bfd_get_16 (abfd, address);
1911       offset = contents & howto->src_mask;
1912       offset += increment;
1913       contents = (contents & ~howto->src_mask) | (offset & howto->src_mask);
1914       score_bfd_put_16 (abfd, contents, address);
1915 
1916       break;
1917     case R_SCORE16_PC8:
1918 
1919       contents = score_bfd_get_16 (abfd, address);
1920       offset = (contents & howto->src_mask) + ((increment >> 1) & 0x1ff);
1921       contents = (contents & (~howto->src_mask)) | (offset & howto->src_mask);
1922       score_bfd_put_16 (abfd, contents, address);
1923 
1924       break;
1925 
1926     case R_SCORE_BCMP:
1927       contents = score_bfd_get_32 (abfd, address);
1928       offset = (contents & howto->src_mask);
1929       offset <<= howto->rightshift;
1930       offset += increment;
1931       offset >>= howto->rightshift;
1932       contents = (contents & (~howto->src_mask)) | (offset & howto->src_mask);
1933       score_bfd_put_32 (abfd, contents, address);
1934       break;
1935 
1936     case R_SCORE_IMM30:
1937       contents = score_bfd_get_48 (abfd, address);
1938       offset = (contents & howto->src_mask);
1939       offset <<= howto->rightshift;
1940       offset += increment;
1941       offset >>= howto->rightshift;
1942       contents = (contents & (~howto->src_mask)) | (offset & howto->src_mask);
1943       score_bfd_put_48 (abfd, contents, address);
1944       break;
1945 
1946     case R_SCORE_IMM32:
1947       contents = score_bfd_get_48 (abfd, address);
1948       offset = (contents & howto->src_mask);
1949       offset += increment;
1950       contents = (contents & (~howto->src_mask)) | (offset & howto->src_mask);
1951       score_bfd_put_48 (abfd, contents, address);
1952       break;
1953 
1954     default:
1955       addend += increment;
1956       contents = (contents & ~howto->dst_mask) | (addend & howto->dst_mask);
1957       score_bfd_put_32 (abfd, contents, address);
1958       break;
1959     }
1960 }
1961 
1962 /* Perform a relocation as part of a final link.  */
1963 static bfd_reloc_status_type
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)1964 score_elf_final_link_relocate (reloc_howto_type *howto,
1965 			       bfd *input_bfd,
1966 			       bfd *output_bfd,
1967 			       asection *input_section,
1968 			       bfd_byte *contents,
1969 			       Elf_Internal_Rela *rel,
1970 			       Elf_Internal_Rela *relocs,
1971 			       bfd_vma symbol,
1972 			       struct bfd_link_info *info,
1973 			       const char *sym_name ATTRIBUTE_UNUSED,
1974 			       int sym_flags ATTRIBUTE_UNUSED,
1975 			       struct score_elf_link_hash_entry *h,
1976 			       asection **local_sections,
1977 			       bfd_boolean gp_disp_p)
1978 {
1979   unsigned long r_type;
1980   unsigned long r_symndx;
1981   bfd_byte *hit_data = contents + rel->r_offset;
1982   bfd_vma addend;
1983   /* The final GP value to be used for the relocatable, executable, or
1984      shared object file being produced.  */
1985   bfd_vma gp = MINUS_ONE;
1986   /* The place (section offset or address) of the storage unit being relocated.  */
1987   bfd_vma rel_addr;
1988   /* The offset into the global offset table at which the address of the relocation entry
1989      symbol, adjusted by the addend, resides during execution.  */
1990   bfd_vma g = MINUS_ONE;
1991   /* TRUE if the symbol referred to by this relocation is a local symbol.  */
1992   bfd_boolean local_p;
1993   /* The eventual value we will relocate.  */
1994   bfd_vma value = symbol;
1995   unsigned long hi16_addend, hi16_offset, hi16_value, uvalue, offset, abs_value = 0;
1996 
1997 
1998   if (elf_gp (output_bfd) == 0)
1999     {
2000       struct bfd_link_hash_entry *bh;
2001       asection *o;
2002 
2003       bh = bfd_link_hash_lookup (info->hash, "_gp", 0, 0, 1);
2004       if (bh != NULL && bh->type == bfd_link_hash_defined)
2005 	elf_gp (output_bfd) = (bh->u.def.value
2006 			       + bh->u.def.section->output_section->vma
2007 			       + bh->u.def.section->output_offset);
2008       else if (bfd_link_relocatable (info))
2009 	{
2010 	  bfd_vma lo = -1;
2011 
2012 	  /* Find the GP-relative section with the lowest offset.  */
2013 	  for (o = output_bfd->sections; o != NULL; o = o->next)
2014 	    if (o->vma < lo)
2015 	      lo = o->vma;
2016 	  /* And calculate GP relative to that.  */
2017 	  elf_gp (output_bfd) = lo + ELF_SCORE_GP_OFFSET (input_bfd);
2018 	}
2019       else
2020 	{
2021 	  /* If the relocate_section function needs to do a reloc
2022 	     involving the GP value, it should make a reloc_dangerous
2023 	     callback to warn that GP is not defined.  */
2024 	}
2025     }
2026 
2027   /* Parse the relocation.  */
2028   r_symndx = ELF32_R_SYM (rel->r_info);
2029   r_type = ELF32_R_TYPE (rel->r_info);
2030   rel_addr = (input_section->output_section->vma + input_section->output_offset + rel->r_offset);
2031   local_p = score_elf_local_relocation_p (input_bfd, rel, local_sections, TRUE);
2032 
2033   if (r_type == R_SCORE_GOT15)
2034     {
2035       const Elf_Internal_Rela *relend;
2036       const Elf_Internal_Rela *lo16_rel;
2037       bfd_vma lo_value = 0;
2038 
2039       relend = relocs + input_section->reloc_count;
2040       lo16_rel = score_elf_next_relocation (input_bfd, R_SCORE_GOT_LO16, rel, relend);
2041       if ((local_p) && (lo16_rel != NULL))
2042 	{
2043 	  bfd_vma tmp = 0;
2044 	  tmp = score_bfd_get_32 (input_bfd, contents + lo16_rel->r_offset);
2045 	  lo_value = (((tmp >> 16) & 0x3) << 14) | ((tmp & 0x7fff) >> 1);
2046 	}
2047       addend = lo_value;
2048     }
2049   /* For score3 R_SCORE_ABS32.  */
2050   else if (r_type == R_SCORE_ABS32 || r_type == R_SCORE_REL32)
2051     {
2052       addend = (bfd_get_32 (input_bfd, hit_data) >> howto->bitpos) & howto->src_mask;
2053     }
2054   else
2055     {
2056       addend = (score_bfd_get_32 (input_bfd, hit_data) >> howto->bitpos) & howto->src_mask;
2057     }
2058 
2059   /* If we haven't already determined the GOT offset, or the GP value,
2060      and we're going to need it, get it now.  */
2061   switch (r_type)
2062     {
2063     case R_SCORE_CALL15:
2064     case R_SCORE_GOT15:
2065       if (!local_p)
2066 	{
2067 	  g = score_elf_global_got_index (elf_hash_table (info)->dynobj,
2068 					  (struct elf_link_hash_entry *) h);
2069 	  if ((! elf_hash_table (info)->dynamic_sections_created
2070 	       || (bfd_link_pic (info)
2071 		   && (info->symbolic || h->root.dynindx == -1)
2072 		   && h->root.def_regular)))
2073 	    {
2074 	      /* This is a static link or a -Bsymbolic link.  The
2075 		 symbol is defined locally, or was forced to be local.
2076 		 We must initialize this entry in the GOT.  */
2077 	      bfd *tmpbfd = elf_hash_table (info)->dynobj;
2078 	      asection *sgot = score_elf_got_section (tmpbfd, FALSE);
2079 	      score_bfd_put_32 (tmpbfd, value, sgot->contents + g);
2080 	    }
2081 	}
2082       else if (r_type == R_SCORE_GOT15 || r_type == R_SCORE_CALL15)
2083 	{
2084 	  /* There's no need to create a local GOT entry here; the
2085 	     calculation for a local GOT15 entry does not involve G.  */
2086 	  ;
2087 	}
2088       else
2089 	{
2090 	  g = score_elf_local_got_index (output_bfd, input_bfd, info,
2091 					 symbol + addend, r_symndx, h, r_type);
2092 	    if (g == MINUS_ONE)
2093 	    return bfd_reloc_outofrange;
2094 	}
2095 
2096       /* Convert GOT indices to actual offsets.  */
2097       g = score_elf_got_offset_from_index (elf_hash_table (info)->dynobj,
2098 					   output_bfd, input_bfd, g);
2099       break;
2100 
2101     case R_SCORE_HI16:
2102     case R_SCORE_LO16:
2103     case R_SCORE_GPREL32:
2104       gp = _bfd_get_gp_value (output_bfd);
2105       break;
2106 
2107     case R_SCORE_GP15:
2108       gp = _bfd_get_gp_value (output_bfd);
2109 
2110     default:
2111       break;
2112     }
2113 
2114   switch (r_type)
2115     {
2116     case R_SCORE_NONE:
2117       return bfd_reloc_ok;
2118 
2119     case R_SCORE_ABS32:
2120     case R_SCORE_REL32:
2121       if ((bfd_link_pic (info)
2122 	   || (elf_hash_table (info)->dynamic_sections_created
2123 	       && h != NULL
2124 	       && h->root.def_dynamic
2125 	       && !h->root.def_regular))
2126 	   && r_symndx != STN_UNDEF
2127 	   && (input_section->flags & SEC_ALLOC) != 0)
2128 	{
2129 	  /* If we're creating a shared library, or this relocation is against a symbol
2130 	     in a shared library, then we can't know where the symbol will end up.
2131 	     So, we create a relocation record in the output, and leave the job up
2132 	     to the dynamic linker.  */
2133 	  value = addend;
2134 	  if (!score_elf_create_dynamic_relocation (output_bfd, info, rel, h,
2135 						    symbol, &value,
2136 						    input_section))
2137 	    return bfd_reloc_undefined;
2138 	}
2139       else if (r_symndx == STN_UNDEF)
2140 	/* r_symndx will be STN_UNDEF (zero) only for relocs against symbols
2141 	   from removed linkonce sections, or sections discarded by
2142 	   a linker script.  */
2143 	value = 0;
2144       else
2145 	{
2146 	  if (r_type != R_SCORE_REL32)
2147 	    value = symbol + addend;
2148 	  else
2149 	    value = addend;
2150 	}
2151       value &= howto->dst_mask;
2152       bfd_put_32 (input_bfd, value, hit_data);
2153       return bfd_reloc_ok;
2154 
2155     case R_SCORE_ABS16:
2156       value += addend;
2157       if ((long)value > 0x7fff || (long)value < -0x8000)
2158 	return bfd_reloc_overflow;
2159       score_bfd_put_16 (input_bfd, value, hit_data);
2160       return bfd_reloc_ok;
2161 
2162     case R_SCORE_24:
2163       addend = score_bfd_get_32 (input_bfd, hit_data);
2164       offset = (((addend & howto->src_mask) >> 1) & 0x1ff8000) | ((addend & howto->src_mask) & 0x7fff);
2165       if ((offset & 0x1000000) != 0)
2166 	offset |= 0xfe000000;
2167       value += offset;
2168       abs_value = value - rel_addr;
2169       if ((abs_value & 0xfe000000) != 0)
2170 	return bfd_reloc_overflow;
2171       addend = (addend & ~howto->src_mask)
2172 		| (((value << 1) & howto->src_mask) & 0x3ff0000) | (value & 0x7fff);
2173       score_bfd_put_32 (input_bfd, addend, hit_data);
2174       return bfd_reloc_ok;
2175 
2176     /* signed imm32.  */
2177     case R_SCORE_IMM30:
2178       {
2179 	int not_word_align_p = 0;
2180 	bfd_vma imm_offset = 0;
2181 	addend = score_bfd_get_48 (input_bfd, hit_data);
2182 	imm_offset = ((addend >> 7) & 0xff)
2183 		     | (((addend >> 16) & 0x7fff) << 8)
2184 		     | (((addend >> 32) & 0x7f) << 23);
2185 	imm_offset <<= howto->rightshift;
2186 	value += imm_offset;
2187 	value &= 0xffffffff;
2188 
2189 	/* Check lw48/sw48 rd, value/label word align.  */
2190 	if ((value & 0x3) != 0)
2191 	  not_word_align_p = 1;
2192 
2193 	value >>= howto->rightshift;
2194 	addend = (addend & ~howto->src_mask)
2195 		 | (((value & 0xff) >> 0) << 7)
2196 		 | (((value & 0x7fff00) >> 8) << 16)
2197 		 | (((value & 0x3f800000) >> 23) << 32);
2198 	score_bfd_put_48 (input_bfd, addend, hit_data);
2199 	if (not_word_align_p)
2200 	  return bfd_reloc_other;
2201 	else
2202 	  return bfd_reloc_ok;
2203       }
2204 
2205     case R_SCORE_IMM32:
2206       {
2207 	bfd_vma imm_offset = 0;
2208 	addend = score_bfd_get_48 (input_bfd, hit_data);
2209 	imm_offset = ((addend >> 5) & 0x3ff)
2210 		     | (((addend >> 16) & 0x7fff) << 10)
2211 		     | (((addend >> 32) & 0x7f) << 25);
2212 	value += imm_offset;
2213 	value &= 0xffffffff;
2214 	addend = (addend & ~howto->src_mask)
2215 		 | ((value & 0x3ff) << 5)
2216 		 | (((value >> 10) & 0x7fff) << 16)
2217 		 | (((value >> 25) & 0x7f) << 32);
2218 	score_bfd_put_48 (input_bfd, addend, hit_data);
2219 	return bfd_reloc_ok;
2220       }
2221 
2222     case R_SCORE_PC19:
2223       addend = score_bfd_get_32 (input_bfd, hit_data);
2224       offset = (((addend & howto->src_mask) & 0x3ff0000) >> 6) | ((addend & howto->src_mask) & 0x3ff);
2225       if ((offset & 0x80000) != 0)
2226 	offset |= 0xfff00000;
2227       abs_value = value = value - rel_addr + offset;
2228       /* exceed 20 bit : overflow.  */
2229       if ((abs_value & 0x80000000) == 0x80000000)
2230 	abs_value = 0xffffffff - value + 1;
2231       if ((abs_value & 0xfff80000) != 0)
2232 	return bfd_reloc_overflow;
2233       addend = (addend & ~howto->src_mask)
2234 		| (((value << 6) & howto->src_mask) & 0x3ff0000) | (value & 0x3ff);
2235       score_bfd_put_32 (input_bfd, addend, hit_data);
2236       return bfd_reloc_ok;
2237 
2238     case R_SCORE16_11:
2239       addend = score_bfd_get_16 (input_bfd, hit_data);
2240       offset = addend & howto->src_mask;
2241       if ((offset & 0x800) != 0)	/* Offset is negative.  */
2242 	offset |= 0xfffff000;
2243       value += offset;
2244       abs_value = value - rel_addr;
2245       if ((abs_value & 0xfffff000) != 0)
2246 	return bfd_reloc_overflow;
2247       addend = (addend & ~howto->src_mask) | (value & howto->src_mask);
2248       score_bfd_put_16 (input_bfd, addend, hit_data);
2249       return bfd_reloc_ok;
2250 
2251     case R_SCORE16_PC8:
2252       addend = score_bfd_get_16 (input_bfd, hit_data);
2253       offset = (addend & howto->src_mask) << 1;
2254       if ((offset & 0x200) != 0)	/* Offset is negative.  */
2255 	offset |= 0xfffffe00;
2256       abs_value = value = value - rel_addr + offset;
2257       /* Sign bit + exceed 9 bit.  */
2258       if (((value & 0xfffffe00) != 0) && ((value & 0xfffffe00) != 0xfffffe00))
2259 	return bfd_reloc_overflow;
2260       value >>= 1;
2261       addend = (addend & ~howto->src_mask) | (value & howto->src_mask);
2262       score_bfd_put_16 (input_bfd, addend, hit_data);
2263       return bfd_reloc_ok;
2264 
2265     case R_SCORE_BCMP:
2266       addend = score_bfd_get_32 (input_bfd, hit_data);
2267       offset = (addend & howto->src_mask) << howto->rightshift;
2268       if ((offset & 0x200) != 0)	/* Offset is negative.  */
2269 	offset |= 0xfffffe00;
2270       value = value - rel_addr + offset;
2271       /* Sign bit + exceed 9 bit.  */
2272       if (((value & 0xfffffe00) != 0) && ((value & 0xfffffe00) != 0xfffffe00))
2273 	return bfd_reloc_overflow;
2274       value >>= howto->rightshift;
2275       addend = (addend & ~howto->src_mask)
2276 	       | (value & 0x1)
2277 	       | (((value >> 1) & 0x7) << 7)
2278 	       | (((value >> 4) & 0x1f) << 21);
2279       score_bfd_put_32 (input_bfd, addend, hit_data);
2280       return bfd_reloc_ok;
2281 
2282     case R_SCORE_HI16:
2283       return bfd_reloc_ok;
2284 
2285     case R_SCORE_LO16:
2286       hi16_addend = score_bfd_get_32 (input_bfd, hit_data - 4);
2287       hi16_offset = ((((hi16_addend >> 16) & 0x3) << 15) | (hi16_addend & 0x7fff)) >> 1;
2288       addend = score_bfd_get_32 (input_bfd, hit_data);
2289       offset = ((((addend >> 16) & 0x3) << 15) | (addend & 0x7fff)) >> 1;
2290       offset = (hi16_offset << 16) | (offset & 0xffff);
2291 
2292       if (!gp_disp_p)
2293 	uvalue = value + offset;
2294       else
2295 	uvalue = offset + gp - rel_addr + 4;
2296 
2297       hi16_offset = (uvalue >> 16) << 1;
2298       hi16_value = (hi16_addend & (~(howto->dst_mask)))
2299 			| (hi16_offset & 0x7fff) | ((hi16_offset << 1) & 0x30000);
2300       score_bfd_put_32 (input_bfd, hi16_value, hit_data - 4);
2301       offset = (uvalue & 0xffff) << 1;
2302       value = (addend & (~(howto->dst_mask))) | (offset & 0x7fff) | ((offset << 1) & 0x30000);
2303       score_bfd_put_32 (input_bfd, value, hit_data);
2304       return bfd_reloc_ok;
2305 
2306     case R_SCORE_GP15:
2307       addend = score_bfd_get_32 (input_bfd, hit_data);
2308       offset = addend & 0x7fff;
2309       if ((offset & 0x4000) == 0x4000)
2310 	offset |= 0xffffc000;
2311       value = value + offset - gp;
2312       if (((value & 0xffffc000) != 0) && ((value & 0xffffc000) != 0xffffc000))
2313 	return bfd_reloc_overflow;
2314       value = (addend & ~howto->src_mask) | (value & howto->src_mask);
2315       score_bfd_put_32 (input_bfd, value, hit_data);
2316       return bfd_reloc_ok;
2317 
2318     case R_SCORE_GOT15:
2319     case R_SCORE_CALL15:
2320       if (local_p)
2321 	{
2322 	  bfd_boolean forced;
2323 
2324 	  /* The special case is when the symbol is forced to be local.  We need the
2325 	     full address in the GOT since no R_SCORE_GOT_LO16 relocation follows.  */
2326 	  forced = ! score_elf_local_relocation_p (input_bfd, rel,
2327 						   local_sections, FALSE);
2328 	  value = score_elf_got16_entry (output_bfd, input_bfd, info,
2329 					 symbol + addend, forced);
2330 	  if (value == MINUS_ONE)
2331 	    return bfd_reloc_outofrange;
2332 	  value = score_elf_got_offset_from_index (elf_hash_table (info)->dynobj,
2333 						   output_bfd, input_bfd, value);
2334 	}
2335       else
2336 	{
2337 	  value = g;
2338 	}
2339 
2340       if ((long) value > 0x3fff || (long) value < -0x4000)
2341 	return bfd_reloc_overflow;
2342 
2343       addend = score_bfd_get_32 (input_bfd, hit_data);
2344       value = (addend & ~howto->dst_mask) | (value & howto->dst_mask);
2345       score_bfd_put_32 (input_bfd, value, hit_data);
2346       return bfd_reloc_ok;
2347 
2348     case R_SCORE_GPREL32:
2349       value = (addend + symbol - gp);
2350       value &= howto->dst_mask;
2351       score_bfd_put_32 (input_bfd, value, hit_data);
2352       return bfd_reloc_ok;
2353 
2354     case R_SCORE_GOT_LO16:
2355       addend = score_bfd_get_32 (input_bfd, hit_data);
2356       value = (((addend >> 16) & 0x3) << 14) | ((addend & 0x7fff) >> 1);
2357       value += symbol;
2358       value = (addend & (~(howto->dst_mask))) | ((value & 0x3fff) << 1)
2359 	       | (((value >> 14) & 0x3) << 16);
2360 
2361       score_bfd_put_32 (input_bfd, value, hit_data);
2362       return bfd_reloc_ok;
2363 
2364     case R_SCORE_DUMMY_HI16:
2365       return bfd_reloc_ok;
2366 
2367     case R_SCORE_GNU_VTINHERIT:
2368     case R_SCORE_GNU_VTENTRY:
2369       /* We don't do anything with these at present.  */
2370       return bfd_reloc_continue;
2371 
2372     default:
2373       return bfd_reloc_notsupported;
2374     }
2375 }
2376 
2377 /* Score backend functions.  */
2378 static bfd_boolean
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     return FALSE;
2388 
2389   bfd_reloc->howto = &elf32_score_howto_table[r_type];
2390   return TRUE;
2391 }
2392 
2393 /* Relocate an score ELF section.  */
2394 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)2395 s3_bfd_score_elf_relocate_section (bfd *output_bfd,
2396 				   struct bfd_link_info *info,
2397 				   bfd *input_bfd,
2398 				   asection *input_section,
2399 				   bfd_byte *contents,
2400 				   Elf_Internal_Rela *relocs,
2401 				   Elf_Internal_Sym *local_syms,
2402 				   asection **local_sections)
2403 {
2404   Elf_Internal_Shdr *symtab_hdr;
2405   Elf_Internal_Rela *rel;
2406   Elf_Internal_Rela *relend;
2407   const char *name;
2408   unsigned long offset;
2409   unsigned long hi16_addend, hi16_offset, hi16_value, uvalue;
2410   size_t extsymoff;
2411   bfd_boolean gp_disp_p = FALSE;
2412 
2413   /* Sort dynsym.  */
2414   if (elf_hash_table (info)->dynamic_sections_created)
2415     {
2416       bfd_size_type dynsecsymcount = 0;
2417       if (bfd_link_pic (info))
2418 	{
2419 	  asection * p;
2420 	  const struct elf_backend_data *bed = get_elf_backend_data (output_bfd);
2421 
2422 	  for (p = output_bfd->sections; p ; p = p->next)
2423 	    if ((p->flags & SEC_EXCLUDE) == 0
2424 		&& (p->flags & SEC_ALLOC) != 0
2425 		&& !(*bed->elf_backend_omit_section_dynsym) (output_bfd, info, p))
2426 	      ++ dynsecsymcount;
2427 	}
2428 
2429       if (!score_elf_sort_hash_table (info, dynsecsymcount + 1))
2430 	return FALSE;
2431     }
2432 
2433   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2434   extsymoff = (elf_bad_symtab (input_bfd)) ? 0 : symtab_hdr->sh_info;
2435   rel = relocs;
2436   relend = relocs + input_section->reloc_count;
2437   for (; rel < relend; rel++)
2438     {
2439       int r_type;
2440       reloc_howto_type *howto;
2441       unsigned long r_symndx;
2442       Elf_Internal_Sym *sym;
2443       asection *sec;
2444       struct score_elf_link_hash_entry *h;
2445       bfd_vma relocation = 0;
2446       bfd_reloc_status_type r;
2447       arelent bfd_reloc;
2448 
2449       r_symndx = ELF32_R_SYM (rel->r_info);
2450       r_type = ELF32_R_TYPE (rel->r_info);
2451 
2452       if (! s3_bfd_score_info_to_howto (input_bfd, &bfd_reloc, (Elf_Internal_Rela *) rel))
2453 	continue;
2454       howto = bfd_reloc.howto;
2455 
2456       h = NULL;
2457       sym = NULL;
2458       sec = NULL;
2459 
2460       if (r_symndx < extsymoff)
2461 	{
2462 	  sym = local_syms + r_symndx;
2463 	  sec = local_sections[r_symndx];
2464 	  relocation = (sec->output_section->vma
2465 			+ sec->output_offset
2466 			+ sym->st_value);
2467 	  name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec);
2468 
2469 	  if (!bfd_link_relocatable (info)
2470 	      && (sec->flags & SEC_MERGE)
2471 	      && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2472 	    {
2473 	      asection *msec;
2474 	      bfd_vma addend, value;
2475 
2476 	      switch (r_type)
2477 		{
2478 		case R_SCORE_HI16:
2479 		  break;
2480 		case R_SCORE_LO16:
2481 		  hi16_addend = score_bfd_get_32 (input_bfd, contents + rel->r_offset - 4);
2482 		  hi16_offset = ((((hi16_addend >> 16) & 0x3) << 15) | (hi16_addend & 0x7fff)) >> 1;
2483 		  value = score_bfd_get_32 (input_bfd, contents + rel->r_offset);
2484 		  offset = ((((value >> 16) & 0x3) << 15) | (value & 0x7fff)) >> 1;
2485 		  addend = (hi16_offset << 16) | (offset & 0xffff);
2486 		  msec = sec;
2487 		  addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend);
2488 		  addend -= relocation;
2489 		  addend += msec->output_section->vma + msec->output_offset;
2490 		  uvalue = addend;
2491 		  hi16_offset = (uvalue >> 16) << 1;
2492 		  hi16_value = (hi16_addend & (~(howto->dst_mask)))
2493 		    | (hi16_offset & 0x7fff) | ((hi16_offset << 1) & 0x30000);
2494 		  score_bfd_put_32 (input_bfd, hi16_value, contents + rel->r_offset - 4);
2495 		  offset = (uvalue & 0xffff) << 1;
2496 		  value = (value & (~(howto->dst_mask)))
2497 		    | (offset & 0x7fff) | ((offset << 1) & 0x30000);
2498 		  score_bfd_put_32 (input_bfd, value, contents + rel->r_offset);
2499 		  break;
2500 
2501 		case R_SCORE_IMM32:
2502 		  {
2503 		    value = score_bfd_get_48 (input_bfd, contents + rel->r_offset);
2504 		    addend = ((value >> 5) & 0x3ff)
2505 			      | (((value >> 16) & 0x7fff) << 10)
2506 			      | (((value >> 32) & 0x7f) << 25);
2507 		    msec = sec;
2508 		    addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend);
2509 		    addend -= relocation;
2510 		    addend += msec->output_section->vma + msec->output_offset;
2511 		    addend &= 0xffffffff;
2512 		    value = (value & ~howto->src_mask)
2513 			     | ((addend & 0x3ff) << 5)
2514 			     | (((addend >> 10) & 0x7fff) << 16)
2515 			     | (((addend >> 25) & 0x7f) << 32);
2516 		    score_bfd_put_48 (input_bfd, value, contents + rel->r_offset);
2517 		    break;
2518 		  }
2519 
2520 		case R_SCORE_IMM30:
2521 		  {
2522 		    int not_word_align_p = 0;
2523 		    value = score_bfd_get_48 (input_bfd, contents + rel->r_offset);
2524 		    addend = ((value >> 7) & 0xff)
2525 			      | (((value >> 16) & 0x7fff) << 8)
2526 			      | (((value >> 32) & 0x7f) << 23);
2527 		    addend <<= howto->rightshift;
2528 		    msec = sec;
2529 		    addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend);
2530 		    addend -= relocation;
2531 		    addend += msec->output_section->vma + msec->output_offset;
2532 		    addend &= 0xffffffff;
2533 
2534 		    /* Check lw48/sw48 rd, value/label word align.  */
2535 		    if ((addend & 0x3) != 0)
2536 		      not_word_align_p = 1;
2537 
2538 		    addend >>= howto->rightshift;
2539 		    value = (value & ~howto->src_mask)
2540 			     | (((addend & 0xff) >> 0) << 7)
2541 			     | (((addend & 0x7fff00) >> 8) << 16)
2542 			     | (((addend & 0x3f800000) >> 23) << 32);
2543 		    score_bfd_put_48 (input_bfd, value, contents + rel->r_offset);
2544 
2545 		    if (not_word_align_p)
2546 		      return bfd_reloc_other;
2547 		    else
2548 		      break;
2549 		  }
2550 
2551 		case R_SCORE_GOT_LO16:
2552 		  value = score_bfd_get_32 (input_bfd, contents + rel->r_offset);
2553 		  addend = (((value >> 16) & 0x3) << 14) | ((value & 0x7fff) >> 1);
2554 		  msec = sec;
2555 		  addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend) - relocation;
2556 		  addend += msec->output_section->vma + msec->output_offset;
2557 		  value = (value & (~(howto->dst_mask))) | ((addend & 0x3fff) << 1)
2558 			   | (((addend >> 14) & 0x3) << 16);
2559 
2560 		  score_bfd_put_32 (input_bfd, value, contents + rel->r_offset);
2561 		  break;
2562 
2563 		case R_SCORE_ABS32:
2564 		case R_SCORE_REL32:
2565 		  value = bfd_get_32 (input_bfd, contents + rel->r_offset);
2566 		  /* Get the (signed) value from the instruction.  */
2567 		  addend = value & howto->src_mask;
2568 		  if (addend & ((howto->src_mask + 1) >> 1))
2569 		    {
2570 		      bfd_signed_vma mask;
2571 
2572 		      mask = -1;
2573 		      mask &= ~howto->src_mask;
2574 		      addend |= mask;
2575 		    }
2576 		  msec = sec;
2577 		  addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend) - relocation;
2578 		  addend += msec->output_section->vma + msec->output_offset;
2579 		  value = (value & ~howto->dst_mask) | (addend & howto->dst_mask);
2580 		  bfd_put_32 (input_bfd, value, contents + rel->r_offset);
2581 		  break;
2582 
2583 		default:
2584 		  value = score_bfd_get_32 (input_bfd, contents + rel->r_offset);
2585 		  /* Get the (signed) value from the instruction.  */
2586 		  addend = value & howto->src_mask;
2587 		  if (addend & ((howto->src_mask + 1) >> 1))
2588 		    {
2589 		      bfd_signed_vma mask;
2590 
2591 		      mask = -1;
2592 		      mask &= ~howto->src_mask;
2593 		      addend |= mask;
2594 		    }
2595 		  msec = sec;
2596 		  addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend) - relocation;
2597 		  addend += msec->output_section->vma + msec->output_offset;
2598 		  value = (value & ~howto->dst_mask) | (addend & howto->dst_mask);
2599 		  score_bfd_put_32 (input_bfd, value, contents + rel->r_offset);
2600 		  break;
2601 		}
2602 	    }
2603 	}
2604       else
2605 	{
2606 	  /* For global symbols we look up the symbol in the hash-table.  */
2607 	  h = ((struct score_elf_link_hash_entry *)
2608 	       elf_sym_hashes (input_bfd) [r_symndx - extsymoff]);
2609 
2610 	  if (info->wrap_hash != NULL
2611 	      && (input_section->flags & SEC_DEBUGGING) != 0)
2612 	    h = ((struct score_elf_link_hash_entry *)
2613 		 unwrap_hash_lookup (info, input_bfd, &h->root.root));
2614 
2615 	  /* Find the real hash-table entry for this symbol.  */
2616 	  while (h->root.root.type == bfd_link_hash_indirect
2617 		 || h->root.root.type == bfd_link_hash_warning)
2618 	    h = (struct score_elf_link_hash_entry *) h->root.root.u.i.link;
2619 
2620 	  /* Record the name of this symbol, for our caller.  */
2621 	  name = h->root.root.root.string;
2622 
2623 	  /* See if this is the special GP_DISP_LABEL symbol.  Note that such a
2624 	     symbol must always be a global symbol.  */
2625 	  if (strcmp (name, GP_DISP_LABEL) == 0)
2626 	    {
2627 	      /* Relocations against GP_DISP_LABEL are permitted only with
2628 		 R_SCORE_HI16 and R_SCORE_LO16 relocations.  */
2629 	      if (r_type != R_SCORE_HI16 && r_type != R_SCORE_LO16)
2630 		return bfd_reloc_notsupported;
2631 
2632 	      gp_disp_p = TRUE;
2633 	    }
2634 
2635 	  /* If this symbol is defined, calculate its address.  Note that
2636 	      GP_DISP_LABEL is a magic symbol, always implicitly defined by the
2637 	      linker, so it's inappropriate to check to see whether or not
2638 	      its defined.  */
2639 	  else if ((h->root.root.type == bfd_link_hash_defined
2640 		    || h->root.root.type == bfd_link_hash_defweak)
2641 		   && h->root.root.u.def.section)
2642 	    {
2643 	      sec = h->root.root.u.def.section;
2644 	      if (sec->output_section)
2645 		relocation = (h->root.root.u.def.value
2646 			      + sec->output_section->vma
2647 			      + sec->output_offset);
2648 	      else
2649 		{
2650 		  relocation = h->root.root.u.def.value;
2651 		}
2652 	    }
2653 	  else if (h->root.root.type == bfd_link_hash_undefweak)
2654 	    /* We allow relocations against undefined weak symbols, giving
2655 	       it the value zero, so that you can undefined weak functions
2656 	       and check to see if they exist by looking at their addresses.  */
2657 	    relocation = 0;
2658 	  else if (info->unresolved_syms_in_objects == RM_IGNORE
2659 		   && ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT)
2660 	    relocation = 0;
2661 	  else if (strcmp (name, "_DYNAMIC_LINK") == 0)
2662 	    {
2663 	      /* If this is a dynamic link, we should have created a _DYNAMIC_LINK symbol
2664 		 in s3_bfd_score_elf_create_dynamic_sections.  Otherwise, we should define
2665 		 the symbol with a value of 0.  */
2666 	      BFD_ASSERT (! bfd_link_pic (info));
2667 	      BFD_ASSERT (bfd_get_section_by_name (output_bfd, ".dynamic") == NULL);
2668 	      relocation = 0;
2669 	    }
2670 	  else if (!bfd_link_relocatable (info))
2671 	    {
2672               info->callbacks->undefined_symbol
2673 		(info, h->root.root.root.string, input_bfd, input_section,
2674 		 rel->r_offset,
2675 		 (info->unresolved_syms_in_objects == RM_DIAGNOSE
2676 		  && !info->warn_unresolved_syms)
2677 		 || ELF_ST_VISIBILITY (h->root.other));
2678               relocation = 0;
2679             }
2680 	}
2681 
2682       if (sec != NULL && discarded_section (sec))
2683 	RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
2684 					 rel, 1, relend, howto, 0, contents);
2685 
2686       if (bfd_link_relocatable (info))
2687 	{
2688 	  /* This is a relocatable link.  We don't have to change
2689 	     anything, unless the reloc is against a section symbol,
2690 	     in which case we have to adjust according to where the
2691 	     section symbol winds up in the output section.  */
2692 	  if (r_symndx < symtab_hdr->sh_info)
2693 	    {
2694 	      sym = local_syms + r_symndx;
2695 	      if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2696 		{
2697 		  sec = local_sections[r_symndx];
2698 		  score_elf_add_to_rel (input_bfd, contents + rel->r_offset,
2699 				    howto, (bfd_signed_vma) (sec->output_offset + sym->st_value));
2700 		}
2701 	    }
2702 	  continue;
2703 	}
2704 
2705       /* This is a final link.  */
2706       r = score_elf_final_link_relocate (howto, input_bfd, output_bfd,
2707 					 input_section, contents, rel, relocs,
2708 					 relocation, info, name,
2709 					 (h ? ELF_ST_TYPE ((unsigned int)h->root.root.type) :
2710 					 ELF_ST_TYPE ((unsigned int)sym->st_info)), h, local_sections,
2711 					 gp_disp_p);
2712 
2713       if (r != bfd_reloc_ok)
2714 	{
2715 	  const char *msg = (const char *)0;
2716 
2717 	  switch (r)
2718 	    {
2719 	    case bfd_reloc_overflow:
2720 	      /* If the overflowing reloc was to an undefined symbol,
2721 		 we have already printed one error message and there
2722 		 is no point complaining again.  */
2723 	      if (!h || h->root.root.type != bfd_link_hash_undefined)
2724 		(*info->callbacks->reloc_overflow)
2725 		  (info, NULL, name, howto->name, (bfd_vma) 0,
2726 		   input_bfd, input_section, rel->r_offset);
2727 	      break;
2728 	    case bfd_reloc_undefined:
2729 	      (*info->callbacks->undefined_symbol)
2730 		(info, name, input_bfd, input_section, rel->r_offset, TRUE);
2731 	      break;
2732 
2733 	    case bfd_reloc_outofrange:
2734 	      msg = _("internal error: out of range error");
2735 	      goto common_error;
2736 
2737 	    case bfd_reloc_notsupported:
2738 	      msg = _("internal error: unsupported relocation error");
2739 	      goto common_error;
2740 
2741 	    case bfd_reloc_dangerous:
2742 	      msg = _("internal error: dangerous error");
2743 	      goto common_error;
2744 
2745 	    /* Use bfd_reloc_other to check lw48, sw48 word align.  */
2746 	    case bfd_reloc_other:
2747 	      msg = _("address not word aligned");
2748 	      goto common_error;
2749 
2750 	    default:
2751 	      msg = _("internal error: unknown error");
2752 	      /* Fall through.  */
2753 
2754 	    common_error:
2755 	      (*info->callbacks->warning) (info, msg, name, input_bfd,
2756 					   input_section, rel->r_offset);
2757 	      break;
2758 	    }
2759 	}
2760     }
2761 
2762   return TRUE;
2763 }
2764 
2765 /* Look through the relocs for a section during the first phase, and
2766    allocate space in the global offset table.  */
2767 static bfd_boolean
s3_bfd_score_elf_check_relocs(bfd * abfd,struct bfd_link_info * info,asection * sec,const Elf_Internal_Rela * relocs)2768 s3_bfd_score_elf_check_relocs (bfd *abfd,
2769 			       struct bfd_link_info *info,
2770 			       asection *sec,
2771 			       const Elf_Internal_Rela *relocs)
2772 {
2773   bfd *dynobj;
2774   Elf_Internal_Shdr *symtab_hdr;
2775   struct elf_link_hash_entry **sym_hashes;
2776   struct score_got_info *g;
2777   size_t extsymoff;
2778   const Elf_Internal_Rela *rel;
2779   const Elf_Internal_Rela *rel_end;
2780   asection *sgot;
2781   asection *sreloc;
2782 
2783   if (bfd_link_relocatable (info))
2784     return TRUE;
2785 
2786   dynobj = elf_hash_table (info)->dynobj;
2787   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2788   sym_hashes = elf_sym_hashes (abfd);
2789   extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info;
2790 
2791   if (dynobj == NULL)
2792     {
2793       sgot = NULL;
2794       g = NULL;
2795     }
2796   else
2797     {
2798       sgot = score_elf_got_section (dynobj, FALSE);
2799       if (sgot == NULL)
2800 	g = NULL;
2801       else
2802 	{
2803 	  BFD_ASSERT (score_elf_section_data (sgot) != NULL);
2804 	  g = score_elf_section_data (sgot)->u.got_info;
2805 	  BFD_ASSERT (g != NULL);
2806 	}
2807     }
2808 
2809   sreloc = NULL;
2810   rel_end = relocs + sec->reloc_count;
2811   for (rel = relocs; rel < rel_end; ++rel)
2812     {
2813       unsigned long r_symndx;
2814       unsigned int r_type;
2815       struct elf_link_hash_entry *h;
2816 
2817       r_symndx = ELF32_R_SYM (rel->r_info);
2818       r_type = ELF32_R_TYPE (rel->r_info);
2819 
2820       if (r_symndx < extsymoff)
2821 	{
2822 	  h = NULL;
2823 	}
2824       else if (r_symndx >= extsymoff + NUM_SHDR_ENTRIES (symtab_hdr))
2825 	{
2826 	  _bfd_error_handler
2827 	    /* xgettext:c-format */
2828 	    (_("%pB: malformed reloc detected for section %pA"), abfd, sec);
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 	}
2843 
2844       /* Some relocs require a global offset table.  */
2845       if (dynobj == NULL || sgot == NULL)
2846 	{
2847 	  switch (r_type)
2848 	    {
2849 	    case R_SCORE_GOT15:
2850 	    case R_SCORE_CALL15:
2851 	      if (dynobj == NULL)
2852 		elf_hash_table (info)->dynobj = dynobj = abfd;
2853 	      if (!score_elf_create_got_section (dynobj, info, FALSE))
2854 		return FALSE;
2855 	      g = score_elf_got_info (dynobj, &sgot);
2856 	      break;
2857 	    case R_SCORE_ABS32:
2858 	    case R_SCORE_REL32:
2859 	      if (dynobj == NULL
2860 		  && (bfd_link_pic (info) || h != NULL)
2861 		  && (sec->flags & SEC_ALLOC) != 0)
2862 		elf_hash_table (info)->dynobj = dynobj = abfd;
2863 	      break;
2864 	    default:
2865 	      break;
2866 	    }
2867 	}
2868 
2869       if (!h && (r_type == R_SCORE_GOT_LO16))
2870 	{
2871 	  if (! score_elf_record_local_got_symbol (abfd, r_symndx, rel->r_addend, g))
2872 	    return FALSE;
2873 	}
2874 
2875       switch (r_type)
2876 	{
2877 	case R_SCORE_CALL15:
2878 	  if (h == NULL)
2879 	    {
2880 	      _bfd_error_handler
2881 		/* xgettext:c-format */
2882 		(_("%pB: CALL15 reloc at %#" PRIx64 " not against global symbol"),
2883 		 abfd, (uint64_t) rel->r_offset);
2884 	      bfd_set_error (bfd_error_bad_value);
2885 	      return FALSE;
2886 	    }
2887 	  else
2888 	    {
2889 	      /* This symbol requires a global offset table entry.  */
2890 	      if (! score_elf_record_global_got_symbol (h, abfd, info, g))
2891 		return FALSE;
2892 
2893 	      /* We need a stub, not a plt entry for the undefined function.  But we record
2894 		 it as if it needs plt.  See _bfd_elf_adjust_dynamic_symbol.  */
2895 	      h->needs_plt = 1;
2896 	      h->type = STT_FUNC;
2897 	    }
2898 	  break;
2899 	case R_SCORE_GOT15:
2900 	  if (h && ! score_elf_record_global_got_symbol (h, abfd, info, g))
2901 	    return FALSE;
2902 	  break;
2903 	case R_SCORE_ABS32:
2904 	case R_SCORE_REL32:
2905 	  if ((bfd_link_pic (info) || h != NULL)
2906 	      && (sec->flags & SEC_ALLOC) != 0)
2907 	    {
2908 	      if (sreloc == NULL)
2909 		{
2910 		  sreloc = score_elf_rel_dyn_section (dynobj, TRUE);
2911 		  if (sreloc == NULL)
2912 		    return FALSE;
2913 		}
2914 #define SCORE_READONLY_SECTION (SEC_ALLOC | SEC_LOAD | SEC_READONLY)
2915 	      if (bfd_link_pic (info))
2916 		{
2917 		  /* When creating a shared object, we must copy these reloc types into
2918 		     the output file as R_SCORE_REL32 relocs.  We make room for this reloc
2919 		     in the .rel.dyn reloc section.  */
2920 		  score_elf_allocate_dynamic_relocations (dynobj, 1);
2921 		  if ((sec->flags & SCORE_READONLY_SECTION)
2922 		      == SCORE_READONLY_SECTION)
2923 		    /* We tell the dynamic linker that there are
2924 		       relocations against the text segment.  */
2925 		    info->flags |= DF_TEXTREL;
2926 		}
2927 	      else
2928 		{
2929 		  struct score_elf_link_hash_entry *hscore;
2930 
2931 		  /* We only need to copy this reloc if the symbol is
2932 		     defined in a dynamic object.  */
2933 		  hscore = (struct score_elf_link_hash_entry *)h;
2934 		  ++hscore->possibly_dynamic_relocs;
2935 		  if ((sec->flags & SCORE_READONLY_SECTION)
2936 		      == SCORE_READONLY_SECTION)
2937 		    /* We need it to tell the dynamic linker if there
2938 		       are relocations against the text segment.  */
2939 		    hscore->readonly_reloc = TRUE;
2940 		}
2941 
2942 	      /* Even though we don't directly need a GOT entry for this symbol,
2943 		 a symbol must have a dynamic symbol table index greater that
2944 		 DT_SCORE_GOTSYM if there are dynamic relocations against it.  */
2945 	      if (h != NULL)
2946 		{
2947 		  if (dynobj == NULL)
2948 		    elf_hash_table (info)->dynobj = dynobj = abfd;
2949 		  if (! score_elf_create_got_section (dynobj, info, TRUE))
2950 		    return FALSE;
2951 		  g = score_elf_got_info (dynobj, &sgot);
2952 		  if (! score_elf_record_global_got_symbol (h, abfd, info, g))
2953 		    return FALSE;
2954 		}
2955 	    }
2956 	  break;
2957 
2958 	  /* This relocation describes the C++ object vtable hierarchy.
2959 	     Reconstruct it for later use during GC.  */
2960 	case R_SCORE_GNU_VTINHERIT:
2961 	  if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2962 	    return FALSE;
2963 	  break;
2964 
2965 	  /* This relocation describes which C++ vtable entries are actually
2966 	     used.  Record for later use during GC.  */
2967 	case R_SCORE_GNU_VTENTRY:
2968 	  if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
2969 	    return FALSE;
2970 	  break;
2971 	default:
2972 	  break;
2973 	}
2974 
2975       /* We must not create a stub for a symbol that has relocations
2976 	 related to taking the function's address.  */
2977       switch (r_type)
2978 	{
2979 	default:
2980 	  if (h != NULL)
2981 	    {
2982 	      struct score_elf_link_hash_entry *sh;
2983 
2984 	      sh = (struct score_elf_link_hash_entry *) h;
2985 	      sh->no_fn_stub = TRUE;
2986 	    }
2987 	  break;
2988 	case R_SCORE_CALL15:
2989 	  break;
2990 	}
2991     }
2992 
2993   return TRUE;
2994 }
2995 
2996 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)2997 s3_bfd_score_elf_add_symbol_hook (bfd *abfd,
2998 				  struct bfd_link_info *info ATTRIBUTE_UNUSED,
2999 				  Elf_Internal_Sym *sym,
3000 				  const char **namep ATTRIBUTE_UNUSED,
3001 				  flagword *flagsp ATTRIBUTE_UNUSED,
3002 				  asection **secp,
3003 				  bfd_vma *valp)
3004 {
3005   switch (sym->st_shndx)
3006     {
3007     case SHN_COMMON:
3008       if (sym->st_size > elf_gp_size (abfd))
3009 	break;
3010       /* Fall through.  */
3011     case SHN_SCORE_SCOMMON:
3012       *secp = bfd_make_section_old_way (abfd, ".scommon");
3013       (*secp)->flags |= SEC_IS_COMMON | SEC_SMALL_DATA;
3014       *valp = sym->st_size;
3015       break;
3016     }
3017 
3018   return TRUE;
3019 }
3020 
3021 static void
s3_bfd_score_elf_symbol_processing(bfd * abfd,asymbol * asym)3022 s3_bfd_score_elf_symbol_processing (bfd *abfd, asymbol *asym)
3023 {
3024   elf_symbol_type *elfsym;
3025 
3026   elfsym = (elf_symbol_type *) asym;
3027   switch (elfsym->internal_elf_sym.st_shndx)
3028     {
3029     case SHN_COMMON:
3030       if (asym->value > elf_gp_size (abfd))
3031 	break;
3032       /* Fall through.  */
3033     case SHN_SCORE_SCOMMON:
3034       if (score_elf_scom_section.name == NULL)
3035 	{
3036 	  /* Initialize the small common section.  */
3037 	  score_elf_scom_section.name = ".scommon";
3038 	  score_elf_scom_section.flags = SEC_IS_COMMON | SEC_SMALL_DATA;
3039 	  score_elf_scom_section.output_section = &score_elf_scom_section;
3040 	  score_elf_scom_section.symbol = &score_elf_scom_symbol;
3041 	  score_elf_scom_section.symbol_ptr_ptr = &score_elf_scom_symbol_ptr;
3042 	  score_elf_scom_symbol.name = ".scommon";
3043 	  score_elf_scom_symbol.flags = BSF_SECTION_SYM;
3044 	  score_elf_scom_symbol.section = &score_elf_scom_section;
3045 	  score_elf_scom_symbol_ptr = &score_elf_scom_symbol;
3046 	}
3047       asym->section = &score_elf_scom_section;
3048       asym->value = elfsym->internal_elf_sym.st_size;
3049       break;
3050     }
3051 }
3052 
3053 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)3054 s3_bfd_score_elf_link_output_symbol_hook (struct bfd_link_info *info ATTRIBUTE_UNUSED,
3055 					  const char *name ATTRIBUTE_UNUSED,
3056 					  Elf_Internal_Sym *sym,
3057 					  asection *input_sec,
3058 					  struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
3059 {
3060   /* If we see a common symbol, which implies a relocatable link, then
3061      if a symbol was small common in an input file, mark it as small
3062      common in the output file.  */
3063   if (sym->st_shndx == SHN_COMMON && strcmp (input_sec->name, ".scommon") == 0)
3064     sym->st_shndx = SHN_SCORE_SCOMMON;
3065 
3066   return 1;
3067 }
3068 
3069 static bfd_boolean
s3_bfd_score_elf_section_from_bfd_section(bfd * abfd ATTRIBUTE_UNUSED,asection * sec,int * retval)3070 s3_bfd_score_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
3071 					   asection *sec,
3072 					   int *retval)
3073 {
3074   if (strcmp (bfd_section_name (sec), ".scommon") == 0)
3075     {
3076       *retval = SHN_SCORE_SCOMMON;
3077       return TRUE;
3078     }
3079 
3080   return FALSE;
3081 }
3082 
3083 /* Adjust a symbol defined by a dynamic object and referenced by a
3084    regular object.  The current definition is in some section of the
3085    dynamic object, but we're not including those sections.  We have to
3086    change the definition to something the rest of the link can understand.  */
3087 static bfd_boolean
s3_bfd_score_elf_adjust_dynamic_symbol(struct bfd_link_info * info,struct elf_link_hash_entry * h)3088 s3_bfd_score_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
3089 					struct elf_link_hash_entry *h)
3090 {
3091   bfd *dynobj;
3092   struct score_elf_link_hash_entry *hscore;
3093   asection *s;
3094 
3095   dynobj = elf_hash_table (info)->dynobj;
3096 
3097   /* Make sure we know what is going on here.  */
3098   BFD_ASSERT (dynobj != NULL
3099 	      && (h->needs_plt
3100 		  || h->is_weakalias
3101 		  || (h->def_dynamic && h->ref_regular && !h->def_regular)));
3102 
3103   /* If this symbol is defined in a dynamic object, we need to copy
3104      any R_SCORE_ABS32 or R_SCORE_REL32 relocs against it into the output
3105      file.  */
3106   hscore = (struct score_elf_link_hash_entry *)h;
3107   if (!bfd_link_relocatable (info)
3108       && hscore->possibly_dynamic_relocs != 0
3109       && (h->root.type == bfd_link_hash_defweak || !h->def_regular))
3110     {
3111       score_elf_allocate_dynamic_relocations (dynobj, hscore->possibly_dynamic_relocs);
3112       if (hscore->readonly_reloc)
3113 	/* We tell the dynamic linker that there are relocations
3114 	   against the text segment.  */
3115 	info->flags |= DF_TEXTREL;
3116     }
3117 
3118   /* For a function, create a stub, if allowed.  */
3119   if (!hscore->no_fn_stub && h->needs_plt)
3120     {
3121       if (!elf_hash_table (info)->dynamic_sections_created)
3122 	return TRUE;
3123 
3124       /* If this symbol is not defined in a regular file, then set
3125 	 the symbol to the stub location.  This is required to make
3126 	 function pointers compare as equal between the normal
3127 	 executable and the shared library.  */
3128       if (!h->def_regular)
3129 	{
3130 	  /* We need .stub section.  */
3131 	  s = bfd_get_linker_section (dynobj, SCORE_ELF_STUB_SECTION_NAME);
3132 	  BFD_ASSERT (s != NULL);
3133 
3134 	  h->root.u.def.section = s;
3135 	  h->root.u.def.value = s->size;
3136 
3137 	  /* XXX Write this stub address somewhere.  */
3138 	  h->plt.offset = s->size;
3139 
3140 	  /* Make room for this stub code.  */
3141 	  s->size += SCORE_FUNCTION_STUB_SIZE;
3142 
3143 	  /* The last half word of the stub will be filled with the index
3144 	     of this symbol in .dynsym section.  */
3145 	  return TRUE;
3146 	}
3147     }
3148   else if ((h->type == STT_FUNC) && !h->needs_plt)
3149     {
3150       /* This will set the entry for this symbol in the GOT to 0, and
3151 	 the dynamic linker will take care of this.  */
3152       h->root.u.def.value = 0;
3153       return TRUE;
3154     }
3155 
3156   /* If this is a weak symbol, and there is a real definition, the
3157      processor independent code will have arranged for us to see the
3158      real definition first, and we can just use the same value.  */
3159   if (h->is_weakalias)
3160     {
3161       struct elf_link_hash_entry *def = weakdef (h);
3162       BFD_ASSERT (def->root.type == bfd_link_hash_defined);
3163       h->root.u.def.section = def->root.u.def.section;
3164       h->root.u.def.value = def->root.u.def.value;
3165       return TRUE;
3166     }
3167 
3168   /* This is a reference to a symbol defined by a dynamic object which
3169      is not a function.  */
3170   return TRUE;
3171 }
3172 
3173 /* This function is called after all the input files have been read,
3174    and the input sections have been assigned to output sections.  */
3175 static bfd_boolean
s3_bfd_score_elf_always_size_sections(bfd * output_bfd,struct bfd_link_info * info)3176 s3_bfd_score_elf_always_size_sections (bfd *output_bfd,
3177 				       struct bfd_link_info *info)
3178 {
3179   bfd *dynobj;
3180   asection *s;
3181   struct score_got_info *g;
3182   int i;
3183   bfd_size_type loadable_size = 0;
3184   bfd_size_type local_gotno;
3185   bfd *sub;
3186 
3187   dynobj = elf_hash_table (info)->dynobj;
3188   if (dynobj == NULL)
3189     /* Relocatable links don't have it.  */
3190     return TRUE;
3191 
3192   g = score_elf_got_info (dynobj, &s);
3193   if (s == NULL)
3194     return TRUE;
3195 
3196   /* Calculate the total loadable size of the output.  That will give us the
3197      maximum number of GOT_PAGE entries required.  */
3198   for (sub = info->input_bfds; sub; sub = sub->link.next)
3199     {
3200       asection *subsection;
3201 
3202       for (subsection = sub->sections;
3203 	   subsection;
3204 	   subsection = subsection->next)
3205 	{
3206 	  if ((subsection->flags & SEC_ALLOC) == 0)
3207 	    continue;
3208 	  loadable_size += ((subsection->size + 0xf)
3209 			    &~ (bfd_size_type) 0xf);
3210 	}
3211     }
3212 
3213   /* There has to be a global GOT entry for every symbol with
3214      a dynamic symbol table index of DT_SCORE_GOTSYM or
3215      higher.  Therefore, it make sense to put those symbols
3216      that need GOT entries at the end of the symbol table.  We
3217      do that here.  */
3218   if (! score_elf_sort_hash_table (info, 1))
3219     return FALSE;
3220 
3221   if (g->global_gotsym != NULL)
3222     i = elf_hash_table (info)->dynsymcount - g->global_gotsym->dynindx;
3223   else
3224     /* If there are no global symbols, or none requiring
3225        relocations, then GLOBAL_GOTSYM will be NULL.  */
3226     i = 0;
3227 
3228   /* In the worst case, we'll get one stub per dynamic symbol.  */
3229   loadable_size += SCORE_FUNCTION_STUB_SIZE * i;
3230 
3231   /* Assume there are two loadable segments consisting of
3232      contiguous sections.  Is 5 enough?  */
3233   local_gotno = (loadable_size >> 16) + 5;
3234 
3235   g->local_gotno += local_gotno;
3236   s->size += g->local_gotno * SCORE_ELF_GOT_SIZE (output_bfd);
3237 
3238   g->global_gotno = i;
3239   s->size += i * SCORE_ELF_GOT_SIZE (output_bfd);
3240 
3241   score_elf_resolve_final_got_entries (g);
3242 
3243   if (s->size > SCORE_ELF_GOT_MAX_SIZE (output_bfd))
3244     {
3245       /* Fixme. Error message or Warning message should be issued here.  */
3246     }
3247 
3248   return TRUE;
3249 }
3250 
3251 /* Set the sizes of the dynamic sections.  */
3252 static bfd_boolean
s3_bfd_score_elf_size_dynamic_sections(bfd * output_bfd,struct bfd_link_info * info)3253 s3_bfd_score_elf_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info)
3254 {
3255   bfd *dynobj;
3256   asection *s;
3257   bfd_boolean reltext;
3258 
3259   dynobj = elf_hash_table (info)->dynobj;
3260   BFD_ASSERT (dynobj != NULL);
3261 
3262   if (elf_hash_table (info)->dynamic_sections_created)
3263     {
3264       /* Set the contents of the .interp section to the interpreter.  */
3265       if (bfd_link_executable (info) && !info->nointerp)
3266 	{
3267 	  s = bfd_get_linker_section (dynobj, ".interp");
3268 	  BFD_ASSERT (s != NULL);
3269 	  s->size = strlen (ELF_DYNAMIC_INTERPRETER) + 1;
3270 	  s->contents = (bfd_byte *) ELF_DYNAMIC_INTERPRETER;
3271 	}
3272     }
3273 
3274   /* The check_relocs and adjust_dynamic_symbol entry points have
3275      determined the sizes of the various dynamic sections.  Allocate
3276      memory for them.  */
3277   reltext = FALSE;
3278   for (s = dynobj->sections; s != NULL; s = s->next)
3279     {
3280       const char *name;
3281 
3282       if ((s->flags & SEC_LINKER_CREATED) == 0)
3283 	continue;
3284 
3285       /* It's OK to base decisions on the section name, because none
3286 	 of the dynobj section names depend upon the input files.  */
3287       name = bfd_section_name (s);
3288 
3289       if (CONST_STRNEQ (name, ".rel"))
3290 	{
3291 	  if (s->size == 0)
3292 	    {
3293 	      /* We only strip the section if the output section name
3294 		 has the same name.  Otherwise, there might be several
3295 		 input sections for this output section.  FIXME: This
3296 		 code is probably not needed these days anyhow, since
3297 		 the linker now does not create empty output sections.  */
3298 	      if (s->output_section != NULL
3299 		  && strcmp (name,
3300 			     bfd_section_name (s->output_section)) == 0)
3301 		s->flags |= SEC_EXCLUDE;
3302 	    }
3303 	  else
3304 	    {
3305 	      const char *outname;
3306 	      asection *target;
3307 
3308 	      /* If this relocation section applies to a read only
3309 		 section, then we probably need a DT_TEXTREL entry.
3310 		 If the relocation section is .rel.dyn, we always
3311 		 assert a DT_TEXTREL entry rather than testing whether
3312 		 there exists a relocation to a read only section or
3313 		 not.  */
3314 	      outname = bfd_section_name (s->output_section);
3315 	      target = bfd_get_section_by_name (output_bfd, outname + 4);
3316 	      if ((target != NULL
3317 		   && (target->flags & SEC_READONLY) != 0
3318 		   && (target->flags & SEC_ALLOC) != 0) || strcmp (outname, ".rel.dyn") == 0)
3319 		reltext = TRUE;
3320 
3321 	      /* We use the reloc_count field as a counter if we need
3322 		 to copy relocs into the output file.  */
3323 	      if (strcmp (name, ".rel.dyn") != 0)
3324 		s->reloc_count = 0;
3325 	    }
3326 	}
3327       else if (CONST_STRNEQ (name, ".got"))
3328 	{
3329 	  /* s3_bfd_score_elf_always_size_sections() has already done
3330 	     most of the work, but some symbols may have been mapped
3331 	     to versions that we must now resolve in the got_entries
3332 	     hash tables.  */
3333 	}
3334       else if (strcmp (name, SCORE_ELF_STUB_SECTION_NAME) == 0)
3335 	{
3336 	  /* IRIX rld assumes that the function stub isn't at the end
3337 	     of .text section. So put a dummy. XXX  */
3338 	  s->size += SCORE_FUNCTION_STUB_SIZE;
3339 	}
3340       else if (! CONST_STRNEQ (name, ".init"))
3341 	{
3342 	  /* It's not one of our sections, so don't allocate space.  */
3343 	  continue;
3344 	}
3345 
3346       /* Allocate memory for the section contents.  */
3347       s->contents = bfd_zalloc (dynobj, s->size);
3348       if (s->contents == NULL && s->size != 0)
3349 	{
3350 	  bfd_set_error (bfd_error_no_memory);
3351 	  return FALSE;
3352 	}
3353     }
3354 
3355   if (elf_hash_table (info)->dynamic_sections_created)
3356     {
3357       /* Add some entries to the .dynamic section.  We fill in the
3358 	 values later, in s3_bfd_score_elf_finish_dynamic_sections, but we
3359 	 must add the entries now so that we get the correct size for
3360 	 the .dynamic section.  The DT_DEBUG entry is filled in by the
3361 	 dynamic linker and used by the debugger.  */
3362 
3363       if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_DEBUG, 0))
3364 	return FALSE;
3365 
3366       if (reltext)
3367 	info->flags |= DF_TEXTREL;
3368 
3369       if ((info->flags & DF_TEXTREL) != 0)
3370 	{
3371 	  if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_TEXTREL, 0))
3372 	    return FALSE;
3373 	}
3374 
3375       if (! SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTGOT, 0))
3376 	return FALSE;
3377 
3378       if (score_elf_rel_dyn_section (dynobj, FALSE))
3379 	{
3380 	  if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_REL, 0))
3381 	    return FALSE;
3382 
3383 	  if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELSZ, 0))
3384 	    return FALSE;
3385 
3386 	  if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELENT, 0))
3387 	    return FALSE;
3388 	}
3389 
3390       if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_SCORE_BASE_ADDRESS, 0))
3391 	return FALSE;
3392 
3393       if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_SCORE_LOCAL_GOTNO, 0))
3394 	return FALSE;
3395 
3396       if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_SCORE_SYMTABNO, 0))
3397 	return FALSE;
3398 
3399       if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_SCORE_UNREFEXTNO, 0))
3400 	return FALSE;
3401 
3402       if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_SCORE_GOTSYM, 0))
3403 	return FALSE;
3404 
3405       if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_SCORE_HIPAGENO, 0))
3406 	return FALSE;
3407     }
3408 
3409   return TRUE;
3410 }
3411 
3412 static bfd_boolean
s3_bfd_score_elf_create_dynamic_sections(bfd * abfd,struct bfd_link_info * info)3413 s3_bfd_score_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
3414 {
3415   struct elf_link_hash_entry *h;
3416   struct bfd_link_hash_entry *bh;
3417   flagword flags;
3418   asection *s;
3419 
3420   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
3421 	   | SEC_LINKER_CREATED | SEC_READONLY);
3422 
3423   /* ABI requests the .dynamic section to be read only.  */
3424   s = bfd_get_linker_section (abfd, ".dynamic");
3425   if (s != NULL)
3426     {
3427       if (!bfd_set_section_flags (s, flags))
3428 	return FALSE;
3429     }
3430 
3431   /* We need to create .got section.  */
3432   if (!score_elf_create_got_section (abfd, info, FALSE))
3433     return FALSE;
3434 
3435   if (!score_elf_rel_dyn_section (elf_hash_table (info)->dynobj, TRUE))
3436     return FALSE;
3437 
3438   /* Create .stub section.  */
3439   if (bfd_get_linker_section (abfd, SCORE_ELF_STUB_SECTION_NAME) == NULL)
3440     {
3441       s = bfd_make_section_anyway_with_flags (abfd, SCORE_ELF_STUB_SECTION_NAME,
3442 					      flags | SEC_CODE);
3443       if (s == NULL
3444 	  || !bfd_set_section_alignment (s, 2))
3445 
3446 	return FALSE;
3447     }
3448 
3449   if (!bfd_link_pic (info))
3450     {
3451       const char *name;
3452 
3453       name = "_DYNAMIC_LINK";
3454       bh = NULL;
3455       if (!(_bfd_generic_link_add_one_symbol
3456 	    (info, abfd, name, BSF_GLOBAL, bfd_abs_section_ptr,
3457 	     (bfd_vma) 0, NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh)))
3458 	return FALSE;
3459 
3460       h = (struct elf_link_hash_entry *)bh;
3461       h->non_elf = 0;
3462       h->def_regular = 1;
3463       h->type = STT_SECTION;
3464 
3465       if (!bfd_elf_link_record_dynamic_symbol (info, h))
3466 	return FALSE;
3467     }
3468 
3469   return TRUE;
3470 }
3471 
3472 
3473 /* Finish up dynamic symbol handling.  We set the contents of various
3474    dynamic sections here.  */
3475 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)3476 s3_bfd_score_elf_finish_dynamic_symbol (bfd *output_bfd,
3477 					struct bfd_link_info *info,
3478 					struct elf_link_hash_entry *h,
3479 					Elf_Internal_Sym *sym)
3480 {
3481   bfd *dynobj;
3482   asection *sgot;
3483   struct score_got_info *g;
3484   const char *name;
3485 
3486   dynobj = elf_hash_table (info)->dynobj;
3487 
3488   if (h->plt.offset != MINUS_ONE)
3489     {
3490       asection *s;
3491       bfd_byte stub[SCORE_FUNCTION_STUB_SIZE];
3492 
3493       /* This symbol has a stub.  Set it up.  */
3494       BFD_ASSERT (h->dynindx != -1);
3495 
3496       s = bfd_get_linker_section (dynobj, SCORE_ELF_STUB_SECTION_NAME);
3497       BFD_ASSERT (s != NULL);
3498 
3499       /* FIXME: Can h->dynindex be more than 64K?  */
3500       if (h->dynindx & 0xffff0000)
3501 	return FALSE;
3502 
3503       /* Fill the stub.  */
3504       score_bfd_put_32 (output_bfd, STUB_LW, stub);
3505       score_bfd_put_32 (output_bfd, STUB_MOVE, stub + 4);
3506       score_bfd_put_32 (output_bfd, STUB_LI16 | (h->dynindx << 1), stub + 8);
3507       score_bfd_put_32 (output_bfd, STUB_BRL, stub + 12);
3508 
3509       BFD_ASSERT (h->plt.offset <= s->size);
3510       memcpy (s->contents + h->plt.offset, stub, SCORE_FUNCTION_STUB_SIZE);
3511 
3512       /* Mark the symbol as undefined.  plt.offset != -1 occurs
3513 	 only for the referenced symbol.  */
3514       sym->st_shndx = SHN_UNDEF;
3515 
3516       /* The run-time linker uses the st_value field of the symbol
3517 	  to reset the global offset table entry for this external
3518 	  to its stub address when unlinking a shared object.  */
3519       sym->st_value = (s->output_section->vma + s->output_offset + h->plt.offset);
3520     }
3521 
3522   BFD_ASSERT (h->dynindx != -1 || h->forced_local);
3523 
3524   sgot = score_elf_got_section (dynobj, FALSE);
3525   BFD_ASSERT (sgot != NULL);
3526   BFD_ASSERT (score_elf_section_data (sgot) != NULL);
3527   g = score_elf_section_data (sgot)->u.got_info;
3528   BFD_ASSERT (g != NULL);
3529 
3530   /* Run through the global symbol table, creating GOT entries for all
3531      the symbols that need them.  */
3532   if (g->global_gotsym != NULL && h->dynindx >= g->global_gotsym->dynindx)
3533     {
3534       bfd_vma offset;
3535       bfd_vma value;
3536 
3537       value = sym->st_value;
3538       offset = score_elf_global_got_index (dynobj, h);
3539       score_bfd_put_32 (output_bfd, value, sgot->contents + offset);
3540     }
3541 
3542   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
3543   name = h->root.root.string;
3544   if (h == elf_hash_table (info)->hdynamic
3545       || h == elf_hash_table (info)->hgot)
3546     sym->st_shndx = SHN_ABS;
3547   else if (strcmp (name, "_DYNAMIC_LINK") == 0)
3548     {
3549       sym->st_shndx = SHN_ABS;
3550       sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
3551       sym->st_value = 1;
3552     }
3553   else if (strcmp (name, GP_DISP_LABEL) == 0)
3554     {
3555       sym->st_shndx = SHN_ABS;
3556       sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
3557       sym->st_value = elf_gp (output_bfd);
3558     }
3559 
3560   return TRUE;
3561 }
3562 
3563 /* Finish up the dynamic sections.  */
3564 static bfd_boolean
s3_bfd_score_elf_finish_dynamic_sections(bfd * output_bfd,struct bfd_link_info * info)3565 s3_bfd_score_elf_finish_dynamic_sections (bfd *output_bfd,
3566 					  struct bfd_link_info *info)
3567 {
3568   bfd *dynobj;
3569   asection *sdyn;
3570   asection *sgot;
3571   asection *s;
3572   struct score_got_info *g;
3573 
3574   dynobj = elf_hash_table (info)->dynobj;
3575 
3576   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
3577 
3578   sgot = score_elf_got_section (dynobj, FALSE);
3579   if (sgot == NULL)
3580     g = NULL;
3581   else
3582     {
3583       BFD_ASSERT (score_elf_section_data (sgot) != NULL);
3584       g = score_elf_section_data (sgot)->u.got_info;
3585       BFD_ASSERT (g != NULL);
3586     }
3587 
3588   if (elf_hash_table (info)->dynamic_sections_created)
3589     {
3590       bfd_byte *b;
3591 
3592       BFD_ASSERT (sdyn != NULL);
3593       BFD_ASSERT (g != NULL);
3594 
3595       for (b = sdyn->contents;
3596 	   b < sdyn->contents + sdyn->size;
3597 	   b += SCORE_ELF_DYN_SIZE (dynobj))
3598 	{
3599 	  Elf_Internal_Dyn dyn;
3600 	  const char *name;
3601 	  size_t elemsize;
3602 	  bfd_boolean swap_out_p;
3603 
3604 	  /* Read in the current dynamic entry.  */
3605 	  (*get_elf_backend_data (dynobj)->s->swap_dyn_in) (dynobj, b, &dyn);
3606 
3607 	  /* Assume that we're going to modify it and write it out.  */
3608 	  swap_out_p = TRUE;
3609 
3610 	  switch (dyn.d_tag)
3611 	    {
3612 	    case DT_RELENT:
3613 	      dyn.d_un.d_val = SCORE_ELF_REL_SIZE (dynobj);
3614 	      break;
3615 
3616 	    case DT_STRSZ:
3617 	      /* Rewrite DT_STRSZ.  */
3618 	      dyn.d_un.d_val
3619 		= _bfd_elf_strtab_size (elf_hash_table (info)->dynstr);
3620 	      break;
3621 
3622 	    case DT_PLTGOT:
3623 	      s = elf_hash_table (info)->sgot;
3624 	      dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
3625 	      break;
3626 
3627 	    case DT_SCORE_BASE_ADDRESS:
3628 	      s = output_bfd->sections;
3629 	      BFD_ASSERT (s != NULL);
3630 	      dyn.d_un.d_ptr = s->vma & ~(bfd_vma) 0xffff;
3631 	      break;
3632 
3633 	    case DT_SCORE_LOCAL_GOTNO:
3634 	      dyn.d_un.d_val = g->local_gotno;
3635 	      break;
3636 
3637 	    case DT_SCORE_UNREFEXTNO:
3638 	      /* The index into the dynamic symbol table which is the
3639 		 entry of the first external symbol that is not
3640 		 referenced within the same object.  */
3641 	      dyn.d_un.d_val = bfd_count_sections (output_bfd) + 1;
3642 	      break;
3643 
3644 	    case DT_SCORE_GOTSYM:
3645 	      if (g->global_gotsym)
3646 		{
3647 		  dyn.d_un.d_val = g->global_gotsym->dynindx;
3648 		  break;
3649 		}
3650 	      /* In case if we don't have global got symbols we default
3651 		  to setting DT_SCORE_GOTSYM to the same value as
3652 		  DT_SCORE_SYMTABNO.  */
3653 	      /* Fall through.  */
3654 
3655 	    case DT_SCORE_SYMTABNO:
3656 	      name = ".dynsym";
3657 	      elemsize = SCORE_ELF_SYM_SIZE (output_bfd);
3658 	      s = bfd_get_linker_section (dynobj, name);
3659 	      dyn.d_un.d_val = s->size / elemsize;
3660 	      break;
3661 
3662 	    case DT_SCORE_HIPAGENO:
3663 	      dyn.d_un.d_val = g->local_gotno - SCORE_RESERVED_GOTNO;
3664 	      break;
3665 
3666 	    default:
3667 	      swap_out_p = FALSE;
3668 	      break;
3669 	    }
3670 
3671 	  if (swap_out_p)
3672 	    (*get_elf_backend_data (dynobj)->s->swap_dyn_out) (dynobj, &dyn, b);
3673 	}
3674     }
3675 
3676   /* The first entry of the global offset table will be filled at
3677      runtime. The second entry will be used by some runtime loaders.
3678      This isn't the case of IRIX rld.  */
3679   if (sgot != NULL && sgot->size > 0)
3680     {
3681       score_bfd_put_32 (output_bfd, 0, sgot->contents);
3682       score_bfd_put_32 (output_bfd, 0x80000000, sgot->contents + SCORE_ELF_GOT_SIZE (output_bfd));
3683     }
3684 
3685   if (sgot != NULL)
3686     elf_section_data (sgot->output_section)->this_hdr.sh_entsize
3687       = SCORE_ELF_GOT_SIZE (output_bfd);
3688 
3689 
3690   /* We need to sort the entries of the dynamic relocation section.  */
3691   s = score_elf_rel_dyn_section (dynobj, FALSE);
3692 
3693   if (s != NULL && s->size > (bfd_vma)2 * SCORE_ELF_REL_SIZE (output_bfd))
3694     {
3695       reldyn_sorting_bfd = output_bfd;
3696       qsort ((Elf32_External_Rel *) s->contents + 1, s->reloc_count - 1,
3697 	     sizeof (Elf32_External_Rel), score_elf_sort_dynamic_relocs);
3698     }
3699 
3700   return TRUE;
3701 }
3702 
3703 /* This function set up the ELF section header for a BFD section in preparation for writing
3704    it out.  This is where the flags and type fields are set for unusual sections.  */
3705 static bfd_boolean
s3_bfd_score_elf_fake_sections(bfd * abfd ATTRIBUTE_UNUSED,Elf_Internal_Shdr * hdr,asection * sec)3706 s3_bfd_score_elf_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
3707 				Elf_Internal_Shdr *hdr,
3708 				asection *sec)
3709 {
3710   const char *name;
3711 
3712   name = bfd_section_name (sec);
3713 
3714   if (strcmp (name, ".got") == 0
3715       || strcmp (name, ".srdata") == 0
3716       || strcmp (name, ".sdata") == 0
3717       || strcmp (name, ".sbss") == 0)
3718     hdr->sh_flags |= SHF_SCORE_GPREL;
3719 
3720   return TRUE;
3721 }
3722 
3723 /* This function do additional processing on the ELF section header before writing
3724    it out.  This is used to set the flags and type fields for some sections.  */
3725 
3726 /* assign_file_positions_except_relocs() check section flag and if it is allocatable,
3727    warning message will be issued.  backend_fake_section is called before
3728    assign_file_positions_except_relocs(); backend_section_processing after it.  so, we
3729    modify section flag there, but not backend_fake_section.  */
3730 static bfd_boolean
s3_bfd_score_elf_section_processing(bfd * abfd ATTRIBUTE_UNUSED,Elf_Internal_Shdr * hdr)3731 s3_bfd_score_elf_section_processing (bfd *abfd ATTRIBUTE_UNUSED, Elf_Internal_Shdr *hdr)
3732 {
3733   if (hdr->bfd_section != NULL)
3734     {
3735       const char *name = bfd_section_name (hdr->bfd_section);
3736 
3737       if (strcmp (name, ".sdata") == 0)
3738 	{
3739 	  hdr->sh_flags |= SHF_ALLOC | SHF_WRITE | SHF_SCORE_GPREL;
3740 	  hdr->sh_type = SHT_PROGBITS;
3741 	}
3742       else if (strcmp (name, ".sbss") == 0)
3743 	{
3744 	  hdr->sh_flags |= SHF_ALLOC | SHF_WRITE | SHF_SCORE_GPREL;
3745 	  hdr->sh_type = SHT_NOBITS;
3746 	}
3747       else if (strcmp (name, ".srdata") == 0)
3748 	{
3749 	  hdr->sh_flags |= SHF_ALLOC | SHF_SCORE_GPREL;
3750 	  hdr->sh_type = SHT_PROGBITS;
3751 	}
3752     }
3753 
3754   return TRUE;
3755 }
3756 
3757 static bfd_boolean
s3_bfd_score_elf_write_section(bfd * output_bfd,asection * sec,bfd_byte * contents)3758 s3_bfd_score_elf_write_section (bfd *output_bfd, asection *sec, bfd_byte *contents)
3759 {
3760   bfd_byte *to, *from, *end;
3761   int i;
3762 
3763   if (strcmp (sec->name, ".pdr") != 0)
3764     return FALSE;
3765 
3766   if (score_elf_section_data (sec)->u.tdata == NULL)
3767     return FALSE;
3768 
3769   to = contents;
3770   end = contents + sec->size;
3771   for (from = contents, i = 0; from < end; from += PDR_SIZE, i++)
3772     {
3773       if ((score_elf_section_data (sec)->u.tdata)[i] == 1)
3774 	continue;
3775 
3776       if (to != from)
3777 	memcpy (to, from, PDR_SIZE);
3778 
3779       to += PDR_SIZE;
3780     }
3781   bfd_set_section_contents (output_bfd, sec->output_section, contents,
3782 			    (file_ptr) sec->output_offset, sec->size);
3783 
3784   return TRUE;
3785 }
3786 
3787 /* Copy data from a SCORE ELF indirect symbol to its direct symbol, hiding the old
3788    indirect symbol.  Process additional relocation information.  */
3789 static void
s3_bfd_score_elf_copy_indirect_symbol(struct bfd_link_info * info,struct elf_link_hash_entry * dir,struct elf_link_hash_entry * ind)3790 s3_bfd_score_elf_copy_indirect_symbol (struct bfd_link_info *info,
3791 				       struct elf_link_hash_entry *dir,
3792 				       struct elf_link_hash_entry *ind)
3793 {
3794   struct score_elf_link_hash_entry *dirscore, *indscore;
3795 
3796   _bfd_elf_link_hash_copy_indirect (info, dir, ind);
3797 
3798   if (ind->root.type != bfd_link_hash_indirect)
3799     return;
3800 
3801   dirscore = (struct score_elf_link_hash_entry *) dir;
3802   indscore = (struct score_elf_link_hash_entry *) ind;
3803   dirscore->possibly_dynamic_relocs += indscore->possibly_dynamic_relocs;
3804 
3805   if (indscore->readonly_reloc)
3806     dirscore->readonly_reloc = TRUE;
3807 
3808   if (indscore->no_fn_stub)
3809     dirscore->no_fn_stub = TRUE;
3810 }
3811 
3812 /* Remove information about discarded functions from other sections which mention them.  */
3813 static bfd_boolean
s3_bfd_score_elf_discard_info(bfd * abfd,struct elf_reloc_cookie * cookie,struct bfd_link_info * info)3814 s3_bfd_score_elf_discard_info (bfd *abfd, struct elf_reloc_cookie *cookie,
3815 			       struct bfd_link_info *info)
3816 {
3817   asection *o;
3818   bfd_boolean ret = FALSE;
3819   unsigned char *tdata;
3820   size_t i, skip;
3821 
3822   o = bfd_get_section_by_name (abfd, ".pdr");
3823   if ((!o) || (o->size == 0) || (o->size % PDR_SIZE != 0)
3824       || (o->output_section != NULL && bfd_is_abs_section (o->output_section)))
3825     return FALSE;
3826 
3827   tdata = bfd_zmalloc (o->size / PDR_SIZE);
3828   if (!tdata)
3829     return FALSE;
3830 
3831   cookie->rels = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL, info->keep_memory);
3832   if (!cookie->rels)
3833     {
3834       free (tdata);
3835       return FALSE;
3836     }
3837 
3838   cookie->rel = cookie->rels;
3839   cookie->relend = cookie->rels + o->reloc_count;
3840 
3841   for (i = 0, skip = 0; i < o->size; i++)
3842     {
3843       if (bfd_elf_reloc_symbol_deleted_p (i * PDR_SIZE, cookie))
3844 	{
3845 	  tdata[i] = 1;
3846 	  skip++;
3847 	}
3848     }
3849 
3850   if (skip != 0)
3851     {
3852       score_elf_section_data (o)->u.tdata = tdata;
3853       o->size -= skip * PDR_SIZE;
3854       ret = TRUE;
3855     }
3856   else
3857     free (tdata);
3858 
3859   if (!info->keep_memory)
3860     free (cookie->rels);
3861 
3862   return ret;
3863 }
3864 
3865 /* Signal that discard_info() has removed the discarded relocations for this section.  */
3866 static bfd_boolean
s3_bfd_score_elf_ignore_discarded_relocs(asection * sec)3867 s3_bfd_score_elf_ignore_discarded_relocs (asection *sec)
3868 {
3869   if (strcmp (sec->name, ".pdr") == 0)
3870     return TRUE;
3871   return FALSE;
3872 }
3873 
3874 /* Return the section that should be marked against GC for a given
3875    relocation.  */
3876 static asection *
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)3877 s3_bfd_score_elf_gc_mark_hook (asection *sec,
3878 			       struct bfd_link_info *info,
3879 			       Elf_Internal_Rela *rel,
3880 			       struct elf_link_hash_entry *h,
3881 			       Elf_Internal_Sym *sym)
3882 {
3883   if (h != NULL)
3884     switch (ELF32_R_TYPE (rel->r_info))
3885       {
3886       case R_SCORE_GNU_VTINHERIT:
3887       case R_SCORE_GNU_VTENTRY:
3888 	return NULL;
3889       }
3890 
3891   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
3892 }
3893 
3894 /* Support for core dump NOTE sections.  */
3895 
3896 static bfd_boolean
s3_bfd_score_elf_grok_prstatus(bfd * abfd,Elf_Internal_Note * note)3897 s3_bfd_score_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
3898 {
3899   int offset;
3900   unsigned int raw_size;
3901 
3902   switch (note->descsz)
3903     {
3904     default:
3905       return FALSE;
3906 
3907     case 148:		       /* Linux/Score 32-bit.  */
3908       /* pr_cursig */
3909       elf_tdata (abfd)->core->signal
3910 	= score_bfd_get_16 (abfd, note->descdata + 12);
3911 
3912       /* pr_pid */
3913       elf_tdata (abfd)->core->lwpid
3914 	= score_bfd_get_32 (abfd, note->descdata + 24);
3915 
3916       /* pr_reg */
3917       offset = 72;
3918       raw_size = 72;
3919 
3920       break;
3921     }
3922 
3923   /* Make a ".reg/999" section.  */
3924   return _bfd_elfcore_make_pseudosection (abfd, ".reg", raw_size,
3925 					  note->descpos + offset);
3926 }
3927 
3928 static bfd_boolean
s3_bfd_score_elf_grok_psinfo(bfd * abfd,Elf_Internal_Note * note)3929 s3_bfd_score_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
3930 {
3931   switch (note->descsz)
3932     {
3933     default:
3934       return FALSE;
3935 
3936     case 124:		       /* Linux/Score elf_prpsinfo.  */
3937       elf_tdata (abfd)->core->program
3938 	= _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
3939       elf_tdata (abfd)->core->command
3940 	= _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
3941     }
3942 
3943   /* Note that for some reason, a spurious space is tacked
3944      onto the end of the args in some (at least one anyway)
3945      implementations, so strip it off if it exists.  */
3946 
3947   {
3948     char *command = elf_tdata (abfd)->core->command;
3949     int n = strlen (command);
3950 
3951     if (0 < n && command[n - 1] == ' ')
3952       command[n - 1] = '\0';
3953   }
3954 
3955   return TRUE;
3956 }
3957 
3958 
3959 /* Score BFD functions.  */
3960 static reloc_howto_type *
s3_elf32_score_reloc_type_lookup(bfd * abfd ATTRIBUTE_UNUSED,bfd_reloc_code_real_type code)3961 s3_elf32_score_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED, bfd_reloc_code_real_type code)
3962 {
3963   unsigned int i;
3964 
3965   for (i = 0; i < ARRAY_SIZE (elf32_score_reloc_map); i++)
3966     if (elf32_score_reloc_map[i].bfd_reloc_val == code)
3967       return &elf32_score_howto_table[elf32_score_reloc_map[i].elf_reloc_val];
3968 
3969   return NULL;
3970 }
3971 
3972 static reloc_howto_type *
elf32_score_reloc_name_lookup(bfd * abfd ATTRIBUTE_UNUSED,const char * r_name)3973 elf32_score_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
3974 			       const char *r_name)
3975 {
3976   unsigned int i;
3977 
3978   for (i = 0;
3979        i < (sizeof (elf32_score_howto_table)
3980 	    / sizeof (elf32_score_howto_table[0]));
3981        i++)
3982     if (elf32_score_howto_table[i].name != NULL
3983 	&& strcasecmp (elf32_score_howto_table[i].name, r_name) == 0)
3984       return &elf32_score_howto_table[i];
3985 
3986   return NULL;
3987 }
3988 
3989 static bfd_boolean
s3_elf32_score_print_private_bfd_data(bfd * abfd,void * ptr)3990 s3_elf32_score_print_private_bfd_data (bfd *abfd, void * ptr)
3991 {
3992   FILE *file = (FILE *) ptr;
3993 
3994   BFD_ASSERT (abfd != NULL && ptr != NULL);
3995 
3996   /* Print normal ELF private data.  */
3997   _bfd_elf_print_private_bfd_data (abfd, ptr);
3998 
3999   /* xgettext:c-format */
4000   fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
4001   if (elf_elfheader (abfd)->e_flags & EF_SCORE_PIC)
4002     {
4003       fprintf (file, _(" [pic]"));
4004     }
4005   if (elf_elfheader (abfd)->e_flags & EF_SCORE_FIXDEP)
4006     {
4007       fprintf (file, _(" [fix dep]"));
4008     }
4009   fputc ('\n', file);
4010 
4011   return TRUE;
4012 }
4013 
4014 static bfd_boolean
s3_elf32_score_merge_private_bfd_data(bfd * ibfd,struct bfd_link_info * info)4015 s3_elf32_score_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
4016 {
4017   bfd *obfd = info->output_bfd;
4018   flagword in_flags;
4019   flagword out_flags;
4020 
4021   if (!_bfd_generic_verify_endian_match (ibfd, info))
4022     return FALSE;
4023 
4024   /* FIXME: What should be checked when linking shared libraries?  */
4025   if ((ibfd->flags & DYNAMIC) != 0)
4026     return TRUE;
4027 
4028   in_flags  = elf_elfheader (ibfd)->e_flags;
4029   out_flags = elf_elfheader (obfd)->e_flags;
4030 
4031   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4032       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4033     return TRUE;
4034 
4035   in_flags = elf_elfheader (ibfd)->e_flags;
4036   out_flags = elf_elfheader (obfd)->e_flags;
4037 
4038   if (! elf_flags_init (obfd))
4039     {
4040       elf_flags_init (obfd) = TRUE;
4041       elf_elfheader (obfd)->e_flags = in_flags;
4042 
4043       if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
4044 	  && bfd_get_arch_info (obfd)->the_default)
4045 	{
4046 	  return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
4047 	}
4048 
4049       return TRUE;
4050     }
4051 
4052   if (((in_flags & EF_SCORE_PIC) != 0) != ((out_flags & EF_SCORE_PIC) != 0))
4053     _bfd_error_handler
4054       (_("%pB: warning: linking PIC files with non-PIC files"), ibfd);
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   size_t 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 bfd_boolean
_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   size_t 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,struct bfd_link_info * info)4394 elf32_score_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
4395 {
4396   if (bfd_get_mach (info->output_bfd) == bfd_mach_score3)
4397     return s3_elf32_score_merge_private_bfd_data (ibfd, info);
4398   else
4399     return s7_elf32_score_merge_private_bfd_data (ibfd, info);
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		NULL
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   _bfd_elf_omit_section_dynsym_all
4476 #define elf_backend_create_dynamic_sections \
4477   _bfd_score_elf_create_dynamic_sections
4478 #define elf_backend_finish_dynamic_symbol \
4479   _bfd_score_elf_finish_dynamic_symbol
4480 #define elf_backend_finish_dynamic_sections \
4481   _bfd_score_elf_finish_dynamic_sections
4482 #define elf_backend_fake_sections	  _bfd_score_elf_fake_sections
4483 #define elf_backend_section_processing	  _bfd_score_elf_section_processing
4484 #define elf_backend_write_section	  _bfd_score_elf_write_section
4485 #define elf_backend_copy_indirect_symbol  _bfd_score_elf_copy_indirect_symbol
4486 #define elf_backend_hide_symbol		  _bfd_score_elf_hide_symbol
4487 #define elf_backend_discard_info	  _bfd_score_elf_discard_info
4488 #define elf_backend_ignore_discarded_relocs \
4489   _bfd_score_elf_ignore_discarded_relocs
4490 #define elf_backend_gc_mark_hook	  _bfd_score_elf_gc_mark_hook
4491 #define elf_backend_grok_prstatus	  _bfd_score_elf_grok_prstatus
4492 #define elf_backend_grok_psinfo		  _bfd_score_elf_grok_psinfo
4493 #define elf_backend_can_gc_sections	  1
4494 #define elf_backend_want_plt_sym	  0
4495 #define elf_backend_got_header_size	  (4 * SCORE_RESERVED_GOTNO)
4496 #define elf_backend_plt_header_size	  0
4497 #define elf_backend_collect		  TRUE
4498 #define elf_backend_type_change_ok	  TRUE
4499 #define elf_backend_object_p		      _bfd_score_elf_score_object_p
4500 
4501 #define bfd_elf32_bfd_reloc_type_lookup	     elf32_score_reloc_type_lookup
4502 #define bfd_elf32_bfd_reloc_name_lookup \
4503   elf32_score_reloc_name_lookup
4504 #define bfd_elf32_bfd_link_hash_table_create elf32_score_link_hash_table_create
4505 #define bfd_elf32_bfd_print_private_bfd_data elf32_score_print_private_bfd_data
4506 #define bfd_elf32_bfd_merge_private_bfd_data elf32_score_merge_private_bfd_data
4507 #define bfd_elf32_new_section_hook	     elf32_score_new_section_hook
4508 
4509 #include "elf32-target.h"
4510