OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [binutils-2.20.1/] [bfd/] [elf32-score.c] - Blame information for rev 818

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.